From cfb3caad1a567ad51cf633838d89c46db9c22a31 Mon Sep 17 00:00:00 2001 From: wangchongwu <759291707@qq.com> Date: Thu, 21 Aug 2025 17:40:10 +0800 Subject: [PATCH] =?UTF-8?q?=E8=BF=9B=E4=B8=80=E6=AD=A5=E4=BF=AE=E6=94=B9?= =?UTF-8?q?=E8=BF=90=E5=8A=A8=E5=8F=82=E6=95=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- NeoTracker/CMakeLists.txt | 2 +- NeoTracker/profile/CMakeLists.txt | 36 + .../profile/Profile_SOT_Ground_NV12.cpp | 128 ++ NeoTracker/profile/Profile_SOT_Ground_RGB.cpp | 135 ++ NeoTracker/profile/Profile_SOT_Ground_Y16.cpp | 135 ++ NeoTracker/profile/Profile_SOT_Ground_Y8.cpp | 137 ++ .../profile/Profile_SOT_LockUnlockStress.cpp | 118 ++ NeoTracker/profile/Profile_SOT_Sky_Y16.cpp | 148 ++ NeoTracker/profile/README.MD | 17 + NeoTracker/profile/TestAPI_Profile.cpp | 55 + NeoTracker/profile/TestAPI_Profile.h | 13 + NeoTracker/profile/cmdline.h | 821 +++++++++++ NeoTracker/profile/image_data.h | 1229 +++++++++++++++++ NeoTracker/profile/test.sh | 1 + NeoTracker/profile/utils.cpp | 398 ++++++ NeoTracker/profile/utils.h | 177 +++ NeoTracker/src/Arith_TrackSAObj.cpp | 34 +- NeoTracker/src/Detect/Arith_DetectSmallObj.h | 2 +- NeoTracker/src/Version.h.in | 2 +- NeoTracker/tests/TestAPI_SOT_Sky_Y16.cpp | 4 +- QGuideArithStudio/src/QFileList.cpp | 2 +- QGuideArithStudio/src/QVideoPlayer.cpp | 8 +- 22 files changed, 3583 insertions(+), 19 deletions(-) create mode 100644 NeoTracker/profile/CMakeLists.txt create mode 100644 NeoTracker/profile/Profile_SOT_Ground_NV12.cpp create mode 100644 NeoTracker/profile/Profile_SOT_Ground_RGB.cpp create mode 100644 NeoTracker/profile/Profile_SOT_Ground_Y16.cpp create mode 100644 NeoTracker/profile/Profile_SOT_Ground_Y8.cpp create mode 100644 NeoTracker/profile/Profile_SOT_LockUnlockStress.cpp create mode 100644 NeoTracker/profile/Profile_SOT_Sky_Y16.cpp create mode 100644 NeoTracker/profile/README.MD create mode 100644 NeoTracker/profile/TestAPI_Profile.cpp create mode 100644 NeoTracker/profile/TestAPI_Profile.h create mode 100644 NeoTracker/profile/cmdline.h create mode 100644 NeoTracker/profile/image_data.h create mode 100644 NeoTracker/profile/test.sh create mode 100644 NeoTracker/profile/utils.cpp create mode 100644 NeoTracker/profile/utils.h diff --git a/NeoTracker/CMakeLists.txt b/NeoTracker/CMakeLists.txt index 23f11c3..06a7be4 100644 --- a/NeoTracker/CMakeLists.txt +++ b/NeoTracker/CMakeLists.txt @@ -3,7 +3,7 @@ SET(ArithTrkPubInc ${CMAKE_SOURCE_DIR}/public_include) include_directories(${ArithTrkPubInc}) #引入算法公共头文件 set(CMAKE_CXX_STANDARD 17) # 添加测试目录 -add_subdirectory(tests) +add_subdirectory(profile) IF(WIN32) # 添加vot_test diff --git a/NeoTracker/profile/CMakeLists.txt b/NeoTracker/profile/CMakeLists.txt new file mode 100644 index 0000000..e740571 --- /dev/null +++ b/NeoTracker/profile/CMakeLists.txt @@ -0,0 +1,36 @@ +message(STATUS "++++++++add Profile Test DIR++++++++") + +# 全局包含opencv +link_directories(${OpenCV_LIBS_DIR}) +include_directories(${OpenCV_INCLUDE_DIRS}) + + # 引入算法公共头文件 +SET(ArithTrkPubInc ${CMAKE_SOURCE_DIR}/public_include) +include_directories(${ArithTrkPubInc}) + +set(LIB_SRC_DIR ${CMAKE_SOURCE_DIR}/NeoTracker/src) +include_directories(${LIB_SRC_DIR}) + +link_directories(${CMAKE_SOURCE_DIR}/Bin) + + +set(EXECUTABLE_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/Bin) + +# 测试用例:性能分析，不需要传入跟踪视频，使用内部仿真数据进行测试。 + +add_executable(TestAPI_Profile TestAPI_Profile.cpp + Profile_SOT_Ground_NV12.cpp + Profile_SOT_Ground_Y16.cpp + Profile_SOT_Ground_Y8.cpp + Profile_SOT_Ground_RGB.cpp + Profile_SOT_Sky_Y16.cpp + Profile_SOT_LockUnlockStress.cpp + utils.cpp + ) +target_link_libraries(TestAPI_Profile PRIVATE + ${LIB_TRACKER} + ${LIB_DETECTOR} #红外检测算法 + ${LIB_GDKCF} #KCF算法 + ${LIB_GDTLD} #TLD算法 + ${LIB_PIPE} +${OpenCV_LIBS}) \ No newline at end of file diff --git a/NeoTracker/profile/Profile_SOT_Ground_NV12.cpp b/NeoTracker/profile/Profile_SOT_Ground_NV12.cpp new file mode 100644 index 0000000..5da04ef --- /dev/null +++ b/NeoTracker/profile/Profile_SOT_Ground_NV12.cpp @@ -0,0 +1,128 @@ +// NV12 对地跟踪性能测试 +#include "NeoArithStandardDll.h" +#include "utils.h" +#include +#include +#include +#include +#include +#include "opencv2/opencv.hpp" +#include "TestAPI_Profile.h" +using std::cout; +using std::endl; +using std::string; + +#define Test_Len 1000 + +int TestAPI_SOT_Ground_NV12() +{ + // 产生一个仿真Y16数据 + int nWidth = 1920; + int nHeight = 1080; + SimTargetImage factory(nWidth, nHeight); + + factory.setBackGround(128, 10); + // 叠加一个初始目标 + Target t; + t.x = 100; + t.y = 100; + t.width = 30; + t.height = 30; + t.vw = 0; + t.vh = 0; + t.vx = 1; + t.vy = 1; + t.addTexture(cow_png,cow_png_len); + factory.addTarget(t); + // + + t.x = 300; + t.y = 250; + t.width = 100; + t.height = 100; + t.vw = 0; + t.vh = 0; + t.vx = 0; + t.vy = 0; + t.color = cv::Scalar(20,20,20); + factory.addOcc(t); + + + // 创建算法句柄 + ArithHandle pTracker = STD_CreatEOArithHandle(); + + // 初始化为凝视-对地模式 + ARIDLL_EOArithInitWithMode(pTracker,nWidth,nHeight,GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_NV12, + GLB_SYS_MODE::GLB_SYS_STARE,GLB_SCEN_MODE::GLB_SCEN_GROUND); + + // 算法输入部分 + ARIDLL_INPUTPARA stInputPara = { 0 }; + stInputPara.unFrmId++; + stInputPara.stCameraInfo.fPixelSize = 15; + stInputPara.stCameraInfo.nFocus = 300; + + // 算法输出部分 + ARIDLL_OUTPUT stOutput = { 0 }; + + + // 模拟算法执行流程 + int nTrackSuc = 0; + cv::Mat frame; + for(int i = 0; i < Test_Len; i++) + { + stInputPara.unFrmId++; + + factory.update(); + cv::Mat src = factory.getImageNV12(); + Target* gt = factory.getTarget(0); + + // 构建图像类型 + GD_VIDEO_FRAME_S img = { 0 }; + img.enPixelFormat = GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_NV12; + img.u32Width = nWidth; + img.u32Height = nHeight; + img.u32Stride[0] = img.u32Width * 1; + img.u64VirAddr[0] = (unsigned char*)src.data; + + // 下发面锁定指令 + if (stInputPara.unFrmId == 3) + { + //ARIDLL_LockCommand(pTracker, gt->x,gt->y,gt->width,gt->height); + ARIDLL_LockCommand(pTracker, gt->x, gt->y, gt->width, gt->height); + } + + + cv::TickMeter tm; + tm.start(); + + // 运行算法主控逻辑API + ARIDLL_RunController(pTracker, img, stInputPara, &stOutput); + + tm.stop(); + + printf("time:%.2f\n",tm.getTimeMilli()); + +#ifdef SHOW + // 绘制跟踪结果 + cv::Mat rgb = factory.getImageRGB(); + showArithInfo(rgb,&stOutput); + imshow("res",rgb); + cv::waitKey(1); +#endif + + if (stOutput.nStatus == GLB_STATUS_TRACK && stOutput.nTrackObjCnts == 1) + { + if (abs(stOutput.stTrackers[0].nX - gt->x) < 5 && + abs(stOutput.stTrackers[0].nY - gt->y) < 5) + { + nTrackSuc++; + } + } + } + + + printf("Suc:%d/A:%d\n",nTrackSuc,Test_Len); + + + return 0; +} diff --git a/NeoTracker/profile/Profile_SOT_Ground_RGB.cpp b/NeoTracker/profile/Profile_SOT_Ground_RGB.cpp new file mode 100644 index 0000000..42d78be --- /dev/null +++ b/NeoTracker/profile/Profile_SOT_Ground_RGB.cpp @@ -0,0 +1,135 @@ +// 单目标对地跟踪流程测试:将TLD从算法中剥离到外部，导致API调用形式调整 +// 读取avi视频进行测试 + + +#include "NeoArithStandardDll.h" +#include "utils.h" +#include +#include +#include +#include +#include +#include "opencv2/opencv.hpp" +#include "TestAPI_Profile.h" +using std::cout; +using std::endl; +using std::string; + +#define Test_Len 1000 + +int TestAPI_SOT_Ground_RGB() +{ + // 产生一个仿真Y16数据 + int nWidth = 1280; + int nHeight = 1024; + SimTargetImage factory(nWidth, nHeight); + + factory.setBackGround(128, 10); + // 叠加一个初始目标 + Target t; + t.x = 100; + t.y = 100; + t.width = 30; + t.height = 30; + t.vw = 0; + t.vh = 0; + t.vx = 1; + t.vy = 1; + t.addTexture(cow_png,cow_png_len); + factory.addTarget(t); + // + + t.x = 300; + t.y = 250; + t.width = 100; + t.height = 100; + t.vw = 0; + t.vh = 0; + t.vx = 0; + t.vy = 0; + t.color = cv::Scalar(20,20,20); + factory.addOcc(t); + + + + // 创建算法句柄 + ArithHandle pTracker = STD_CreatEOArithHandle(); + + // 初始化为凝视-对地模式 + ARIDLL_EOArithInitWithMode(pTracker,nWidth,nHeight,GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_RGB_PACKED, + GLB_SYS_MODE::GLB_SYS_STARE,GLB_SCEN_MODE::GLB_SCEN_GROUND); + + // 算法输入部分 + ARIDLL_INPUTPARA stInputPara = { 0 }; + stInputPara.unFrmId++; + stInputPara.stCameraInfo.fPixelSize = 15; + stInputPara.stCameraInfo.nFocus = 300; + + // 算法输出部分 + ARIDLL_OUTPUT stOutput = { 0 }; + + + // 模拟算法执行流程 + int nTrackSuc = 0; + cv::Mat frame; + for(int i = 0; i < Test_Len; i++) + { + stInputPara.unFrmId++; + + factory.update(); + cv::Mat src = factory.getImageRGB(); + Target* gt = factory.getTarget(0); + + + + // 构建图像类型 + GD_VIDEO_FRAME_S img = { 0 }; + img.enPixelFormat = GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_RGB_PACKED; + img.u32Width = nWidth; + img.u32Height = nHeight; + img.u32Stride[0] = img.u32Width * 3; + img.u64VirAddr[0] = (unsigned char*)src.data; + + + + // 下发面锁定指令 + if (stInputPara.unFrmId == 3) + { + ARIDLL_LockCommand(pTracker, gt->x,gt->y,gt->width,gt->height); + } + + + cv::TickMeter tm; + tm.start(); + + // 运行算法主控逻辑API + ARIDLL_RunController(pTracker, img, stInputPara, &stOutput); + + tm.stop(); + + printf("time:%.2f\n",tm.getTimeMilli()); + +#ifdef SHOW + // 绘制跟踪结果 + cv::Mat rgb = factory.getImageRGB(); + showArithInfo(rgb,&stOutput); + imshow("res",rgb); + cv::waitKey(1); +#endif + + if (stOutput.nStatus == GLB_STATUS_TRACK && stOutput.nTrackObjCnts == 1) + { + if (abs(stOutput.stTrackers[0].nX - gt->x) < 5 && + abs(stOutput.stTrackers[0].nY - gt->y) < 5) + { + nTrackSuc++; + } + } + } + + + printf("Suc:%d/A:%d\n",nTrackSuc,Test_Len); + + + return 0; +} diff --git a/NeoTracker/profile/Profile_SOT_Ground_Y16.cpp b/NeoTracker/profile/Profile_SOT_Ground_Y16.cpp new file mode 100644 index 0000000..8e87362 --- /dev/null +++ b/NeoTracker/profile/Profile_SOT_Ground_Y16.cpp @@ -0,0 +1,135 @@ +// 单目标对地跟踪流程测试:将TLD从算法中剥离到外部，导致API调用形式调整 +// 读取avi视频进行测试 + + +#include "NeoArithStandardDll.h" +#include "utils.h" +#include +#include +#include +#include +#include +#include "opencv2/opencv.hpp" +#include "TestAPI_Profile.h" +using std::cout; +using std::endl; +using std::string; + +#define Test_Len 1000 + +int TestAPI_SOT_Ground_Y16() +{ + // 产生一个仿真Y16数据 + int nWidth = 1280; + int nHeight = 1024; + SimTargetImage factory(nWidth, nHeight); + + factory.setBackGround(128, 10); + // 叠加一个初始目标 + Target t; + + t.x = 100; + t.y = 100; + t.width = 30; + t.height = 30; + t.vw = 0; + t.vh = 0; + t.vx = 1; + t.vy = 1; + t.addTexture(cow_png,cow_png_len); + factory.addTarget(t); + // + + t.x = 300; + t.y = 250; + t.width = 100; + t.height = 100; + t.vw = 0; + t.vh = 0; + t.vx = 0; + t.vy = 0; + t.color = cv::Scalar(20,20,20); + factory.addOcc(t); + + // 创建算法句柄 + ArithHandle pTracker = STD_CreatEOArithHandle(); + + // 初始化为凝视-对地模式 + ARIDLL_EOArithInitWithMode(pTracker,nWidth,nHeight,GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_GRAY_Y16, + GLB_SYS_MODE::GLB_SYS_STARE,GLB_SCEN_MODE::GLB_SCEN_GROUND); + + // 算法输入部分 + ARIDLL_INPUTPARA stInputPara = { 0 }; + stInputPara.unFrmId++; + stInputPara.stCameraInfo.fPixelSize = 15; + stInputPara.stCameraInfo.nFocus = 300; + + // 算法输出部分 + ARIDLL_OUTPUT stOutput = { 0 }; + + + // 模拟算法执行流程 + int nTrackSuc = 0; + cv::Mat frame; + for(int i = 0; i < Test_Len; i++) + { + stInputPara.unFrmId++; + + factory.update(); + cv::Mat src = factory.getImageY16(); + Target* gt = factory.getTarget(0); + + + + // 构建图像类型 + GD_VIDEO_FRAME_S img = { 0 }; + img.enPixelFormat = GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_GRAY_Y16; + img.u32Width = nWidth; + img.u32Height = nHeight; + img.u32Stride[0] = img.u32Width * 2; + img.u64VirAddr[0] = (unsigned char*)src.data; + + + + // 下发面锁定指令 + if (stInputPara.unFrmId == 3) + { + //ARIDLL_LockCommand(pTracker, gt->x,gt->y,gt->width,gt->height); + ARIDLL_LockCommand(pTracker, gt->x, gt->y, gt->width, gt->height); + } + + + cv::TickMeter tm; + tm.start(); + + // 运行算法主控逻辑API + ARIDLL_RunController(pTracker, img, stInputPara, &stOutput); + + tm.stop(); + + printf("time:%.2f\n",tm.getTimeMilli()); + +#ifdef SHOW + // 绘制跟踪结果 + cv::Mat rgb = factory.getImageRGB(); + showArithInfo(rgb,&stOutput); + imshow("res",rgb); + cv::waitKey(1); +#endif + + if (stOutput.nStatus == GLB_STATUS_TRACK && stOutput.nTrackObjCnts == 1) + { + if (abs(stOutput.stTrackers[0].nX - gt->x) < 5 && + abs(stOutput.stTrackers[0].nY - gt->y) < 5) + { + nTrackSuc++; + } + } + } + + + printf("Suc:%d/A:%d\n",nTrackSuc,Test_Len); + + + return 0; +} diff --git a/NeoTracker/profile/Profile_SOT_Ground_Y8.cpp b/NeoTracker/profile/Profile_SOT_Ground_Y8.cpp new file mode 100644 index 0000000..e077197 --- /dev/null +++ b/NeoTracker/profile/Profile_SOT_Ground_Y8.cpp @@ -0,0 +1,137 @@ +// 单目标对地跟踪流程测试:将TLD从算法中剥离到外部，导致API调用形式调整 +// 读取avi视频进行测试 + + +#include "NeoArithStandardDll.h" +#include "utils.h" +#include +#include +#include +#include +#include +#include "opencv2/opencv.hpp" +#include "TestAPI_Profile.h" +using std::cout; +using std::endl; +using std::string; + +#define Test_Len 1000 + +int TestAPI_SOT_Ground_Y8() +{ + // 产生一个仿真Y16数据 + int nWidth = 1280; + int nHeight = 1024; + SimTargetImage factory(nWidth, nHeight); + + factory.setBackGround(128, 10); + // 叠加一个初始目标 + Target t; + + t.x = 100; + t.y = 100; + t.width = 50; + t.height = 30; + t.vw = 0; + t.vh = 0; + t.vx = 0.3; + t.vy = 0.2; + t.color = cv::Scalar(25,255,1); + t.addTexture(cow_png,cow_png_len); + + factory.addTarget(t); + + t.x = 300; + t.y = 250; + t.width = 100; + t.height = 100; + t.vw = 0; + t.vh = 0; + t.vx = 0; + t.vy = 0; + t.color = cv::Scalar(20,20,20); + factory.addOcc(t); + + + + // 创建算法句柄 + ArithHandle pTracker = STD_CreatEOArithHandle(); + + // 初始化为凝视-对地模式 + ARIDLL_EOArithInitWithMode(pTracker,nWidth,nHeight,GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_GRAY_Y8, + GLB_SYS_MODE::GLB_SYS_STARE,GLB_SCEN_MODE::GLB_SCEN_GROUND); + + // 算法输入部分 + ARIDLL_INPUTPARA stInputPara = { 0 }; + stInputPara.unFrmId++; + stInputPara.stCameraInfo.fPixelSize = 15; + stInputPara.stCameraInfo.nFocus = 300; + + // 算法输出部分 + ARIDLL_OUTPUT stOutput = { 0 }; + + + // 模拟算法执行流程 + int nTrackSuc = 0; + cv::Mat frame; + for(int i = 0; i < Test_Len; i++) + { + stInputPara.unFrmId++; + + factory.update(); + cv::Mat src = factory.getImageY8(); + Target* gt = factory.getTarget(0); + + + + // 构建图像类型 + GD_VIDEO_FRAME_S img = { 0 }; + img.enPixelFormat = GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_GRAY_Y8; + img.u32Width = nWidth; + img.u32Height = nHeight; + img.u32Stride[0] = img.u32Width * 1; + img.u64VirAddr[0] = (unsigned char*)src.data; + + + + // 下发面锁定指令 + if (stInputPara.unFrmId == 3) + { + ARIDLL_LockCommand(pTracker, gt->x,gt->y,gt->width,gt->height); + } + + + cv::TickMeter tm; + tm.start(); + + // 运行算法主控逻辑API + ARIDLL_RunController(pTracker, img, stInputPara, &stOutput); + + tm.stop(); + + printf("time:%.2f\n",tm.getTimeMilli()); + +#ifdef SHOW + // 绘制跟踪结果 + cv::Mat rgb = factory.getImageRGB(); + showArithInfo(rgb,&stOutput); + imshow("res",rgb); + cv::waitKey(1); +#endif + + if (stOutput.nStatus == GLB_STATUS_TRACK && stOutput.nTrackObjCnts == 1) + { + if (abs(stOutput.stTrackers[0].nX - gt->x) < 5 && + abs(stOutput.stTrackers[0].nY - gt->y) < 5) + { + nTrackSuc++; + } + } + } + + + printf("Suc:%d/A:%d\n",nTrackSuc,Test_Len); + + + return 0; +} diff --git a/NeoTracker/profile/Profile_SOT_LockUnlockStress.cpp b/NeoTracker/profile/Profile_SOT_LockUnlockStress.cpp new file mode 100644 index 0000000..afa5ff6 --- /dev/null +++ b/NeoTracker/profile/Profile_SOT_LockUnlockStress.cpp @@ -0,0 +1,118 @@ +// 暴力锁定解锁鲁棒性测试 +#include "NeoArithStandardDll.h" +#include "utils.h" +#include +#include +#include +#include +#include +#include "opencv2/opencv.hpp" +#include "TestAPI_Profile.h" +#include +using std::cout; +using std::endl; + +int TestAPI_SOT_LockUnlock_Stress() +{ + // 产生一个仿真数据 + int nWidth = 1920; + int nHeight = 1080; + + const int Test_Len = 100000; + + // 初始化随机数生成器 + std::random_device rd; + std::mt19937 gen(rd()); + std::uniform_int_distribution<> offsetDist(-2000, 2000); // 在目标周围±5像素范围内随机 + + SimTargetImage factory(nWidth, nHeight); + factory.setCheckerboardBackGround(120, 0, 80); + + // 创建算法句柄 + ArithHandle pTracker = STD_CreatEOArithHandle(); + + // 初始化为凝视-对空模式 + ARIDLL_EOArithInitWithMode(pTracker, nWidth, nHeight, GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_NV12, + GLB_SYS_MODE::GLB_SYS_STARE, GLB_SCEN_MODE::GLB_SCEN_GROUND); + + ARIDLL_INPUTPARA stInputPara = { 0 }; + stInputPara.unFrmId++; + stInputPara.unFreq = 50; + stInputPara.stCameraInfo.fPixelSize = 15; + stInputPara.stCameraInfo.nFocus = 300; + stInputPara.stCameraInfo.unVideoType = GLB_VIDEO_IR_MW; + ARIDLL_OUTPUT stOutput = { 0 }; + + // 生成随机锁定解锁序列 + std::vector lockUnlockSequence = generateRandomLockUnlockSequence(Test_Len); + + int nTrackSuc = 0; + int nLock = 0, nUnlock = 0, nLost = 0; + bool locked = false; + + for (int i = 0; i < Test_Len; i++) + { + stInputPara.unFrmId++; + factory.update(); + cv::Mat src = factory.getImageNV12(); + + GD_VIDEO_FRAME_S img = { 0 }; + img.enPixelFormat = GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_NV12; + img.u32Width = nWidth; + img.u32Height = nHeight; + img.u32Stride[0] = img.u32Width; + img.u64VirAddr[0] = (UBYTE8*)src.data; + + int targetNum = 0; + cv::TickMeter tm1; + tm1.start(); + { + //targetNum = ARIDLL_SearchFrameTargets(pTracker, img); + } + tm1.stop(); + printf("det time:%.2f", tm1.getTimeMilli()); + + // 根据序列执行锁定/解锁操作 + switch (lockUnlockSequence[i]) + { + case 1: // 锁定 + { + // 在目标周围随机选择锁定位置 + int offsetX = offsetDist(gen); + int offsetY = offsetDist(gen); + //ARIDLL_LockCommand_DefaultSize(pTracker, (int)nWidth / 2 + offsetX, (int)nHeight / 2 + offsetY, 30, 30); + //ARIDLL_LockTarget_DefaultSize(pTracker, img,(int)nWidth / 2 + offsetX, (int)nHeight / 2 + offsetY, 30, 30); + locked = true; + nLock++; + } + break; + case 2: // 解锁 + ARIDLL_unLockCommand(pTracker); + locked = false; + nUnlock++; + break; + default: // 普通帧 + break; + } + + + cv::TickMeter tm2; + tm2.start(); + ARIDLL_RunController(pTracker, img, stInputPara, &stOutput); + tm2.stop(); + printf(" trk time:%.2f\n", tm2.getTimeMilli()); + +#ifdef SHOW + cv::Mat rgb = factory.getImageRGB(); + showArithInfo(rgb, &stOutput); + imshow("res", rgb); + cv::waitKey(1); +#endif + printf("nStatus:%d,Proc:%d", stOutput.nStatus,stInputPara.unFrmId); + } + + // 输出测试统计结果 + + + return 0; +} diff --git a/NeoTracker/profile/Profile_SOT_Sky_Y16.cpp b/NeoTracker/profile/Profile_SOT_Sky_Y16.cpp new file mode 100644 index 0000000..3ff0152 --- /dev/null +++ b/NeoTracker/profile/Profile_SOT_Sky_Y16.cpp @@ -0,0 +1,148 @@ +// 单目标对空跟踪流程测试，关注跟踪器FPS + +#include "NeoArithStandardDll.h" +#include "utils.h" +#include +#include +#include +#include +#include +#include "opencv2/opencv.hpp" +#include "TestAPI_Profile.h" +using std::cout; +using std::endl; + +#define Test_Len 1000 + +int TestAPI_SOT_Sky_Y16() +{ + // 产生一个仿真Y16数据 + int nWidth = 640; + int nHeight = 512; + SimTargetImage factory(nWidth, nHeight); + + factory.setBackGround(120, 0); + // 叠加一个初始目标 + Target t; + + t.x = 100; + t.y = 100; + t.width = 4; + t.height = 4; + t.vw = 0; + t.vh = 0; + t.vx = 1; + t.vy = 1; + t.color = cv::Scalar(255,255,255); + t.vc = 10; + //t.addTexture(cow_png, cow_png_len); + //t.bGrayComplex = true; + //t.color2 = cv::Scalar(10, 10, 10); + factory.addTarget(t); + + + // 创建算法句柄 + ArithHandle pTracker = STD_CreatEOArithHandle(); + // 初始化为凝视-对空模式 + ARIDLL_EOArithInitWithMode(pTracker,nWidth,nHeight,GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_GRAY_Y16, + GLB_SYS_MODE::GLB_SYS_STARE,GLB_SCEN_MODE::GLB_SCEN_SKY); + + // 算法输入部分 + ARIDLL_INPUTPARA stInputPara = { 0 }; + stInputPara.unFrmId++; + stInputPara.unFreq = 50; + stInputPara.stCameraInfo.fPixelSize = 15; + stInputPara.stCameraInfo.nFocus = 300; + stInputPara.stCameraInfo.unVideoType = GLB_VIDEO_IR_MW; + + // 算法输出部分 + ARIDLL_OUTPUT stOutput = { 0 }; + + + // 模拟算法执行流程 + int nTrackSuc = 0; + for (int i = 0; i < Test_Len; i++) + { + stInputPara.unFrmId++; + + + factory.update(); + + cv::Mat src = factory.getImageY16(); + + Target* gt = factory.getTarget(0); + + + // 下发点锁定指令 + if (i == 50) + { + ARIDLL_LockCommand(pTracker, (int)gt->x, (int)gt->y,0,0); + } + + // 构建图像类型 + GD_VIDEO_FRAME_S img = { 0 }; + img.enPixelFormat = GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_GRAY_Y16; + img.u32Width = nWidth; + img.u32Height = nHeight; + img.u32Stride[0] = img.u32Width * 2; + img.u64VirAddr[0] = (UBYTE8*)src.data; + + // 红外目标检测API调用 + int targetNum = 0; + + // 目标搜索仅在搜索状态执行，保持与经典对空算法一致，用于与上一版本耗时对比 + // 新跟踪器中搜索在单独线程中不间断执行，本demo中仅展示用法，不做并行示范。 + //if (stOutput.nStatus == GLB_STATUS_SEARCH) + + cv::TickMeter tm1; + tm1.start(); + { + targetNum = ARIDLL_SearchFrameTargets(pTracker, img); + } + + + + tm1.stop(); + printf("det time:%.2f", tm1.getTimeMilli()); + + cv::TickMeter tm2; + tm2.start(); + // 运行算法主控逻辑API + ARIDLL_RunController(pTracker, img, stInputPara, &stOutput); + tm2.stop(); + printf(" trk time:%.2f\n", tm2.getTimeMilli()); + + + //std::cout << gt->x << " " << gt->y << std::endl; + + +#ifdef SHOW + // 绘制跟踪结果 + cv::Mat rgb = factory.getImageRGB(); + showArithInfo(rgb,&stOutput); + imshow("res",rgb); + cv::waitKey(1); +#endif + + if (stOutput.nStatus == GLB_STATUS_TRACK && stOutput.nTrackObjCnts == 1) + { + if (abs(stOutput.stTrackers[0].nX - gt->x) < 5 && + abs(stOutput.stTrackers[0].nY - gt->y) < 5) + { + nTrackSuc++; + } + } + + } + + if (nTrackSuc > Test_Len * 0.9) + { + cout << "pass" << endl; + } + + printf("Suc:%d/A:%d\n",nTrackSuc,Test_Len); + + + + return 0; +} \ No newline at end of file diff --git a/NeoTracker/profile/README.MD b/NeoTracker/profile/README.MD new file mode 100644 index 0000000..b189f29 --- /dev/null +++ b/NeoTracker/profile/README.MD @@ -0,0 +1,17 @@ +# 单元测试为基础的性能和功能测试 + +test 中包含的内容为基准性能测试和最简单的功能测试。主要用于不同平台下耗时统计。 + +使用方式： + +如 +./TestAPI_Profile -s ground -d NV12 + + +- 使用了cmdline进行参数解析 +- 使用lambda进行参数与测试接口绑定，减少可执行程序个数。 +- 内置一个功能较为完整的目标图像仿真模块，可以制作出贴图目标的遮挡、放缩、运动等效果而不需要依赖外部视频或者贴图。 +- 根据项目和硬件需要自由增加测试项。 +- test项不再执行其他性能测试。 + + diff --git a/NeoTracker/profile/TestAPI_Profile.cpp b/NeoTracker/profile/TestAPI_Profile.cpp new file mode 100644 index 0000000..b7a53d8 --- /dev/null +++ b/NeoTracker/profile/TestAPI_Profile.cpp @@ -0,0 +1,55 @@ +#include "cmdline.h"//命令行解析 +#include +#include +#include +#include "image_data.h" +#include "TestAPI_Profile.h" + +using namespace std; + + +int main(int argc, char *argv[]) +{ + TestAPI_SOT_Sky_Y16(); + return 0; + // 映射表 + std::unordered_map> handlerMap = { + {"sky:Y16", TestAPI_SOT_Sky_Y16}, + {"ground:Y8", TestAPI_SOT_Ground_Y8}, + {"ground:RGB", TestAPI_SOT_Ground_RGB}, + {"ground:Y16", TestAPI_SOT_Ground_Y16}, + {"ground:NV12", TestAPI_SOT_Ground_NV12}, + {"ground:NV12:LOCK_STRESS", TestAPI_SOT_LockUnlock_Stress}, + }; + + cmdline::parser a; + a.add("scen",'s',"sky or ground",true,""); + a.add("dataType",'d',"Y8/Y16/RGB/NV12",true,""); + a.add("testItem",'t',"other item",false,""); + a.parse_check(argc, argv); + + cout << "scen:" << a.get("scen") + << "datatype:" << a.get("dataType") << endl; + cout << "------------------ " << endl; + + + std::string scen = a.get("scen"); + std::string dataType = a.get("dataType"); + std::string testItem = a.get("testItem"); + + std::string key; + if (!testItem.empty()) { + key = scen + ":" + dataType + ":" + testItem; + } else { + key = scen + ":" + dataType; + } + + // 查找并执行逻辑 + if (handlerMap.find(key) != handlerMap.end()) { + handlerMap[key](); + } else { + std::cout << "Invalid combination of scen and dataType: " << key << std::endl; + } + + return 0; +} \ No newline at end of file diff --git a/NeoTracker/profile/TestAPI_Profile.h b/NeoTracker/profile/TestAPI_Profile.h new file mode 100644 index 0000000..a9ad7a7 --- /dev/null +++ b/NeoTracker/profile/TestAPI_Profile.h @@ -0,0 +1,13 @@ +#include "utils.h" + +#define SHOW + +extern unsigned char cow_png[]; +extern unsigned int cow_png_len; + +int TestAPI_SOT_Ground_NV12(); +int TestAPI_SOT_Ground_RGB(); +int TestAPI_SOT_Ground_Y8(); +int TestAPI_SOT_Ground_Y16(); +int TestAPI_SOT_Sky_Y16(); +int TestAPI_SOT_LockUnlock_Stress(); \ No newline at end of file diff --git a/NeoTracker/profile/cmdline.h b/NeoTracker/profile/cmdline.h new file mode 100644 index 0000000..dce58c4 --- /dev/null +++ b/NeoTracker/profile/cmdline.h @@ -0,0 +1,821 @@ +/* + Copyright (c) 2009, Hideyuki Tanaka + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of the nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY ''AS IS'' AND ANY + EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifdef __GNUC__ +#include +#endif +#include + +namespace cmdline{ + +namespace detail{ + +template +class lexical_cast_t{ +public: + static Target cast(const Source &arg){ + Target ret; + std::stringstream ss; + if (!(ss<>ret && ss.eof())) + throw std::bad_cast(); + + return ret; + } +}; + +template +class lexical_cast_t{ +public: + static Target cast(const Source &arg){ + return arg; + } +}; + +template +class lexical_cast_t{ +public: + static std::string cast(const Source &arg){ + std::ostringstream ss; + ss< +class lexical_cast_t{ +public: + static Target cast(const std::string &arg){ + Target ret; + std::istringstream ss(arg); + if (!(ss>>ret && ss.eof())) + throw std::bad_cast(); + return ret; + } +}; + +template +struct is_same { + static const bool value = false; +}; + +template +struct is_same{ + static const bool value = true; +}; + +template +Target lexical_cast(const Source &arg) +{ + return lexical_cast_t::value>::cast(arg); +} + +static inline std::string demangle(const std::string &name) +{ + +#ifdef _MSC_VER + return name; // 为MSVC编译器时直接返回name +#elif defined(__GNUC__) + // 为gcc编译器时还调用原来的代码 + int status = 0; + char* p = abi::__cxa_demangle(name.c_str(), 0, 0, &status); + std::string ret(p); + free(p); + return ret; +#else + // 其他不支持的编译器需要自己实现这个方法 +#error unexpected c complier (msc/gcc), Need to implement this method for demangle +#endif +} + +template +std::string readable_typename() +{ + return demangle(typeid(T).name()); +} + +template +std::string default_value(T def) +{ + return detail::lexical_cast(def); +} + +template <> +inline std::string readable_typename() +{ + return "string"; +} + +} // detail + +//----- + +class cmdline_error : public std::exception { +public: + cmdline_error(const std::string &msg): msg(msg){} + ~cmdline_error() throw() {} + const char *what() const throw() { return msg.c_str(); } +private: + std::string msg; +}; + +template +struct default_reader{ + T operator()(const std::string &str){ + return detail::lexical_cast(str); + } +}; + +template +struct range_reader{ + range_reader(const T &low, const T &high): low(low), high(high) {} + T operator()(const std::string &s) const { + T ret=default_reader()(s); + if (!(ret>=low && ret<=high)) throw cmdline::cmdline_error("range_error"); + return ret; + } +private: + T low, high; +}; + +template +range_reader range(const T &low, const T &high) +{ + return range_reader(low, high); +} + +template +struct oneof_reader{ + T operator()(const std::string &s){ + T ret=default_reader()(s); + if (std::find(alt.begin(), alt.end(), ret)==alt.end()) + throw cmdline_error(""); + return ret; + } + void add(const T &v){ alt.push_back(v); } +private: + std::vector alt; +}; + +template +oneof_reader oneof(T a1) +{ + oneof_reader ret; + ret.add(a1); + return ret; +} + +template +oneof_reader oneof(T a1, T a2) +{ + oneof_reader ret; + ret.add(a1); + ret.add(a2); + return ret; +} + +template +oneof_reader oneof(T a1, T a2, T a3) +{ + oneof_reader ret; + ret.add(a1); + ret.add(a2); + ret.add(a3); + return ret; +} + +template +oneof_reader oneof(T a1, T a2, T a3, T a4) +{ + oneof_reader ret; + ret.add(a1); + ret.add(a2); + ret.add(a3); + ret.add(a4); + return ret; +} + +template +oneof_reader oneof(T a1, T a2, T a3, T a4, T a5) +{ + oneof_reader ret; + ret.add(a1); + ret.add(a2); + ret.add(a3); + ret.add(a4); + ret.add(a5); + return ret; +} + +template +oneof_reader oneof(T a1, T a2, T a3, T a4, T a5, T a6) +{ + oneof_reader ret; + ret.add(a1); + ret.add(a2); + ret.add(a3); + ret.add(a4); + ret.add(a5); + ret.add(a6); + return ret; +} + +template +oneof_reader oneof(T a1, T a2, T a3, T a4, T a5, T a6, T a7) +{ + oneof_reader ret; + ret.add(a1); + ret.add(a2); + ret.add(a3); + ret.add(a4); + ret.add(a5); + ret.add(a6); + ret.add(a7); + return ret; +} + +template +oneof_reader oneof(T a1, T a2, T a3, T a4, T a5, T a6, T a7, T a8) +{ + oneof_reader ret; + ret.add(a1); + ret.add(a2); + ret.add(a3); + ret.add(a4); + ret.add(a5); + ret.add(a6); + ret.add(a7); + ret.add(a8); + return ret; +} + +template +oneof_reader oneof(T a1, T a2, T a3, T a4, T a5, T a6, T a7, T a8, T a9) +{ + oneof_reader ret; + ret.add(a1); + ret.add(a2); + ret.add(a3); + ret.add(a4); + ret.add(a5); + ret.add(a6); + ret.add(a7); + ret.add(a8); + ret.add(a9); + return ret; +} + +template +oneof_reader oneof(T a1, T a2, T a3, T a4, T a5, T a6, T a7, T a8, T a9, T a10) +{ + oneof_reader ret; + ret.add(a1); + ret.add(a2); + ret.add(a3); + ret.add(a4); + ret.add(a5); + ret.add(a6); + ret.add(a7); + ret.add(a8); + ret.add(a9); + ret.add(a10); + return ret; +} + +//----- + +class parser{ +public: + parser(){ + } + ~parser(){ + for (std::map::iterator p=options.begin(); + p!=options.end(); p++) + delete p->second; + } + + void add(const std::string &name, + char short_name=0, + const std::string &desc=""){ + if (options.count(name)) throw cmdline_error("multiple definition: "+name); + options[name]=new option_without_value(name, short_name, desc); + ordered.push_back(options[name]); + } + + template + void add(const std::string &name, + char short_name=0, + const std::string &desc="", + bool need=true, + const T def=T()){ + add(name, short_name, desc, need, def, default_reader()); + } + + template + void add(const std::string &name, + char short_name=0, + const std::string &desc="", + bool need=true, + const T def=T(), + F reader=F()){ + if (options.count(name)) throw cmdline_error("multiple definition: "+name); + options[name]=new option_with_value_with_reader(name, short_name, need, def, desc, reader); + ordered.push_back(options[name]); + } + + void footer(const std::string &f){ + ftr=f; + } + + void set_program_name(const std::string &name){ + prog_name=name; + } + + bool exist(const std::string &name) const { + if (options.count(name)==0) throw cmdline_error("there is no flag: --"+name); + return options.find(name)->second->has_set(); + } + + template + const T &get(const std::string &name) const { + if (options.count(name)==0) throw cmdline_error("there is no flag: --"+name); + const option_with_value *p=dynamic_cast*>(options.find(name)->second); + if (p==NULL) throw cmdline_error("type mismatch flag '"+name+"'"); + return p->get(); + } + + const std::vector &rest() const { + return others; + } + + bool parse(const std::string &arg){ + std::vector args; + + std::string buf; + bool in_quote=false; + for (std::string::size_type i=0; i=arg.length()){ + errors.push_back("unexpected occurrence of '\\' at end of string"); + return false; + } + } + + buf+=arg[i]; + } + + if (in_quote){ + errors.push_back("quote is not closed"); + return false; + } + + if (buf.length()>0) + args.push_back(buf); + + for (size_t i=0; i &args){ + int argc=static_cast(args.size()); + std::vector argv(argc); + + for (int i=0; i lookup; + for (std::map::iterator p=options.begin(); + p!=options.end(); p++){ + if (p->first.length()==0) continue; + char initial=p->second->short_name(); + if (initial){ + if (lookup.count(initial)>0){ + lookup[initial]=""; + errors.push_back(std::string("short option '")+initial+"' is ambiguous"); + return false; + } + else lookup[initial]=p->first; + } + } + + for (int i=1; i &args){ + if (!options.count("help")) + add("help", '?', "print this message"); + check(args.size(), parse(args)); + } + + void parse_check(int argc, char *argv[]){ + if (!options.count("help")) + add("help", '?', "print this message"); + check(argc, parse(argc, argv)); + } + + std::string error() const{ + return errors.size()>0?errors[0]:""; + } + + std::string error_full() const{ + std::ostringstream oss; + for (size_t i=0; imust()) + oss<short_description()<<" "; + } + + oss<<"[options] ... "<name().length()); + } + for (size_t i=0; ishort_name()){ + oss<<" -"<short_name()<<", "; + } + else{ + oss<<" "; + } + + oss<<"--"<name(); + for (size_t j=ordered[i]->name().length(); jdescription()<set()){ + errors.push_back("option needs value: --"+name); + return; + } + } + + void set_option(const std::string &name, const std::string &value){ + if (options.count(name)==0){ + errors.push_back("undefined option: --"+name); + return; + } + if (!options[name]->set(value)){ + errors.push_back("option value is invalid: --"+name+"="+value); + return; + } + } + + class option_base{ + public: + virtual ~option_base(){} + + virtual bool has_value() const=0; + virtual bool set()=0; + virtual bool set(const std::string &value)=0; + virtual bool has_set() const=0; + virtual bool valid() const=0; + virtual bool must() const=0; + + virtual const std::string &name() const=0; + virtual char short_name() const=0; + virtual const std::string &description() const=0; + virtual std::string short_description() const=0; + }; + + class option_without_value : public option_base { + public: + option_without_value(const std::string &name, + char short_name, + const std::string &desc) + :nam(name), snam(short_name), desc(desc), has(false){ + } + ~option_without_value(){} + + bool has_value() const { return false; } + + bool set(){ + has=true; + return true; + } + + bool set(const std::string &){ + return false; + } + + bool has_set() const { + return has; + } + + bool valid() const{ + return true; + } + + bool must() const{ + return false; + } + + const std::string &name() const{ + return nam; + } + + char short_name() const{ + return snam; + } + + const std::string &description() const { + return desc; + } + + std::string short_description() const{ + return "--"+nam; + } + + private: + std::string nam; + char snam; + std::string desc; + bool has; + }; + + template + class option_with_value : public option_base { + public: + option_with_value(const std::string &name, + char short_name, + bool need, + const T &def, + const std::string &desc) + : nam(name), snam(short_name), need(need), has(false) + , def(def), actual(def) { + this->desc=full_description(desc); + } + ~option_with_value(){} + + const T &get() const { + return actual; + } + + bool has_value() const { return true; } + + bool set(){ + return false; + } + + bool set(const std::string &value){ + try{ + actual=read(value); + has=true; + } + catch(const std::exception &e){ + return false; + } + return true; + } + + bool has_set() const{ + return has; + } + + bool valid() const{ + if (need && !has) return false; + return true; + } + + bool must() const{ + return need; + } + + const std::string &name() const{ + return nam; + } + + char short_name() const{ + return snam; + } + + const std::string &description() const { + return desc; + } + + std::string short_description() const{ + return "--"+nam+"="+detail::readable_typename(); + } + + protected: + std::string full_description(const std::string &desc){ + return + desc+" ("+detail::readable_typename()+ + (need?"":" [="+detail::default_value(def)+"]") + +")"; + } + + virtual T read(const std::string &s)=0; + + std::string nam; + char snam; + bool need; + std::string desc; + + bool has; + T def; + T actual; + }; + + template + class option_with_value_with_reader : public option_with_value { + public: + option_with_value_with_reader(const std::string &name, + char short_name, + bool need, + const T def, + const std::string &desc, + F reader) + : option_with_value(name, short_name, need, def, desc), reader(reader){ + } + + private: + T read(const std::string &s){ + return reader(s); + } + + F reader; + }; + + std::map options; + std::vector ordered; + std::string ftr; + + std::string prog_name; + std::vector others; + + std::vector errors; +}; + +} // cmdline + diff --git a/NeoTracker/profile/image_data.h b/NeoTracker/profile/image_data.h new file mode 100644 index 0000000..f93df78 --- /dev/null +++ b/NeoTracker/profile/image_data.h @@ -0,0 +1,1229 @@ +#include "TestAPI_Profile.h" +// cow图片 +// xxd -i image.png > image_data.h +unsigned char cow_png[] = { + 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, + 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x71, + 0x08, 0x06, 0x00, 0x00, 0x00, 0x23, 0xf9, 0x06, 0x7c, 0x00, 0x00, 0x00, + 0x06, 0x62, 0x4b, 0x47, 0x44, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0xa0, + 0xbd, 0xa7, 0x93, 0x00, 0x00, 0x00, 0x09, 0x70, 0x48, 0x59, 0x73, 0x00, + 0x00, 0x0b, 0x13, 0x00, 0x00, 0x0b, 0x13, 0x01, 0x00, 0x9a, 0x9c, 0x18, + 0x00, 0x00, 0x00, 0x07, 0x74, 0x49, 0x4d, 0x45, 0x07, 0xe4, 0x03, 0x05, + 0x0c, 0x12, 0x2d, 0x05, 0x4e, 0xac, 0x14, 0x00, 0x00, 0x00, 0x1d, 0x69, + 0x54, 0x58, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, + 0x69, 0x74, 0x68, 0x20, 0x47, 0x49, 0x4d, 0x50, 0x64, 0x2e, 0x65, 0x07, + 0x00, 0x00, 0x20, 0x00, 0x49, 0x44, 0x41, 0x54, 0x78, 0xda, 0xe5, 0x7d, + 0x77, 0x78, 0x54, 0x55, 0xfa, 0xff, 0xe7, 0x96, 0xe9, 0x2d, 0xc9, 0x4c, + 0x7a, 0x02, 0x81, 0x04, 0x42, 0x42, 0x09, 0x12, 0x02, 0x0b, 0x01, 0x01, + 0xe9, 0x45, 0x57, 0x45, 0x01, 0xc5, 0x82, 0xfe, 0xd6, 0x55, 0x17, 0x2c, + 0x58, 0x50, 0xd4, 0xd5, 0x55, 0xd9, 0x65, 0x45, 0x5d, 0x3b, 0xca, 0x82, + 0x5f, 0x76, 0x75, 0xbf, 0xee, 0x2a, 0x0a, 0x5f, 0x0b, 0x48, 0x93, 0x2a, + 0x75, 0x21, 0x24, 0x21, 0x24, 0x40, 0x7a, 0xef, 0x33, 0x99, 0x5e, 0x6e, + 0x39, 0xbf, 0x3f, 0xc8, 0xbd, 0x9b, 0x21, 0x6d, 0x12, 0xe2, 0xba, 0xcf, + 0xb3, 0x2f, 0x4f, 0x9e, 0x84, 0x99, 0x7b, 0xcf, 0x3d, 0xf7, 0xbc, 0xe7, + 0xbc, 0xf5, 0x73, 0xde, 0x43, 0xe1, 0x1a, 0x69, 0xc6, 0x8c, 0x19, 0x38, + 0x78, 0xf0, 0x60, 0x97, 0xdf, 0xa5, 0xa6, 0xa6, 0xe2, 0xd2, 0xa5, 0x4b, + 0x21, 0xb5, 0x93, 0x90, 0x90, 0x80, 0x9a, 0x9a, 0x1a, 0xf9, 0xff, 0x66, + 0xb3, 0x99, 0x65, 0x59, 0xd6, 0xe8, 0x72, 0xb9, 0xa2, 0x39, 0x8e, 0x8b, + 0xd0, 0x68, 0x34, 0x09, 0x1c, 0xc7, 0x65, 0xf0, 0x3c, 0x3f, 0x4c, 0x14, + 0xc5, 0xc1, 0x00, 0x62, 0x08, 0x21, 0x11, 0x00, 0x74, 0x82, 0x20, 0x80, + 0xa2, 0x28, 0x30, 0x0c, 0xc3, 0x03, 0xf0, 0x00, 0xb0, 0x52, 0x14, 0xd5, + 0x40, 0xd3, 0x74, 0x25, 0x4d, 0xd3, 0xc5, 0x0c, 0xc3, 0xe4, 0x73, 0x1c, + 0x57, 0xcb, 0x30, 0x4c, 0xab, 0xd1, 0x68, 0x6c, 0xe6, 0x79, 0xde, 0xd1, + 0xd2, 0xd2, 0xc2, 0x4b, 0xcf, 0x8a, 0x8e, 0x8e, 0x46, 0x63, 0x63, 0xe3, + 0x35, 0x8d, 0xc3, 0xa8, 0x51, 0xa3, 0x50, 0x50, 0x50, 0x80, 0xff, 0x18, + 0x32, 0x18, 0x0c, 0xd9, 0x1a, 0x8d, 0x66, 0x89, 0x5e, 0xaf, 0x5f, 0x68, + 0x34, 0x1a, 0x47, 0x12, 0x42, 0x28, 0xe9, 0xbb, 0x7b, 0xee, 0xb9, 0xa7, + 0xdb, 0xfb, 0x1e, 0x7d, 0xf4, 0x51, 0xf9, 0xef, 0x25, 0x4b, 0x96, 0xa8, + 0xf4, 0x7a, 0xfd, 0x34, 0xb5, 0x5a, 0xfd, 0x8a, 0x42, 0xa1, 0x38, 0x41, + 0xd3, 0x74, 0x35, 0x00, 0x27, 0x00, 0x22, 0xfd, 0x18, 0x0c, 0x06, 0x32, + 0x68, 0xd0, 0x20, 0x32, 0x72, 0xe4, 0x48, 0x92, 0x95, 0x95, 0x45, 0xb2, + 0xb3, 0xb3, 0xc9, 0xd4, 0xa9, 0x53, 0xc9, 0x94, 0x29, 0x53, 0xc8, 0xa4, + 0x49, 0x93, 0x48, 0x66, 0x66, 0x26, 0x49, 0x4b, 0x4b, 0x23, 0x09, 0x09, + 0x09, 0x44, 0xaf, 0xd7, 0x13, 0x00, 0x84, 0x61, 0x18, 0xc2, 0x30, 0x0c, + 0x01, 0xe0, 0x00, 0x50, 0xc5, 0xb2, 0xec, 0x71, 0xb5, 0x5a, 0xfd, 0xb2, + 0x5e, 0xaf, 0xbf, 0x7e, 0xd6, 0xac, 0x59, 0x2a, 0xe9, 0xf9, 0xf7, 0xdd, + 0x77, 0x5f, 0xb7, 0xfd, 0x8c, 0x89, 0x89, 0x91, 0xff, 0x4e, 0x4a, 0x4a, + 0x8a, 0xd2, 0xeb, 0xf5, 0x53, 0xf5, 0x7a, 0xfd, 0x6d, 0x5a, 0xad, 0xf6, + 0x97, 0x63, 0xc7, 0x8e, 0x35, 0x00, 0xc0, 0x2f, 0x7e, 0xf1, 0x8b, 0x9f, + 0x9f, 0x11, 0x4f, 0x3c, 0xf1, 0x04, 0xa5, 0x52, 0xa9, 0xde, 0xa2, 0x69, + 0x5a, 0x1e, 0x34, 0x9a, 0xa6, 0x03, 0x0c, 0xc3, 0x14, 0x6a, 0x34, 0x9a, + 0x37, 0x4c, 0x26, 0x53, 0x9a, 0xc4, 0x9c, 0xf0, 0xf0, 0xf0, 0x4e, 0xf7, + 0x8f, 0x1b, 0x37, 0x4e, 0x65, 0x36, 0x9b, 0x47, 0xa9, 0xd5, 0xea, 0xf7, + 0x68, 0x9a, 0x2e, 0x95, 0xda, 0x30, 0x9b, 0xcd, 0x64, 0xc4, 0x88, 0x11, + 0xe4, 0x96, 0x5b, 0x6e, 0x21, 0x1b, 0x36, 0x6c, 0x20, 0xbb, 0x77, 0xef, + 0x26, 0xf9, 0xf9, 0xf9, 0xa4, 0xba, 0xba, 0x9a, 0xd8, 0x6c, 0x36, 0xe2, + 0xf7, 0xfb, 0x49, 0x77, 0xe4, 0xf3, 0xf9, 0x88, 0xd5, 0x6a, 0x25, 0x95, + 0x95, 0x95, 0xa4, 0xa0, 0xa0, 0x80, 0x6c, 0xd8, 0xb0, 0x81, 0x4c, 0x99, + 0x32, 0x85, 0x4c, 0x98, 0x30, 0x81, 0x0c, 0x1b, 0x36, 0x8c, 0x98, 0x4c, + 0x26, 0xa2, 0x52, 0xa9, 0x08, 0x45, 0x51, 0x84, 0xa2, 0xa8, 0x12, 0xb5, + 0x5a, 0xfd, 0xae, 0xd9, 0x6c, 0x1e, 0x3d, 0x6b, 0xd6, 0x2c, 0x65, 0xc7, + 0xbe, 0x11, 0x42, 0xe4, 0xbf, 0xc3, 0xc2, 0xc2, 0xa2, 0x0c, 0x06, 0xc3, + 0x1d, 0x4a, 0xa5, 0x72, 0x2f, 0x4d, 0xd3, 0x8d, 0x14, 0x45, 0xc9, 0xef, + 0xab, 0x50, 0x28, 0x6c, 0x99, 0x99, 0x99, 0xa6, 0xff, 0x88, 0x95, 0xa1, + 0xd3, 0xe9, 0xa2, 0x18, 0x86, 0xa9, 0x63, 0x59, 0x96, 0x0c, 0x1d, 0x3a, + 0x94, 0x24, 0x26, 0x26, 0x12, 0xa3, 0xd1, 0x28, 0x77, 0x96, 0xa2, 0x28, + 0x3f, 0xc3, 0x30, 0x17, 0x62, 0x63, 0x63, 0xb3, 0x01, 0x40, 0xab, 0xd5, + 0xca, 0xf7, 0x86, 0x87, 0x87, 0xff, 0x8a, 0x61, 0x98, 0xcb, 0x00, 0x02, + 0xd2, 0xf5, 0xbf, 0xfa, 0xd5, 0xaf, 0xc8, 0x89, 0x13, 0x27, 0x48, 0x4d, + 0x4d, 0x0d, 0xf1, 0xfb, 0xfd, 0x44, 0x14, 0x45, 0x32, 0x10, 0x74, 0xe0, + 0xc0, 0x01, 0xb2, 0x70, 0xe1, 0x42, 0xb2, 0x70, 0xe1, 0x42, 0xb2, 0x60, + 0xc1, 0x02, 0x32, 0x7b, 0xf6, 0x6c, 0x32, 0x75, 0xea, 0x54, 0x92, 0x98, + 0x98, 0x28, 0xf5, 0x35, 0x40, 0x51, 0x54, 0x49, 0x78, 0x78, 0xf8, 0xaf, + 0xaf, 0x7e, 0x47, 0x95, 0x4a, 0xf5, 0x01, 0x45, 0x51, 0x4d, 0x00, 0x44, + 0x00, 0x84, 0x65, 0x59, 0x12, 0x15, 0x15, 0x45, 0x86, 0x0e, 0x1d, 0x4a, + 0xa2, 0xa3, 0xa3, 0x09, 0x00, 0xa2, 0xd7, 0xeb, 0x37, 0x0c, 0xc4, 0x78, + 0x52, 0x03, 0xc0, 0x90, 0x58, 0x9f, 0xcf, 0x97, 0xaf, 0x50, 0x28, 0x2c, + 0xe9, 0xe9, 0xe9, 0x00, 0x00, 0x86, 0x61, 0x20, 0x8a, 0x22, 0x1a, 0x1a, + 0x1a, 0x60, 0xb5, 0x5a, 0xe1, 0xf3, 0xf9, 0x40, 0x08, 0x81, 0x56, 0xab, + 0x7d, 0x57, 0xad, 0x56, 0xbf, 0xea, 0xf7, 0xfb, 0xd3, 0x78, 0x9e, 0xff, + 0xc0, 0xef, 0xf7, 0x8f, 0xd6, 0x6a, 0xb5, 0x18, 0x35, 0x6a, 0x14, 0x96, + 0x2d, 0x5b, 0x86, 0xd5, 0xab, 0x57, 0xff, 0xa4, 0x93, 0xe7, 0xeb, 0xaf, + 0xbf, 0xc6, 0xa6, 0x4d, 0x9b, 0x40, 0xd3, 0xb4, 0xfc, 0x19, 0xcb, 0xb2, + 0x10, 0x04, 0x01, 0x97, 0x2e, 0x5d, 0x42, 0x7d, 0x7d, 0x3d, 0x5c, 0x2e, + 0x17, 0x94, 0x4a, 0x65, 0x01, 0xcb, 0xb2, 0x8f, 0x30, 0x0c, 0x23, 0xfa, + 0x7c, 0xbe, 0xbf, 0x73, 0x1c, 0x17, 0xc7, 0xb2, 0x2c, 0xf4, 0x7a, 0x3d, + 0x62, 0x62, 0x62, 0x60, 0x30, 0x18, 0x20, 0x8a, 0x22, 0x00, 0xc0, 0x6e, + 0xb7, 0xa3, 0xb4, 0xb4, 0x14, 0x7a, 0xbd, 0xfe, 0x13, 0xa7, 0xd3, 0x79, + 0xef, 0xcf, 0xce, 0x10, 0x83, 0xc1, 0x10, 0xe1, 0xf1, 0x78, 0x4e, 0xd1, + 0x34, 0x9d, 0x92, 0x9e, 0x9e, 0x1e, 0xf4, 0xb2, 0x14, 0x45, 0x81, 0x10, + 0x02, 0xa7, 0xd3, 0x89, 0xba, 0xba, 0x3a, 0x78, 0x3c, 0x1e, 0xd0, 0x34, + 0xdd, 0x04, 0xc0, 0x22, 0x8a, 0x22, 0x7d, 0xdf, 0x7d, 0xf7, 0xe1, 0x89, + 0x27, 0x9e, 0x40, 0x6a, 0x6a, 0x2a, 0x14, 0x0a, 0xc5, 0xbf, 0x65, 0x45, + 0x6f, 0xdf, 0xbe, 0x1d, 0x9b, 0x37, 0x6f, 0x06, 0xc3, 0x30, 0x41, 0x9f, + 0xd3, 0x34, 0x0d, 0x41, 0x10, 0xd0, 0xdc, 0xdc, 0x8c, 0xe2, 0xe2, 0x62, + 0xb4, 0xb5, 0xb5, 0x09, 0xed, 0xfd, 0x67, 0xa2, 0xa3, 0xa3, 0x11, 0x1d, + 0x1d, 0x0d, 0x96, 0x65, 0x83, 0x44, 0x19, 0x4d, 0xd3, 0x68, 0x6a, 0x6a, + 0x42, 0x75, 0x75, 0x35, 0x8c, 0x46, 0xe3, 0xe3, 0x0e, 0x87, 0xe3, 0x9d, + 0x6b, 0xed, 0x1f, 0x7d, 0xad, 0x0d, 0x8c, 0x19, 0x33, 0xc6, 0x41, 0x51, + 0x54, 0x09, 0xc7, 0x71, 0xe0, 0x79, 0x1e, 0x5d, 0xc9, 0x60, 0xa3, 0xd1, + 0x88, 0xd4, 0xd4, 0x54, 0x44, 0x46, 0x46, 0x42, 0x14, 0xc5, 0x28, 0x51, + 0x14, 0xe9, 0x1f, 0x7e, 0xf8, 0x01, 0xff, 0xf3, 0x3f, 0xff, 0x83, 0x51, + 0xa3, 0x46, 0xfd, 0xdb, 0x98, 0x01, 0x00, 0x37, 0xdc, 0x70, 0x03, 0xf4, + 0x7a, 0x3d, 0x28, 0x2a, 0x78, 0x2e, 0x8a, 0xa2, 0x08, 0x8a, 0xa2, 0x10, + 0x13, 0x13, 0x03, 0x8b, 0xc5, 0xd2, 0xbe, 0xd0, 0x19, 0x26, 0x35, 0x35, + 0x15, 0x09, 0x09, 0x09, 0x60, 0x18, 0x06, 0x84, 0x90, 0x20, 0xbd, 0x42, + 0x08, 0x81, 0xdb, 0xed, 0x06, 0x00, 0xa4, 0xa4, 0xa4, 0x7c, 0x31, 0x10, + 0xfd, 0xbb, 0x66, 0x86, 0x1c, 0x3b, 0x76, 0x8c, 0x57, 0x28, 0x14, 0x47, + 0x01, 0xa0, 0xb5, 0xb5, 0xb5, 0xd3, 0xcc, 0xeb, 0xc8, 0x98, 0xc4, 0xc4, + 0x44, 0xc4, 0xc5, 0xc5, 0x01, 0x00, 0xd6, 0xaf, 0x5f, 0x1f, 0xf4, 0x72, + 0xff, 0x2e, 0x12, 0x45, 0xb1, 0xc7, 0xe7, 0xda, 0xed, 0x76, 0x54, 0x56, + 0x56, 0x82, 0x65, 0x59, 0xa4, 0xa5, 0xa5, 0x41, 0xab, 0xd5, 0xca, 0xe2, + 0xe9, 0x6a, 0x12, 0x04, 0x01, 0x36, 0x9b, 0x0d, 0x2a, 0x95, 0xaa, 0x24, + 0x27, 0x27, 0xa7, 0xfe, 0x3f, 0x82, 0x21, 0xed, 0xe6, 0xde, 0xfb, 0x14, + 0x45, 0xa1, 0xb9, 0xb9, 0x19, 0x82, 0x20, 0x74, 0x7b, 0x1d, 0x21, 0x04, + 0xd1, 0xd1, 0xd1, 0x50, 0x2a, 0x95, 0xc8, 0xcd, 0xcd, 0x45, 0x6d, 0x6d, + 0xed, 0xbf, 0x95, 0x19, 0x56, 0xab, 0x15, 0x9b, 0x37, 0x6f, 0x86, 0xcb, + 0xe5, 0xea, 0x92, 0x29, 0x14, 0x45, 0xa1, 0xad, 0xad, 0x0d, 0x1c, 0xc7, + 0x21, 0x21, 0x21, 0xa1, 0xc7, 0x95, 0x4b, 0x51, 0x14, 0xac, 0x56, 0x2b, + 0x08, 0x21, 0x60, 0x18, 0x66, 0xc3, 0x40, 0xf5, 0x91, 0xbd, 0xd6, 0x06, + 0xe2, 0xe2, 0xe2, 0x70, 0xf0, 0xe0, 0x41, 0x87, 0xc1, 0x60, 0x78, 0xd3, + 0xe9, 0x74, 0x3e, 0xd9, 0xdc, 0xdc, 0x8c, 0xc8, 0xc8, 0xc8, 0x1e, 0x5f, + 0x84, 0x65, 0x59, 0x78, 0xbd, 0x5e, 0xf8, 0xfd, 0xfe, 0x7f, 0x0b, 0x23, + 0x4a, 0x4a, 0x4a, 0xf0, 0xc3, 0x0f, 0x3f, 0xe0, 0xe0, 0xc1, 0x83, 0xb0, + 0xdb, 0xed, 0xb2, 0x2e, 0xe8, 0xaa, 0x6f, 0x1c, 0xc7, 0x01, 0x00, 0xf4, + 0x7a, 0x7d, 0x8f, 0x2b, 0x49, 0x14, 0x45, 0x34, 0x35, 0x35, 0x81, 0xa6, + 0x69, 0xab, 0x42, 0xa1, 0xd8, 0x0b, 0x00, 0xe9, 0xe9, 0xe9, 0x28, 0x2c, + 0x2c, 0xfc, 0x79, 0x19, 0x52, 0x57, 0x57, 0x87, 0xb8, 0xb8, 0x38, 0xd8, + 0x6c, 0xb6, 0x3f, 0xd1, 0x34, 0xfd, 0x60, 0x53, 0x53, 0x93, 0x3e, 0x22, + 0x22, 0xa2, 0x4b, 0xd1, 0x25, 0xbd, 0x88, 0x28, 0x8a, 0xd0, 0xeb, 0xf5, + 0x50, 0xa9, 0x54, 0x3f, 0x19, 0x13, 0xea, 0xeb, 0xeb, 0x91, 0x93, 0x93, + 0x83, 0x5d, 0xbb, 0x76, 0xa1, 0xba, 0xba, 0x1a, 0x5e, 0xaf, 0x17, 0x2a, + 0x95, 0xaa, 0xdb, 0x7e, 0x49, 0x2b, 0x58, 0xa9, 0xbc, 0xe2, 0x8a, 0xf8, + 0xfd, 0xfe, 0x6e, 0x57, 0x08, 0x4d, 0xd3, 0x68, 0x6e, 0x6e, 0x86, 0xdf, + 0xef, 0x87, 0x52, 0xa9, 0xdc, 0x39, 0x72, 0xe4, 0xc8, 0xea, 0x40, 0x20, + 0x80, 0x33, 0x67, 0xce, 0xfc, 0xbc, 0x2b, 0x84, 0x10, 0x02, 0x8a, 0xa2, + 0x50, 0x57, 0x57, 0x07, 0x00, 0x75, 0x3a, 0x9d, 0x6e, 0x93, 0xdb, 0xed, + 0x7e, 0xb2, 0xa9, 0xa9, 0x09, 0x71, 0x71, 0x71, 0x5d, 0xce, 0xb0, 0x40, + 0x20, 0x00, 0xbf, 0xdf, 0x8f, 0x61, 0xc3, 0x86, 0xf5, 0xb8, 0x92, 0xfa, + 0x4b, 0x3c, 0xcf, 0xe3, 0xd5, 0x57, 0x5f, 0x45, 0x5e, 0x5e, 0x9e, 0x3c, + 0xdb, 0x29, 0x8a, 0x0a, 0x89, 0xf9, 0xed, 0xa6, 0x39, 0x68, 0x9a, 0x46, + 0x43, 0x43, 0x03, 0x86, 0x0d, 0x1b, 0xd6, 0xe9, 0x1d, 0x28, 0x8a, 0x82, + 0xc7, 0xe3, 0x41, 0x55, 0x55, 0x15, 0x28, 0x8a, 0x72, 0xa5, 0xa7, 0xa7, + 0xaf, 0x39, 0x7e, 0xfc, 0xb8, 0xac, 0x64, 0x2e, 0x5c, 0xb8, 0x80, 0x91, + 0x23, 0x47, 0xfe, 0xfb, 0x75, 0xc8, 0xa2, 0x45, 0x8b, 0x18, 0xbd, 0x5e, + 0x1f, 0x11, 0x11, 0x11, 0x91, 0xac, 0xd7, 0xeb, 0xb3, 0xf5, 0x7a, 0xfd, + 0x5c, 0xa5, 0x52, 0x79, 0x80, 0x61, 0x98, 0x40, 0x43, 0x43, 0x03, 0x9a, + 0x9b, 0x9b, 0xe5, 0xd9, 0x24, 0x99, 0xc2, 0x1c, 0xc7, 0xa1, 0xa2, 0xa2, + 0x02, 0x84, 0x10, 0xac, 0x5a, 0xb5, 0x6a, 0xc0, 0x57, 0x48, 0x20, 0x10, + 0xc0, 0xea, 0xd5, 0xab, 0x71, 0xe2, 0xc4, 0x09, 0xf0, 0x3c, 0x0f, 0x8a, + 0xa2, 0x3a, 0x59, 0x53, 0xbd, 0x91, 0xc9, 0x64, 0x82, 0x5e, 0xaf, 0x87, + 0xd3, 0xe9, 0x44, 0x4b, 0x4b, 0x8b, 0x3c, 0xe9, 0x68, 0x9a, 0x06, 0x45, + 0x51, 0xf0, 0xfb, 0xfd, 0x28, 0x2b, 0x2b, 0x03, 0x00, 0x28, 0x14, 0x8a, + 0xc2, 0xa2, 0xa2, 0xa2, 0x58, 0x9d, 0x4e, 0x37, 0x57, 0xab, 0xd5, 0x66, + 0x5b, 0x2c, 0x96, 0x94, 0xac, 0xac, 0xac, 0x88, 0x25, 0x4b, 0x96, 0xc8, + 0xcb, 0xb0, 0x63, 0x7c, 0x6e, 0x40, 0xfd, 0x10, 0xa3, 0xd1, 0x08, 0x87, + 0xc3, 0x81, 0x76, 0x6f, 0x7b, 0x15, 0xc7, 0x71, 0x73, 0x44, 0x51, 0xcc, + 0x14, 0x45, 0x51, 0x47, 0x08, 0x51, 0x02, 0x90, 0x3a, 0xc1, 0x00, 0x60, + 0x28, 0x8a, 0x82, 0xc1, 0x60, 0x80, 0x46, 0xa3, 0x91, 0x5f, 0xc4, 0xe9, + 0x74, 0x82, 0xe7, 0x79, 0x3c, 0xf7, 0xdc, 0x73, 0xf8, 0xfd, 0xef, 0x7f, + 0x3f, 0xa0, 0xcc, 0x10, 0x04, 0x01, 0xaf, 0xbe, 0xfa, 0x2a, 0x4e, 0x9d, + 0x3a, 0xd5, 0xa3, 0x58, 0xea, 0x75, 0x40, 0x28, 0x0a, 0x2e, 0x97, 0x0b, + 0x47, 0x8e, 0x1c, 0x81, 0x28, 0x8a, 0xd0, 0x68, 0x34, 0xd0, 0xeb, 0xf5, + 0x60, 0x18, 0x06, 0x3c, 0xcf, 0xc3, 0xe1, 0x70, 0x20, 0x10, 0x08, 0x74, + 0xd4, 0x17, 0xfe, 0xf6, 0x71, 0x14, 0x28, 0x8a, 0x0a, 0xd0, 0x34, 0xed, + 0xa2, 0x69, 0xfa, 0x9c, 0x52, 0xa9, 0xdc, 0xe7, 0x72, 0xb9, 0xde, 0xa7, + 0x28, 0x4a, 0x1c, 0x30, 0x86, 0x8c, 0x1c, 0x39, 0x12, 0x17, 0x2e, 0x5c, + 0x90, 0xa2, 0xaf, 0x83, 0xdc, 0x6e, 0xf7, 0x43, 0x81, 0x40, 0x60, 0xb5, + 0x28, 0x8a, 0x6a, 0x00, 0x48, 0x4e, 0x4e, 0x46, 0x62, 0x62, 0x22, 0x06, + 0x0f, 0x1e, 0x8c, 0xd8, 0xd8, 0x58, 0x59, 0x47, 0xdc, 0x72, 0xcb, 0x2d, + 0x78, 0xe0, 0x81, 0x07, 0x3a, 0x45, 0x3f, 0x87, 0x0e, 0x1d, 0x8a, 0x55, + 0xab, 0x56, 0xfd, 0x24, 0x1e, 0x79, 0x41, 0x41, 0x01, 0x9e, 0x7f, 0xfe, + 0xf9, 0x1e, 0xad, 0xbc, 0x90, 0xc5, 0x06, 0x4d, 0xc3, 0xeb, 0xf5, 0x22, + 0x2f, 0x2f, 0x0f, 0x56, 0xab, 0x35, 0xa8, 0xcd, 0x88, 0x88, 0x08, 0xbc, + 0xf0, 0xc2, 0x0b, 0xf8, 0xf5, 0xaf, 0x7f, 0x8d, 0xe7, 0x9f, 0x7f, 0x1e, + 0x1a, 0x8d, 0x06, 0x84, 0x10, 0x34, 0x36, 0x36, 0xa2, 0xb2, 0xb2, 0x12, + 0xd5, 0xd5, 0xd5, 0x28, 0x29, 0x29, 0x91, 0x98, 0xeb, 0xd1, 0x6a, 0xb5, + 0xef, 0xe9, 0x74, 0xba, 0x8d, 0x4d, 0x4d, 0x4d, 0x55, 0x00, 0x60, 0xb1, + 0x58, 0xd0, 0xd2, 0xd2, 0xd2, 0x77, 0x86, 0x48, 0x37, 0xee, 0xda, 0xb5, + 0x8b, 0xbe, 0xfd, 0xf6, 0xdb, 0xdf, 0x74, 0xbb, 0xdd, 0x0f, 0x00, 0xd0, + 0xa9, 0x54, 0x2a, 0xac, 0x5c, 0xb9, 0x12, 0x4f, 0x3d, 0xf5, 0x14, 0xf4, + 0x7a, 0x3d, 0x0c, 0x06, 0x43, 0x97, 0xf7, 0x73, 0x1c, 0x87, 0xfa, 0xfa, + 0x7a, 0xb4, 0xb5, 0xb5, 0xc1, 0xe7, 0xf3, 0x21, 0x3a, 0x3a, 0x1a, 0x66, + 0xb3, 0x19, 0x7a, 0xbd, 0xfe, 0x27, 0x51, 0xe2, 0xeb, 0xd7, 0xaf, 0xc7, + 0x91, 0x23, 0x47, 0xae, 0x69, 0x75, 0x74, 0xa7, 0x93, 0xda, 0x95, 0x37, + 0x36, 0x6c, 0xd8, 0x80, 0xf8, 0xf8, 0x78, 0xc9, 0x71, 0xec, 0x92, 0x9c, + 0x4e, 0x27, 0x5c, 0x2e, 0x17, 0xde, 0x78, 0xe3, 0x0d, 0xbc, 0xf7, 0xde, + 0x7b, 0xe0, 0x38, 0x0e, 0x14, 0x45, 0xb9, 0xb4, 0x5a, 0xed, 0x5f, 0x5d, + 0x2e, 0xd7, 0x2a, 0x8a, 0xa2, 0x10, 0x19, 0x19, 0x29, 0x8b, 0xf4, 0x5e, + 0x19, 0xb2, 0x62, 0xc5, 0x0a, 0xfc, 0xe5, 0x2f, 0x7f, 0x91, 0xc2, 0x22, + 0xd3, 0xbc, 0x5e, 0xef, 0x9b, 0x3c, 0xcf, 0x67, 0x0e, 0x1e, 0x3c, 0x18, + 0xcb, 0x97, 0x2f, 0xc7, 0x9a, 0x35, 0x6b, 0x60, 0x32, 0xfd, 0x67, 0x04, + 0x36, 0x25, 0x72, 0xbb, 0xdd, 0x58, 0xbe, 0x7c, 0xb9, 0xf4, 0xf2, 0x03, + 0xde, 0x3e, 0x45, 0x51, 0xd0, 0x68, 0x34, 0xf8, 0xf0, 0xc3, 0x0f, 0x61, + 0x36, 0x9b, 0x43, 0xbe, 0xcf, 0xe9, 0x74, 0x62, 0xc3, 0x86, 0x0d, 0xf8, + 0xdb, 0xdf, 0xfe, 0x86, 0x8a, 0x8a, 0x0a, 0x28, 0x14, 0x8a, 0x7c, 0xa5, + 0x52, 0xf9, 0x88, 0xdb, 0xed, 0x3e, 0xa2, 0xd5, 0x6a, 0xe1, 0xf1, 0x78, + 0x42, 0x5f, 0x21, 0x6a, 0xb5, 0xfa, 0x2d, 0xbf, 0xdf, 0xff, 0x10, 0x21, + 0x44, 0xfd, 0xcc, 0x33, 0xcf, 0x60, 0xcd, 0x9a, 0x35, 0x88, 0x88, 0x88, + 0xc0, 0x7f, 0x22, 0x55, 0x57, 0x57, 0x63, 0xe9, 0xd2, 0xa5, 0x3f, 0x69, + 0xff, 0x58, 0x96, 0xc5, 0xc6, 0x8d, 0x1b, 0xe5, 0x48, 0x43, 0x5f, 0xa8, + 0xa5, 0xa5, 0x05, 0xef, 0xbc, 0xf3, 0x0e, 0xd6, 0xad, 0x5b, 0x07, 0x8a, + 0xa2, 0xbc, 0x6a, 0xb5, 0xfa, 0x7f, 0xbc, 0x5e, 0xef, 0xaa, 0x1e, 0xad, + 0xac, 0xe8, 0xe8, 0x68, 0x29, 0x26, 0xa3, 0x57, 0x2a, 0x95, 0xbb, 0x7c, + 0x3e, 0xdf, 0xe3, 0xb1, 0xb1, 0xb1, 0xea, 0x6f, 0xbf, 0xfd, 0x16, 0x7f, + 0xfc, 0xe3, 0x1f, 0xff, 0x63, 0x99, 0x21, 0xf9, 0x0c, 0x3f, 0x75, 0x18, + 0x46, 0x10, 0x84, 0x7e, 0xeb, 0x27, 0x8b, 0xc5, 0x82, 0x57, 0x5f, 0x7d, + 0x15, 0x7b, 0xf6, 0xec, 0x41, 0x74, 0x74, 0xb4, 0xc6, 0xeb, 0xf5, 0xae, + 0x54, 0x2a, 0x95, 0x07, 0x53, 0x52, 0x52, 0xc2, 0x24, 0xbd, 0xd4, 0x89, + 0x21, 0x8d, 0x8d, 0x8d, 0xb8, 0xe3, 0x8e, 0x3b, 0x94, 0x55, 0x55, 0x55, + 0xb9, 0x81, 0x40, 0x60, 0x7e, 0x56, 0x56, 0x16, 0xf2, 0xf2, 0xf2, 0xb0, + 0x68, 0xd1, 0x22, 0xfc, 0xa7, 0x93, 0xc5, 0x62, 0x09, 0xca, 0xb3, 0xfc, + 0x14, 0x24, 0x99, 0xbd, 0xd7, 0x42, 0x73, 0xe6, 0xcc, 0x41, 0x6e, 0x6e, + 0x2e, 0xc6, 0x8d, 0x1b, 0x87, 0x40, 0x20, 0x30, 0xbd, 0xb2, 0xb2, 0xf2, + 0xc7, 0x94, 0x94, 0x94, 0x30, 0xab, 0xd5, 0xfa, 0xaf, 0xe7, 0x48, 0xfa, + 0x20, 0x32, 0x32, 0x32, 0x79, 0xdb, 0xb6, 0x6d, 0xa5, 0x81, 0x40, 0x20, + 0xf9, 0xae, 0xbb, 0xee, 0xc2, 0xe9, 0xd3, 0xa7, 0x7b, 0x54, 0x5e, 0x3f, + 0x15, 0x35, 0x37, 0x37, 0xa3, 0xa2, 0xa2, 0x02, 0x65, 0x65, 0x65, 0xa8, + 0xa9, 0xa9, 0x81, 0xd3, 0xe9, 0xec, 0xf5, 0x9e, 0xb0, 0xb0, 0x30, 0x64, + 0x67, 0x67, 0x77, 0x3b, 0x83, 0xdb, 0xf3, 0xed, 0x10, 0x45, 0x11, 0x81, + 0x40, 0x00, 0x3e, 0x9f, 0x0f, 0x7e, 0xbf, 0x5f, 0x76, 0x1c, 0x43, 0x31, + 0x04, 0x14, 0x0a, 0x85, 0xec, 0xc5, 0x5f, 0x0b, 0x45, 0x47, 0x47, 0xe3, + 0xec, 0xd9, 0xb3, 0xb8, 0xfb, 0xee, 0xbb, 0xc1, 0x71, 0xdc, 0xc8, 0xca, + 0xca, 0xca, 0xd3, 0xb1, 0xb1, 0xb1, 0x43, 0xa5, 0x95, 0xc2, 0xda, 0xed, + 0x76, 0xc4, 0xc6, 0xc6, 0xc6, 0x36, 0x37, 0x37, 0x1f, 0xe2, 0x79, 0x3e, + 0x61, 0xd5, 0xaa, 0x55, 0x78, 0xfb, 0xed, 0xb7, 0xff, 0xed, 0x8c, 0x78, + 0xe7, 0x9d, 0x77, 0xb0, 0x7d, 0xfb, 0x76, 0x54, 0x57, 0x57, 0xa3, 0xad, + 0xad, 0x0d, 0x3c, 0xcf, 0x43, 0xad, 0x56, 0x23, 0x2a, 0x2a, 0x0a, 0x29, + 0x29, 0x29, 0x78, 0xe6, 0x99, 0x67, 0x30, 0x69, 0xd2, 0xa4, 0x6e, 0xef, + 0xbf, 0xf7, 0xde, 0x7b, 0x91, 0x9f, 0x9f, 0xdf, 0x29, 0x05, 0xc0, 0xb2, + 0x2c, 0x6c, 0x36, 0x1b, 0x4a, 0x4a, 0x4a, 0xe0, 0x72, 0xb9, 0xe0, 0xf7, + 0xfb, 0x21, 0x81, 0x22, 0x58, 0x96, 0x85, 0x46, 0xa3, 0x41, 0x64, 0x64, + 0x24, 0x52, 0x53, 0x53, 0xbb, 0x8d, 0x04, 0x53, 0x14, 0x05, 0xb5, 0x5a, + 0xdd, 0xad, 0x45, 0xd9, 0x1f, 0xda, 0xba, 0x75, 0x2b, 0x2c, 0x16, 0x0b, + 0xde, 0x7a, 0xeb, 0xad, 0x61, 0x4d, 0x4d, 0x4d, 0xc7, 0x87, 0x0d, 0x1b, + 0x36, 0xbe, 0xb8, 0xb8, 0xb8, 0x86, 0x89, 0x8a, 0x8a, 0x32, 0x5a, 0xad, + 0xd6, 0x23, 0x3c, 0xcf, 0x27, 0x3f, 0xf9, 0xe4, 0x93, 0x78, 0xfb, 0xed, + 0xb7, 0x83, 0x92, 0x4c, 0x3f, 0x35, 0x7d, 0xf9, 0xe5, 0x97, 0x98, 0x38, + 0x71, 0x22, 0xbe, 0xf9, 0xe6, 0x1b, 0x54, 0x56, 0x56, 0x22, 0x2c, 0x2c, + 0x0c, 0x49, 0x49, 0x49, 0x88, 0x8f, 0x8f, 0x87, 0x5a, 0xad, 0x46, 0x4d, + 0x4d, 0x0d, 0x72, 0x73, 0x73, 0xf1, 0xf1, 0xc7, 0x1f, 0x23, 0x27, 0x27, + 0x07, 0xe3, 0xc7, 0x8f, 0xef, 0xd2, 0xd2, 0x89, 0x88, 0x88, 0x40, 0x64, + 0x64, 0x24, 0xce, 0x9d, 0x3b, 0x87, 0x40, 0x20, 0x00, 0x86, 0x61, 0xe0, + 0xf3, 0xf9, 0x90, 0x97, 0x97, 0x87, 0x82, 0x82, 0x02, 0x38, 0x9d, 0x4e, + 0x68, 0x34, 0x1a, 0x0c, 0x1b, 0x36, 0x0c, 0xc9, 0xc9, 0xc9, 0x88, 0x89, + 0x89, 0x01, 0xc3, 0x30, 0xa8, 0xab, 0xab, 0x43, 0x4b, 0x4b, 0x0b, 0x2e, + 0x5f, 0xbe, 0x0c, 0x8d, 0x46, 0x03, 0xa3, 0xd1, 0xd8, 0xa5, 0xfe, 0x48, + 0x4f, 0x4f, 0xc7, 0xdc, 0xb9, 0x73, 0x07, 0x54, 0x04, 0xce, 0x9d, 0x3b, + 0x17, 0x36, 0x9b, 0x0d, 0x27, 0x4f, 0x9e, 0xd4, 0xdb, 0xed, 0xf6, 0x05, + 0xb1, 0xb1, 0xb1, 0x9f, 0x43, 0xab, 0xd5, 0x7e, 0x02, 0x80, 0xdc, 0x78, + 0xe3, 0x8d, 0x7d, 0xce, 0x53, 0xfb, 0x7c, 0xbe, 0x7e, 0xe7, 0xb8, 0x39, + 0x8e, 0x23, 0x37, 0xdd, 0x74, 0x13, 0x01, 0x40, 0x54, 0x2a, 0x15, 0xb9, + 0xff, 0xfe, 0xfb, 0x49, 0x45, 0x45, 0x05, 0x71, 0x3a, 0x9d, 0x24, 0x10, + 0x08, 0x10, 0x8e, 0xe3, 0x88, 0xcf, 0xe7, 0x23, 0x6d, 0x6d, 0x6d, 0xe4, + 0xe0, 0xc1, 0x83, 0x64, 0xdc, 0xb8, 0x71, 0x04, 0x00, 0xd1, 0x6a, 0xb5, + 0x64, 0xfb, 0xf6, 0xed, 0xdd, 0xb6, 0xdb, 0xd2, 0xd2, 0x42, 0xfe, 0xf0, + 0x87, 0x3f, 0x90, 0x49, 0x93, 0x26, 0x11, 0x85, 0x42, 0x41, 0x00, 0x90, + 0x11, 0x23, 0x46, 0x90, 0xef, 0xbe, 0xfb, 0x8e, 0xd8, 0x6c, 0x36, 0xe2, + 0xf5, 0x7a, 0x09, 0xc7, 0x71, 0x24, 0x10, 0x08, 0x10, 0xa7, 0xd3, 0x49, + 0x6a, 0x6a, 0x6a, 0xc8, 0xea, 0xd5, 0xab, 0x89, 0x46, 0xa3, 0x21, 0x00, + 0x48, 0x78, 0x78, 0x38, 0x99, 0x37, 0x6f, 0x9e, 0x9c, 0x7f, 0x5f, 0xb8, + 0x70, 0x21, 0x99, 0x36, 0x6d, 0x1a, 0x69, 0x68, 0x68, 0xf8, 0xc9, 0xc6, + 0x64, 0xc6, 0x8c, 0x19, 0xd2, 0x38, 0x6c, 0x85, 0x4a, 0xa5, 0xba, 0x00, + 0x80, 0x44, 0x46, 0x46, 0x92, 0x5b, 0x6e, 0xb9, 0x85, 0x6c, 0xdc, 0xb8, + 0x91, 0x9c, 0x3e, 0x7d, 0x9a, 0x54, 0x57, 0x57, 0x13, 0xaf, 0xd7, 0x1b, + 0x74, 0xa3, 0xd7, 0xeb, 0x25, 0x65, 0x65, 0x65, 0xe4, 0xcb, 0x2f, 0xbf, + 0x24, 0xb3, 0x66, 0xcd, 0x22, 0xa3, 0x47, 0x8f, 0x26, 0x3c, 0xcf, 0xf7, + 0xb9, 0x03, 0x81, 0x40, 0x40, 0x66, 0xc6, 0xe4, 0xc9, 0x93, 0x49, 0x5e, + 0x5e, 0x5e, 0x48, 0xf7, 0x6d, 0xda, 0xb4, 0x89, 0x84, 0x87, 0x87, 0x13, + 0x00, 0x64, 0xf3, 0xe6, 0xcd, 0xdd, 0x5e, 0xb7, 0x77, 0xef, 0x5e, 0x42, + 0xd3, 0x34, 0x31, 0x1a, 0x8d, 0xe4, 0x8d, 0x37, 0xde, 0x08, 0xa9, 0xed, + 0x92, 0x92, 0x12, 0x32, 0x7b, 0xf6, 0x6c, 0x02, 0x80, 0x44, 0x44, 0x44, + 0x90, 0xf9, 0xf3, 0xe7, 0x93, 0xb9, 0x73, 0xe7, 0x92, 0x45, 0x8b, 0x16, + 0x91, 0x7d, 0xfb, 0xf6, 0x85, 0xd4, 0x86, 0xc7, 0xe3, 0x21, 0xd7, 0x5f, + 0x7f, 0x3d, 0x99, 0x35, 0x6b, 0x16, 0xd9, 0xb6, 0x6d, 0x1b, 0x29, 0x2b, + 0x2b, 0x23, 0x1e, 0x8f, 0xa7, 0xd3, 0x18, 0xd6, 0xd4, 0xd4, 0x90, 0xd3, + 0xa7, 0x4f, 0x93, 0x8d, 0x1b, 0x37, 0x92, 0x5b, 0x6e, 0xb9, 0x85, 0x58, + 0x2c, 0x16, 0x02, 0x80, 0xe8, 0x74, 0xba, 0x7f, 0x22, 0x2c, 0x2c, 0xcc, + 0xa0, 0xd7, 0xeb, 0x17, 0xa9, 0x54, 0xaa, 0x02, 0x5c, 0x81, 0xf0, 0x10, + 0xa5, 0x52, 0x49, 0xa2, 0xa3, 0xa3, 0x49, 0x7a, 0x7a, 0x3a, 0xc9, 0xca, + 0xca, 0x22, 0x93, 0x26, 0x4d, 0x22, 0x13, 0x26, 0x4c, 0x20, 0xe9, 0xe9, + 0xe9, 0xc4, 0x6c, 0x36, 0x13, 0x96, 0x65, 0x09, 0x00, 0xa2, 0x54, 0x2a, + 0xfb, 0xb5, 0x3a, 0x6e, 0xbb, 0xed, 0x36, 0x02, 0x80, 0xfc, 0xf2, 0x97, + 0xbf, 0xec, 0x33, 0xaa, 0xa4, 0xb0, 0xb0, 0x90, 0x98, 0x4c, 0x26, 0xa2, + 0xd7, 0xeb, 0xc9, 0x99, 0x33, 0x67, 0x3a, 0x7d, 0x5f, 0x55, 0x55, 0x25, + 0x7f, 0x7f, 0xf2, 0xe4, 0xc9, 0x3e, 0xb5, 0x2d, 0x8a, 0x22, 0x59, 0xbd, + 0x7a, 0x35, 0x01, 0x40, 0x2c, 0x16, 0x0b, 0x79, 0xe2, 0x89, 0x27, 0x48, + 0x45, 0x45, 0x45, 0xc8, 0x7d, 0xf4, 0x7a, 0xbd, 0x24, 0x3d, 0x3d, 0x9d, + 0xa0, 0x1d, 0x99, 0x62, 0x36, 0x9b, 0x49, 0x5a, 0x5a, 0x1a, 0x99, 0x30, + 0x61, 0x02, 0x99, 0x34, 0x69, 0x12, 0xc9, 0xca, 0xca, 0x22, 0xe9, 0xe9, + 0xe9, 0x24, 0x26, 0x26, 0x86, 0x28, 0x95, 0x4a, 0x22, 0x41, 0xa7, 0x54, + 0x2a, 0x55, 0x81, 0xc1, 0x60, 0x58, 0x14, 0x11, 0x11, 0x11, 0x2c, 0x2f, + 0x53, 0x52, 0x52, 0x52, 0x34, 0x1a, 0xcd, 0xab, 0x2c, 0xcb, 0xee, 0xa6, + 0x69, 0xfa, 0x22, 0x80, 0x36, 0x74, 0x00, 0xa9, 0x51, 0x14, 0x15, 0xf4, + 0xff, 0xfe, 0x88, 0xb9, 0xa3, 0x47, 0x8f, 0x12, 0x96, 0x65, 0x49, 0x52, + 0x52, 0x12, 0x71, 0xb9, 0x5c, 0xfd, 0x82, 0xf9, 0xec, 0xda, 0xb5, 0x8b, + 0x00, 0x20, 0x13, 0x26, 0x4c, 0xe8, 0xf4, 0xdd, 0x94, 0x29, 0x53, 0x08, + 0x00, 0xb2, 0x69, 0xd3, 0xa6, 0x7e, 0x4d, 0x16, 0x9f, 0xcf, 0x47, 0xb2, + 0xb2, 0xb2, 0x08, 0x00, 0x72, 0xec, 0xd8, 0xb1, 0x3e, 0xdf, 0xbf, 0x6c, + 0xd9, 0x32, 0x72, 0xd5, 0x98, 0xb9, 0xae, 0xfa, 0xbf, 0x9d, 0xa6, 0xe9, + 0x8b, 0x2c, 0xcb, 0xee, 0xd1, 0x68, 0x34, 0xaf, 0x0e, 0x1b, 0x36, 0x2c, + 0xb9, 0x57, 0x85, 0xb3, 0x60, 0xc1, 0x02, 0x3a, 0x2c, 0x2c, 0x4c, 0xab, + 0x56, 0xab, 0xc3, 0x54, 0x2a, 0x95, 0x99, 0xa2, 0x28, 0x0b, 0xc3, 0x30, + 0x46, 0x9d, 0x4e, 0xf7, 0xb6, 0xb4, 0x8a, 0x00, 0x90, 0xbf, 0xfc, 0xe5, + 0x2f, 0x7d, 0xee, 0xf0, 0xdc, 0xb9, 0x73, 0x09, 0x80, 0x90, 0xc5, 0x40, + 0x77, 0xf4, 0xe8, 0xa3, 0x8f, 0x12, 0x00, 0xe4, 0xb3, 0xcf, 0x3e, 0x93, + 0x3f, 0xfb, 0xfc, 0xf3, 0xcf, 0x09, 0x00, 0x72, 0xc3, 0x0d, 0x37, 0x5c, + 0x53, 0xdb, 0xc7, 0x8f, 0x1f, 0x27, 0x00, 0x48, 0x42, 0x42, 0x42, 0x9f, + 0xef, 0x7d, 0xe1, 0x85, 0x17, 0x24, 0xf0, 0x1c, 0x01, 0x40, 0xd4, 0x6a, + 0xf5, 0x9b, 0x6a, 0xb5, 0x3a, 0x8c, 0xa2, 0x28, 0x8b, 0x52, 0xa9, 0x34, + 0x6b, 0xb5, 0xda, 0xb0, 0xf0, 0xf0, 0x70, 0xed, 0x0d, 0x37, 0xdc, 0x10, + 0x64, 0x39, 0x85, 0x6c, 0x52, 0x4b, 0x5e, 0xa4, 0x56, 0xab, 0xbd, 0x09, + 0x00, 0x19, 0x34, 0x68, 0x10, 0x99, 0x39, 0x73, 0x26, 0x01, 0x40, 0xce, + 0x9f, 0x3f, 0xdf, 0xa7, 0xce, 0x5e, 0xbc, 0x78, 0x91, 0x50, 0x14, 0x45, + 0x26, 0x4e, 0x9c, 0x78, 0xcd, 0xc0, 0xb7, 0xfc, 0xfc, 0x7c, 0xa2, 0xd7, + 0xeb, 0x49, 0x46, 0x46, 0x86, 0x2c, 0x6e, 0x66, 0xcd, 0x9a, 0x45, 0x00, + 0xf4, 0x59, 0x54, 0x75, 0x45, 0x92, 0x3e, 0xe9, 0xeb, 0xc4, 0xf9, 0xe4, + 0x93, 0x4f, 0x08, 0x4d, 0xd3, 0xe4, 0xba, 0xeb, 0xae, 0x23, 0x63, 0xc6, + 0x8c, 0x21, 0x00, 0x44, 0xa3, 0xd1, 0xb8, 0x00, 0xb8, 0x82, 0x5f, 0x1e, + 0x10, 0x8a, 0x8b, 0x8b, 0x4b, 0xa7, 0x69, 0xda, 0x0d, 0x80, 0x9c, 0x3e, + 0x7d, 0x9a, 0xcc, 0x9a, 0x35, 0x8b, 0x18, 0x8d, 0x46, 0x52, 0x59, 0x59, + 0xd9, 0xa7, 0xce, 0x6e, 0xd9, 0xb2, 0x85, 0x00, 0x20, 0x3b, 0x77, 0xee, + 0xbc, 0xe6, 0x01, 0xb3, 0xdb, 0xed, 0x24, 0x23, 0x23, 0x83, 0x98, 0xcd, + 0x66, 0x52, 0x5b, 0x5b, 0x4b, 0x9a, 0x9a, 0x9a, 0xc8, 0xa0, 0x41, 0x83, + 0x48, 0x42, 0x42, 0x02, 0xb1, 0x5a, 0xad, 0xd7, 0xdc, 0xfe, 0xfe, 0xfd, + 0xfb, 0x09, 0x00, 0xb2, 0x6a, 0xd5, 0xaa, 0x3e, 0xdd, 0xb7, 0x77, 0xef, + 0x5e, 0xa2, 0xd1, 0x68, 0x48, 0x46, 0x46, 0x06, 0xc9, 0xc9, 0xc9, 0x91, + 0x30, 0xc5, 0x64, 0xf2, 0xe4, 0xc9, 0x83, 0x06, 0x24, 0x63, 0x38, 0x74, + 0xe8, 0x50, 0x75, 0x73, 0x73, 0xf3, 0x47, 0xa2, 0x28, 0x6a, 0x3f, 0xf8, + 0xe0, 0x03, 0x8c, 0x19, 0x33, 0x46, 0xf6, 0x17, 0xfa, 0x1a, 0xf5, 0xfd, + 0xe7, 0x3f, 0xff, 0x09, 0x96, 0x65, 0x31, 0x68, 0x50, 0xef, 0x7d, 0xe3, + 0x79, 0x1e, 0x3b, 0x76, 0xec, 0xc0, 0x9a, 0x35, 0x6b, 0xb0, 0x6e, 0xdd, + 0x3a, 0x9c, 0x3d, 0x7b, 0x36, 0xe8, 0x7b, 0x83, 0xc1, 0x80, 0x94, 0x94, + 0x14, 0xb4, 0xb6, 0xb6, 0xc2, 0x6a, 0xb5, 0xc2, 0xe9, 0x74, 0xc2, 0x66, + 0xb3, 0xc1, 0x62, 0xb1, 0x74, 0xc2, 0x10, 0xb7, 0xb4, 0xb4, 0x60, 0xd3, + 0xa6, 0x4d, 0x78, 0xec, 0xb1, 0xc7, 0xb0, 0x71, 0xe3, 0xc6, 0x90, 0x90, + 0xee, 0x89, 0x89, 0x89, 0x60, 0x59, 0x16, 0x15, 0x15, 0x15, 0x9d, 0x9c, + 0xcd, 0x9e, 0x48, 0xad, 0x56, 0x43, 0xa7, 0xd3, 0xc1, 0x66, 0xb3, 0x61, + 0xc4, 0x88, 0x11, 0xf8, 0xe0, 0x83, 0x0f, 0x00, 0x00, 0xa7, 0x4e, 0x9d, + 0xda, 0x93, 0x96, 0x96, 0xa6, 0xec, 0x77, 0xa4, 0x7c, 0xfa, 0xf4, 0xe9, + 0x00, 0x00, 0x9d, 0x4e, 0x77, 0xbf, 0x24, 0x97, 0x45, 0x51, 0x24, 0x8d, + 0x8d, 0x8d, 0x24, 0x26, 0x26, 0x86, 0x8c, 0x1a, 0x35, 0x8a, 0x08, 0x82, + 0xd0, 0x27, 0x0b, 0xe6, 0xa6, 0x9b, 0x6e, 0x22, 0x26, 0x93, 0x89, 0x94, + 0x95, 0x95, 0xf5, 0x7a, 0xfd, 0xbd, 0xf7, 0xde, 0x1b, 0xa4, 0x1c, 0xd5, + 0x6a, 0x35, 0xd9, 0xb1, 0x63, 0x47, 0xd0, 0x35, 0xf7, 0xdf, 0x7f, 0x3f, + 0x01, 0x40, 0xce, 0x9d, 0x3b, 0x47, 0x72, 0x73, 0x73, 0x89, 0x46, 0xa3, + 0x21, 0xd3, 0xa7, 0x4f, 0x0f, 0xba, 0xa6, 0xb5, 0xb5, 0x95, 0x24, 0x27, + 0x27, 0x07, 0xb5, 0x15, 0x11, 0x11, 0x41, 0x2a, 0x2a, 0x2a, 0x7a, 0x7c, + 0x7e, 0x75, 0x75, 0x35, 0x09, 0x0b, 0x0b, 0x23, 0x53, 0xa7, 0x4e, 0xed, + 0x64, 0xba, 0xf6, 0x44, 0xc7, 0x8e, 0x1d, 0x23, 0x83, 0x07, 0x0f, 0x26, + 0x11, 0x11, 0x11, 0xa4, 0xba, 0xba, 0x9a, 0xf0, 0x3c, 0x2f, 0xfb, 0x19, + 0x3a, 0x9d, 0x6e, 0x8d, 0x14, 0x7b, 0xeb, 0xf3, 0x0a, 0x39, 0x74, 0xe8, + 0x10, 0x92, 0x93, 0x93, 0xe3, 0x3d, 0x1e, 0xcf, 0x96, 0xf0, 0xf0, 0x70, + 0x7c, 0xf1, 0xc5, 0x17, 0x72, 0x7a, 0x33, 0x10, 0x08, 0xc8, 0x60, 0x80, + 0xbe, 0x7a, 0xa7, 0x57, 0xa3, 0xff, 0xba, 0xa2, 0xbd, 0x7b, 0xf7, 0xe2, + 0xaf, 0x7f, 0xfd, 0x6b, 0xd0, 0x67, 0x3e, 0x9f, 0x0f, 0x0f, 0x3f, 0xfc, + 0x70, 0x27, 0xe4, 0xa0, 0xf4, 0x5b, 0x0a, 0xfe, 0x5d, 0x1d, 0xcf, 0x7a, + 0xfb, 0xed, 0xb7, 0x51, 0x5a, 0x5a, 0x1a, 0xf4, 0x99, 0xd5, 0x6a, 0x0d, + 0xda, 0x06, 0xd1, 0x1d, 0xe0, 0x41, 0xca, 0xa7, 0xf7, 0x27, 0x77, 0xe2, + 0xf1, 0x78, 0xe0, 0xf1, 0x78, 0xc0, 0x30, 0x0c, 0x9e, 0x7c, 0xf2, 0x49, + 0xe9, 0xb3, 0x57, 0x23, 0x23, 0x23, 0x53, 0x7b, 0xca, 0x18, 0xd2, 0x3d, + 0x24, 0x7d, 0xa8, 0x8a, 0x8a, 0x8a, 0xaf, 0x69, 0x9a, 0xa6, 0xde, 0x7f, + 0xff, 0x7d, 0x39, 0x5c, 0xe1, 0x74, 0x3a, 0xe1, 0xf7, 0xfb, 0x83, 0xf6, + 0x4b, 0x84, 0xda, 0xd1, 0xc4, 0xc4, 0x44, 0x38, 0x9d, 0xce, 0x5e, 0x03, + 0x86, 0x9f, 0x7d, 0xf6, 0x59, 0x97, 0x9f, 0x77, 0x04, 0x4f, 0x88, 0xa2, + 0x08, 0xab, 0xd5, 0x2a, 0x23, 0x4a, 0x0c, 0x06, 0x03, 0x58, 0x96, 0x95, + 0xf3, 0xfe, 0x12, 0x7d, 0xf1, 0x45, 0xd7, 0x08, 0xcf, 0xa2, 0xa2, 0x22, + 0xf8, 0x7c, 0xbe, 0x6e, 0xfb, 0xe0, 0x72, 0xb9, 0xe0, 0x74, 0x3a, 0x11, + 0x1e, 0x1e, 0x1e, 0xb2, 0x05, 0x24, 0x8a, 0x22, 0x04, 0x41, 0x80, 0x4a, + 0xa5, 0x42, 0x20, 0x10, 0x90, 0x73, 0xf0, 0xdb, 0xb7, 0x6f, 0xc7, 0x84, + 0x09, 0x13, 0xc0, 0x30, 0x8c, 0xb2, 0xad, 0xad, 0xed, 0xaf, 0x4f, 0x3d, + 0xf5, 0x14, 0x35, 0x76, 0xec, 0xd8, 0xd0, 0x18, 0x22, 0x05, 0xf0, 0xa2, + 0xa2, 0xa2, 0xe6, 0x08, 0x82, 0x30, 0x2e, 0x23, 0x23, 0x03, 0xb7, 0xde, + 0x7a, 0x6b, 0x50, 0x76, 0x8e, 0xe3, 0xb8, 0x3e, 0x33, 0x44, 0x6a, 0x9b, + 0x10, 0xd2, 0xeb, 0xae, 0xaa, 0xe1, 0xc3, 0x87, 0xf7, 0x08, 0xb6, 0x90, + 0x26, 0xc6, 0xa5, 0x4b, 0x97, 0x10, 0x19, 0x19, 0x09, 0x8b, 0xc5, 0x02, + 0x83, 0xc1, 0x80, 0xc8, 0xc8, 0xc8, 0x20, 0xa6, 0xf5, 0xd4, 0x96, 0x4e, + 0xa7, 0xeb, 0x11, 0x99, 0x58, 0x54, 0x54, 0x04, 0x51, 0x14, 0x31, 0x6c, + 0xd8, 0xb0, 0x90, 0xd3, 0xc2, 0x3c, 0xcf, 0x23, 0x10, 0x08, 0x40, 0xad, + 0x56, 0x83, 0x10, 0x02, 0x8e, 0xe3, 0x90, 0x97, 0x97, 0x87, 0xc6, 0xc6, + 0x46, 0xe8, 0xf5, 0x7a, 0xc4, 0xc7, 0xc7, 0x83, 0xe3, 0xb8, 0xf1, 0x5b, + 0xb6, 0x6c, 0xc9, 0xce, 0xcd, 0xcd, 0xed, 0x52, 0x52, 0x74, 0x62, 0xc8, + 0x89, 0x13, 0x27, 0x24, 0x11, 0xf1, 0x0e, 0x00, 0xea, 0x9d, 0x77, 0xde, + 0x81, 0x5a, 0xad, 0x0e, 0x4a, 0x06, 0xf1, 0x3c, 0x8f, 0xb0, 0xb0, 0xb0, + 0x7e, 0x31, 0x44, 0xa3, 0xd1, 0x60, 0xed, 0xda, 0xb5, 0x3d, 0x5e, 0xb7, + 0x76, 0xed, 0xda, 0x2e, 0x23, 0xab, 0x2b, 0x57, 0xae, 0x94, 0xfb, 0x72, + 0xf1, 0xe2, 0x45, 0x54, 0x56, 0x56, 0x22, 0x29, 0x29, 0x09, 0x51, 0x51, + 0x51, 0x30, 0x9b, 0xcd, 0x18, 0x39, 0x72, 0x24, 0x1a, 0x1b, 0x1b, 0x71, + 0xfe, 0xfc, 0x79, 0xf9, 0x9e, 0x17, 0x5f, 0x7c, 0xb1, 0x4b, 0xd1, 0xfa, + 0xf4, 0xd3, 0x4f, 0xf7, 0x38, 0xd0, 0x7f, 0xf8, 0xc3, 0x1f, 0x00, 0x00, + 0x4b, 0x97, 0x2e, 0x0d, 0xf9, 0xfd, 0x02, 0x81, 0x00, 0x9c, 0x4e, 0x27, + 0x74, 0x3a, 0x9d, 0x0c, 0xc4, 0xde, 0xb3, 0x67, 0x8f, 0x8c, 0x0d, 0x4e, + 0x4d, 0x4d, 0x85, 0x52, 0xa9, 0x64, 0xdc, 0x6e, 0xf7, 0x36, 0x49, 0x6a, + 0x84, 0x24, 0xb2, 0x0c, 0x06, 0xc3, 0x83, 0x82, 0x20, 0xa4, 0xde, 0x7d, + 0xf7, 0xdd, 0x98, 0x32, 0x65, 0x4a, 0xa7, 0x59, 0x20, 0x8a, 0x62, 0x10, + 0x93, 0x42, 0xa5, 0xa4, 0xa4, 0x24, 0xdc, 0x7c, 0xf3, 0xcd, 0x28, 0x2b, + 0x2b, 0xc3, 0xd6, 0xad, 0x5b, 0x7b, 0x14, 0x6f, 0xa7, 0x4f, 0x9f, 0xc6, + 0xfc, 0xf9, 0xf3, 0x11, 0x17, 0x17, 0x87, 0xe4, 0xe4, 0x64, 0x3c, 0xf8, + 0xe0, 0x83, 0x78, 0xed, 0xb5, 0xd7, 0xe4, 0x6b, 0x36, 0x6c, 0xd8, 0x00, + 0xaf, 0xd7, 0x1b, 0xf4, 0xd9, 0x33, 0xcf, 0x3c, 0x03, 0x00, 0x78, 0xea, + 0xa9, 0xa7, 0xe4, 0xd9, 0x37, 0x7e, 0xfc, 0x78, 0x6c, 0xdd, 0xba, 0x15, + 0x99, 0x99, 0x99, 0x88, 0x8e, 0x8e, 0xc6, 0x98, 0x31, 0x63, 0xb0, 0x69, + 0xd3, 0x26, 0xdc, 0x79, 0xe7, 0x9d, 0xdd, 0x3e, 0xff, 0x9b, 0x6f, 0xbe, + 0xc1, 0xd9, 0xb3, 0x67, 0x31, 0x61, 0xc2, 0x04, 0x8c, 0x1f, 0x3f, 0x3e, + 0xe4, 0xf7, 0xb3, 0xd9, 0x6c, 0x10, 0x45, 0x51, 0x16, 0x71, 0x65, 0x65, + 0x65, 0xa8, 0xa8, 0xa8, 0x90, 0x07, 0x5e, 0x8a, 0x36, 0x73, 0x1c, 0x17, + 0x63, 0x34, 0x1a, 0x9f, 0xe9, 0xb5, 0x41, 0xb3, 0xd9, 0x8c, 0xc8, 0xc8, + 0x48, 0x2d, 0xc3, 0x30, 0x17, 0x0d, 0x06, 0x03, 0x29, 0x2d, 0x2d, 0xed, + 0x64, 0x45, 0xec, 0xd9, 0xb3, 0x87, 0x00, 0x20, 0x2f, 0xbd, 0xf4, 0x52, + 0xbf, 0xec, 0xfb, 0xc2, 0xc2, 0x42, 0xa2, 0xd1, 0x68, 0x48, 0x64, 0x64, + 0x24, 0xa9, 0xaf, 0xaf, 0xef, 0x35, 0x22, 0xec, 0x76, 0xbb, 0x89, 0xc7, + 0xe3, 0x09, 0x0a, 0xb1, 0x7c, 0xf8, 0xe1, 0x87, 0x04, 0x00, 0xb9, 0xed, + 0xb6, 0xdb, 0x3a, 0xdd, 0xb3, 0x7c, 0xf9, 0xf2, 0x2e, 0xfb, 0xe7, 0xf7, + 0xfb, 0x89, 0xcb, 0xe5, 0xea, 0x35, 0x1a, 0xdb, 0xd6, 0xd6, 0x46, 0x86, + 0x0c, 0x19, 0x42, 0x18, 0x86, 0x21, 0xb9, 0xb9, 0xb9, 0x7d, 0x7a, 0xb7, + 0x93, 0x27, 0x4f, 0x92, 0x6f, 0xbf, 0xfd, 0x96, 0x2c, 0x58, 0xb0, 0x80, + 0x50, 0x14, 0x45, 0xd6, 0xaf, 0x5f, 0x4f, 0x66, 0xcf, 0x9e, 0x1d, 0x14, + 0x39, 0x9e, 0x37, 0x6f, 0x1e, 0x51, 0xa9, 0x54, 0x84, 0x61, 0x98, 0xe2, + 0xf0, 0xf0, 0xf0, 0x70, 0xc9, 0x9a, 0xed, 0x72, 0x85, 0xb4, 0xb6, 0xb6, + 0xc2, 0xe3, 0xf1, 0x64, 0x0a, 0x82, 0x90, 0x3c, 0x7d, 0xfa, 0x74, 0x0c, + 0x1d, 0x3a, 0xb4, 0xcb, 0xcc, 0x19, 0x4d, 0xd3, 0xf2, 0xbe, 0x88, 0xbe, + 0x52, 0x5a, 0x5a, 0x1a, 0x1e, 0x79, 0xe4, 0x11, 0x34, 0x37, 0x37, 0xe3, + 0xc6, 0x1b, 0x6f, 0xec, 0x16, 0x0e, 0x23, 0x25, 0x97, 0xb4, 0x5a, 0xad, + 0x0c, 0xb6, 0x03, 0x80, 0x5d, 0xbb, 0x76, 0xe1, 0xd1, 0x47, 0x1f, 0x85, + 0xc5, 0x62, 0x91, 0xc5, 0x4a, 0x47, 0xcb, 0xe8, 0xbd, 0xf7, 0xde, 0x43, + 0x5c, 0x5c, 0x1c, 0xd6, 0xad, 0x5b, 0x87, 0xcf, 0x3f, 0xff, 0x3c, 0x28, + 0x34, 0xa1, 0xd3, 0xe9, 0x7a, 0x44, 0x4b, 0xba, 0x5c, 0x2e, 0x2c, 0x5f, + 0xbe, 0x1c, 0xe5, 0xe5, 0xe5, 0x78, 0xe0, 0x81, 0x07, 0x90, 0x91, 0x91, + 0xd1, 0xa7, 0x9c, 0x7b, 0x6b, 0x6b, 0x2b, 0x68, 0x9a, 0x96, 0x8d, 0x85, + 0xa6, 0xa6, 0xa6, 0x4e, 0x7a, 0x42, 0xa1, 0x50, 0x20, 0x21, 0x21, 0x01, + 0x82, 0x20, 0x0c, 0xe1, 0x79, 0x7e, 0xea, 0xa1, 0x43, 0x87, 0x82, 0xf4, + 0x9c, 0xcc, 0x90, 0xac, 0xac, 0x2c, 0xc9, 0x52, 0x78, 0x0e, 0x00, 0xbb, + 0x6e, 0xdd, 0x3a, 0x74, 0x23, 0xce, 0xa0, 0x52, 0xa9, 0xfa, 0x0c, 0x91, + 0xec, 0x48, 0xaf, 0xbd, 0xf6, 0x1a, 0x56, 0xad, 0x5a, 0x85, 0x33, 0x67, + 0xce, 0x60, 0xcc, 0x98, 0x31, 0xdd, 0x6e, 0xab, 0xbe, 0xfa, 0x85, 0x9f, + 0x7d, 0xf6, 0x59, 0x2c, 0x5c, 0xb8, 0x10, 0x1c, 0xc7, 0xe1, 0xb3, 0xcf, + 0x3e, 0xc3, 0xb0, 0x61, 0xc3, 0x3a, 0x89, 0xba, 0xf0, 0xf0, 0x70, 0xec, + 0xda, 0xb5, 0x0b, 0x0a, 0x85, 0x02, 0xcb, 0x96, 0x2d, 0xc3, 0xca, 0x95, + 0x2b, 0x11, 0x08, 0x04, 0x7a, 0x6d, 0xff, 0xcc, 0x99, 0x33, 0x48, 0x4b, + 0x4b, 0xc3, 0xce, 0x9d, 0x3b, 0x71, 0xe7, 0x9d, 0x77, 0xe2, 0xc3, 0x0f, + 0x3f, 0xec, 0xd3, 0x3b, 0x79, 0x3c, 0x1e, 0x19, 0xcd, 0x6f, 0xb7, 0xdb, + 0xbb, 0x85, 0xb1, 0x8a, 0xa2, 0x28, 0x61, 0x7f, 0x19, 0x9f, 0xcf, 0xf7, + 0x10, 0x00, 0x5c, 0xbe, 0x7c, 0xb9, 0xdb, 0xd9, 0x3b, 0x08, 0x00, 0x99, + 0x33, 0x67, 0x4e, 0xb7, 0xcb, 0xb2, 0xb4, 0xb4, 0x94, 0x44, 0x44, 0x44, + 0x90, 0xac, 0xac, 0xac, 0x6b, 0x0e, 0x4f, 0x48, 0x81, 0x38, 0xe9, 0x99, + 0x9f, 0x7e, 0xfa, 0x29, 0x29, 0x28, 0x28, 0x20, 0x6d, 0x6d, 0x6d, 0xc4, + 0xeb, 0xf5, 0x92, 0x86, 0x86, 0x06, 0x72, 0xf4, 0xe8, 0x51, 0xb2, 0x7e, + 0xfd, 0x7a, 0xd9, 0xb9, 0x4b, 0x4a, 0x4a, 0x22, 0xc7, 0x8f, 0x1f, 0xef, + 0xb5, 0xed, 0xbc, 0xbc, 0x3c, 0x92, 0x96, 0x96, 0x26, 0x07, 0x09, 0x7f, + 0xf7, 0xbb, 0xdf, 0x91, 0x43, 0x87, 0x0e, 0x91, 0xba, 0xba, 0x3a, 0xe2, + 0xf1, 0x78, 0x88, 0xc3, 0xe1, 0x20, 0x45, 0x45, 0x45, 0xe4, 0x1f, 0xff, + 0xf8, 0x07, 0xb9, 0xf9, 0xe6, 0x9b, 0xe5, 0x10, 0xc7, 0xaa, 0x55, 0xab, + 0x08, 0xc7, 0x71, 0x7d, 0x7e, 0x97, 0x9c, 0x9c, 0x1c, 0xf2, 0xd5, 0x57, + 0x5f, 0x91, 0xaf, 0xbf, 0xfe, 0x9a, 0xa4, 0xa5, 0xa5, 0x11, 0xa5, 0x52, + 0x49, 0x5e, 0x7f, 0xfd, 0x75, 0x32, 0x63, 0xc6, 0x8c, 0x20, 0x91, 0xb5, + 0x70, 0xe1, 0x42, 0x72, 0xe3, 0x8d, 0x37, 0x92, 0xf4, 0xf4, 0x74, 0x42, + 0x51, 0x14, 0xb1, 0x58, 0x2c, 0x69, 0xdd, 0x72, 0x59, 0xa5, 0x52, 0x7d, + 0xcd, 0x30, 0x4c, 0x50, 0x04, 0xb5, 0xab, 0x8c, 0x5c, 0x5c, 0x5c, 0x1c, + 0x19, 0x3e, 0x7c, 0x78, 0xa7, 0x04, 0x56, 0x5f, 0x49, 0x14, 0x45, 0x52, + 0x56, 0x56, 0x46, 0x62, 0x62, 0x62, 0x3a, 0x6e, 0x31, 0x26, 0x2a, 0x95, + 0x8a, 0xa8, 0xd5, 0x6a, 0x49, 0xd6, 0xca, 0xdf, 0x3d, 0xfa, 0xe8, 0xa3, + 0x7d, 0x0e, 0xd7, 0xbf, 0xf4, 0xd2, 0x4b, 0xf2, 0xfd, 0x0c, 0xc3, 0x10, + 0xa5, 0x52, 0x49, 0xd4, 0x6a, 0x35, 0x51, 0xab, 0xd5, 0x44, 0xa1, 0x50, + 0x10, 0x69, 0x7b, 0x73, 0x78, 0x78, 0x38, 0xb9, 0x78, 0xf1, 0x62, 0xbf, + 0xd2, 0x01, 0x1c, 0xc7, 0x91, 0x2f, 0xbf, 0xfc, 0x92, 0xec, 0xd8, 0xb1, + 0x83, 0x6c, 0xdb, 0xb6, 0x8d, 0x24, 0x24, 0x24, 0x10, 0x93, 0xc9, 0x44, + 0xbe, 0xfc, 0xf2, 0x4b, 0xb2, 0x7c, 0xf9, 0x72, 0x32, 0x7f, 0xfe, 0xfc, + 0x4e, 0x4c, 0x99, 0x36, 0x6d, 0x1a, 0x61, 0x59, 0x96, 0xa8, 0xd5, 0xea, + 0x3f, 0x77, 0x02, 0xca, 0x2d, 0x59, 0xb2, 0x04, 0x07, 0x0e, 0x1c, 0x88, + 0x68, 0x6d, 0x6d, 0x3d, 0x1f, 0x19, 0x19, 0x19, 0x97, 0x97, 0x97, 0xd7, + 0xad, 0x9f, 0xe1, 0xf1, 0x78, 0x30, 0x7b, 0xf6, 0x6c, 0x5c, 0xb8, 0x70, + 0x01, 0xe7, 0xcf, 0x9f, 0x47, 0x62, 0x62, 0xe2, 0x80, 0x04, 0x30, 0x77, + 0xee, 0xdc, 0x89, 0xfd, 0xfb, 0xf7, 0xa3, 0xa0, 0xa0, 0x00, 0x0d, 0x0d, + 0x0d, 0xe0, 0x38, 0x0e, 0x06, 0x83, 0x01, 0x83, 0x07, 0x0f, 0xc6, 0xd8, + 0xb1, 0x63, 0xb1, 0x6c, 0xd9, 0x32, 0xa4, 0xa4, 0xa4, 0xf4, 0xab, 0xed, + 0x9a, 0x9a, 0x1a, 0x7c, 0xf6, 0xd9, 0x67, 0xc8, 0xc9, 0xc9, 0x41, 0x59, + 0x59, 0x19, 0x1c, 0x0e, 0x07, 0x58, 0x96, 0x45, 0x74, 0x74, 0x34, 0xd2, + 0xd2, 0xd2, 0x30, 0x63, 0xc6, 0x0c, 0x2c, 0x5e, 0xbc, 0xb8, 0xdf, 0x7d, + 0x3f, 0x77, 0xee, 0x1c, 0x2a, 0x2a, 0x2a, 0x64, 0x3f, 0xed, 0xe1, 0x87, + 0x1f, 0x86, 0xd1, 0x68, 0xc4, 0x37, 0xdf, 0x7c, 0x83, 0xb0, 0xb0, 0x30, + 0x7c, 0xfe, 0xf9, 0xe7, 0x28, 0x2c, 0x2c, 0x84, 0xcb, 0xe5, 0x82, 0xc7, + 0xe3, 0x91, 0xf7, 0x33, 0x9e, 0x3e, 0x7d, 0x1a, 0x2e, 0x97, 0xab, 0x2a, + 0x36, 0x36, 0x76, 0x64, 0x6d, 0x6d, 0xad, 0x0b, 0x68, 0xdf, 0x1f, 0xf2, + 0xc5, 0x17, 0x5f, 0xc0, 0x6c, 0x36, 0x0f, 0x25, 0x84, 0xc4, 0x8c, 0x1c, + 0x39, 0xb2, 0x47, 0xa7, 0x4f, 0xab, 0xd5, 0x62, 0xe4, 0xc8, 0x91, 0x38, + 0x7e, 0xfc, 0x38, 0x9a, 0x9a, 0x9a, 0x06, 0x8c, 0x21, 0x0b, 0x17, 0x2e, + 0xc4, 0x82, 0x05, 0x0b, 0x64, 0xe4, 0x47, 0xc7, 0x6d, 0x00, 0xd7, 0x0a, + 0xba, 0x48, 0x48, 0x48, 0xc0, 0x9a, 0x35, 0x6b, 0xe4, 0xcd, 0x42, 0x52, + 0xdb, 0x1d, 0xb7, 0x19, 0xf4, 0x97, 0x7c, 0x3e, 0x1f, 0x1a, 0x1a, 0x1a, + 0x64, 0xa8, 0x51, 0x65, 0x65, 0x25, 0x3c, 0x1e, 0x0f, 0x86, 0x0f, 0x1f, + 0x0e, 0x8a, 0xa2, 0x90, 0x9c, 0x9c, 0x8c, 0x67, 0x9f, 0x7d, 0x16, 0x1c, + 0xc7, 0xa1, 0xbc, 0xbc, 0x1c, 0x55, 0x55, 0x55, 0xa8, 0xa9, 0xa9, 0x41, + 0x7d, 0x7d, 0x3d, 0x9c, 0x4e, 0x27, 0x4e, 0x9d, 0x3a, 0x35, 0xa8, 0xa5, + 0xa5, 0x65, 0x48, 0x42, 0x42, 0xc2, 0xf9, 0x9a, 0x9a, 0x1a, 0xb0, 0x8b, + 0x16, 0x2d, 0xc2, 0x77, 0xdf, 0x7d, 0x07, 0x8f, 0xc7, 0x73, 0x37, 0x00, + 0xba, 0xa7, 0x32, 0x18, 0x12, 0x4d, 0x9b, 0x36, 0x0d, 0x9b, 0x37, 0x6f, + 0x96, 0xed, 0xfb, 0x81, 0x22, 0xe9, 0xa5, 0x7e, 0x4a, 0xb0, 0xdb, 0x40, + 0x23, 0x6a, 0x2a, 0x2b, 0x2b, 0xe1, 0xf3, 0xf9, 0x40, 0x51, 0x14, 0x94, + 0x4a, 0x25, 0x72, 0x72, 0x72, 0x20, 0x8a, 0x22, 0x66, 0xce, 0x9c, 0x29, + 0x33, 0x9a, 0xa6, 0x69, 0xa8, 0x54, 0x2a, 0x8c, 0x18, 0x31, 0x02, 0x23, + 0x46, 0x8c, 0xe8, 0x18, 0x49, 0xc7, 0x9d, 0x77, 0xde, 0x09, 0x96, 0x65, + 0x97, 0xd5, 0xd4, 0xd4, 0x9c, 0x07, 0x00, 0xfa, 0xbb, 0xef, 0xbe, 0x93, + 0x3c, 0xf0, 0x99, 0x0c, 0xc3, 0x84, 0x04, 0x26, 0xbe, 0xe3, 0x8e, 0x3b, + 0xa0, 0x50, 0x28, 0xf0, 0xf1, 0xc7, 0x1f, 0xe3, 0xbf, 0x99, 0x7c, 0x3e, + 0x1f, 0x0a, 0x0b, 0x0b, 0xe5, 0xd5, 0xe6, 0x72, 0xb9, 0x90, 0x9b, 0x9b, + 0x0b, 0x00, 0x98, 0x3d, 0x7b, 0x76, 0xb7, 0x7b, 0x19, 0x25, 0x9a, 0x3c, + 0x79, 0x32, 0x0c, 0x06, 0x03, 0x02, 0x81, 0xc0, 0x6a, 0xe0, 0x4a, 0x01, + 0x1b, 0x1a, 0x00, 0x4c, 0x26, 0xd3, 0x48, 0x42, 0xc8, 0xf0, 0xd4, 0xd4, + 0x54, 0xbc, 0xfb, 0xee, 0xbb, 0x78, 0xf4, 0xd1, 0x47, 0x91, 0x97, 0x97, + 0xd7, 0xe3, 0x4c, 0x5b, 0xb2, 0x64, 0x09, 0x7c, 0x3e, 0x1f, 0xde, 0x7d, + 0xf7, 0xdd, 0xff, 0x4a, 0x66, 0x10, 0x42, 0x70, 0xe6, 0xcc, 0x99, 0x20, + 0x3f, 0xa3, 0xac, 0xac, 0x0c, 0x65, 0x65, 0x65, 0x98, 0x3f, 0x7f, 0x3e, + 0x38, 0x8e, 0xeb, 0x15, 0xde, 0x9a, 0x90, 0x90, 0x20, 0xc5, 0xb7, 0x34, + 0x29, 0x29, 0x29, 0xa9, 0x05, 0x05, 0x05, 0x57, 0x18, 0xc2, 0xf3, 0xfc, + 0x38, 0x42, 0x88, 0xc2, 0x6c, 0x36, 0x43, 0xa5, 0x52, 0xa1, 0xac, 0xac, + 0x0c, 0x6b, 0xd7, 0xae, 0x0d, 0x72, 0xac, 0xae, 0xa6, 0x35, 0x6b, 0xd6, + 0x00, 0x00, 0x3e, 0xf9, 0xe4, 0x13, 0xd8, 0x6c, 0xb6, 0xff, 0x3a, 0x86, + 0xd4, 0xd5, 0xd5, 0x49, 0xbb, 0x70, 0xe5, 0xcf, 0xbe, 0xfa, 0xea, 0x2b, + 0x50, 0x14, 0x85, 0x19, 0x33, 0x66, 0x80, 0xe3, 0xb8, 0x5e, 0x13, 0x78, + 0x2e, 0x97, 0x0b, 0x13, 0x27, 0x4e, 0x94, 0x22, 0xd9, 0x77, 0x00, 0x00, + 0x3d, 0x67, 0xce, 0x1c, 0x8a, 0xe7, 0xf9, 0x6c, 0xa5, 0x52, 0x19, 0xe4, + 0xc5, 0xd2, 0x34, 0x8d, 0x8f, 0x3f, 0xfe, 0x18, 0x7f, 0xfe, 0xf3, 0x9f, + 0xbb, 0x8c, 0x4a, 0x8e, 0x18, 0x31, 0x02, 0xa9, 0xa9, 0xa9, 0xb8, 0x70, + 0xe1, 0x02, 0x76, 0xec, 0xd8, 0xf1, 0x5f, 0xc5, 0x0c, 0xa7, 0xd3, 0x89, + 0x7f, 0xfe, 0xf3, 0x9f, 0x32, 0x33, 0x08, 0x21, 0xb0, 0xdb, 0xed, 0xb2, + 0xd5, 0x99, 0x98, 0x98, 0x08, 0x9a, 0xa6, 0xa1, 0xd1, 0x68, 0x7a, 0x6d, + 0x47, 0x0a, 0xc3, 0x7b, 0xbd, 0xde, 0x0c, 0x00, 0xa0, 0x4f, 0x9f, 0x3e, + 0xcd, 0x12, 0x42, 0x7e, 0xa1, 0x50, 0x28, 0x3a, 0x85, 0xa3, 0x95, 0x4a, + 0x25, 0xbe, 0xfd, 0xf6, 0x5b, 0x39, 0x02, 0x7c, 0xf5, 0x77, 0x2f, 0xbf, + 0xfc, 0x32, 0x7c, 0x3e, 0x1f, 0x76, 0xee, 0xdc, 0x89, 0x63, 0xc7, 0x8e, + 0xfd, 0x57, 0x30, 0x83, 0xe3, 0x38, 0x9c, 0x3a, 0x75, 0x2a, 0xe8, 0x33, + 0x8d, 0x46, 0x83, 0xdd, 0xbb, 0x77, 0xc3, 0xe3, 0xf1, 0x60, 0xd6, 0xac, + 0x59, 0xd0, 0x6a, 0xb5, 0x50, 0xab, 0xd5, 0xbd, 0xe6, 0x51, 0xfc, 0x7e, + 0x3f, 0x4c, 0x26, 0x13, 0x74, 0x3a, 0x1d, 0x00, 0x0c, 0xb2, 0x58, 0x2c, + 0x7a, 0x96, 0x65, 0x59, 0x2d, 0xc7, 0x71, 0x61, 0x61, 0x61, 0x61, 0x5d, + 0x5a, 0x20, 0x82, 0x20, 0x60, 0xe3, 0xc6, 0x8d, 0xc8, 0xcc, 0xcc, 0xec, + 0x14, 0x07, 0x5a, 0xba, 0x74, 0x29, 0x9e, 0x79, 0xe6, 0x19, 0x6c, 0xdf, + 0xbe, 0x1d, 0xd3, 0xa7, 0x4f, 0x47, 0x64, 0x64, 0x64, 0x8f, 0xb9, 0x8c, + 0x81, 0xa0, 0x96, 0x96, 0x16, 0x54, 0x54, 0x54, 0xa0, 0xa8, 0xa8, 0x08, + 0xe5, 0xe5, 0xe5, 0x68, 0x6e, 0x6e, 0x96, 0x77, 0x22, 0x69, 0xb5, 0x5a, + 0x44, 0x46, 0x46, 0x62, 0xc8, 0x90, 0x21, 0x18, 0x31, 0x62, 0x04, 0x92, + 0x92, 0x92, 0x06, 0x7c, 0xeb, 0xf5, 0xf9, 0xf3, 0xe7, 0xe1, 0x74, 0x3a, + 0x83, 0x2c, 0xa8, 0xea, 0xea, 0x6a, 0xfc, 0xfd, 0xef, 0x7f, 0x87, 0xd9, + 0x6c, 0xc6, 0xbc, 0x79, 0xf3, 0x20, 0x8a, 0x62, 0xaf, 0xf9, 0x16, 0xc9, + 0x28, 0xd0, 0x6a, 0xb5, 0x30, 0x18, 0x0c, 0xf0, 0xf9, 0x7c, 0x71, 0x1e, + 0x8f, 0x47, 0xcf, 0xfa, 0xfd, 0xfe, 0x08, 0x42, 0x88, 0xb1, 0xbb, 0xfc, + 0x06, 0x4d, 0xd3, 0xa8, 0xa9, 0xa9, 0xc1, 0xb7, 0xdf, 0x7e, 0x8b, 0xdb, + 0x6e, 0xbb, 0xad, 0xd3, 0xf7, 0xcf, 0x3f, 0xff, 0x3c, 0x1e, 0x7a, 0xe8, + 0x21, 0xfc, 0xe9, 0x4f, 0x7f, 0x42, 0x7c, 0x7c, 0x3c, 0x58, 0x96, 0xed, + 0x32, 0x28, 0x79, 0xad, 0x74, 0xe9, 0xd2, 0x25, 0xbc, 0xf0, 0xc2, 0x0b, + 0x38, 0x75, 0xea, 0x14, 0x6a, 0x6b, 0x6b, 0x7b, 0x4c, 0x05, 0x4b, 0x56, + 0x4f, 0x5c, 0x5c, 0x1c, 0xb2, 0xb2, 0xb2, 0xf0, 0xf2, 0xcb, 0x2f, 0x63, + 0xf4, 0xe8, 0xd1, 0x03, 0xc2, 0x8c, 0xf2, 0xf2, 0xf2, 0x20, 0xd3, 0x9c, + 0x10, 0x22, 0x03, 0x19, 0xee, 0xbb, 0xef, 0x3e, 0xe8, 0x74, 0x3a, 0xb8, + 0x5c, 0xae, 0x5e, 0x9d, 0x58, 0x42, 0x08, 0x3c, 0x1e, 0x0f, 0x34, 0x1a, + 0x0d, 0x74, 0x3a, 0x1d, 0x1a, 0x1b, 0x1b, 0x75, 0x6a, 0xb5, 0xda, 0xc0, + 0x72, 0x1c, 0x67, 0x02, 0xa0, 0x93, 0x2a, 0xe4, 0x74, 0xf5, 0x92, 0x06, + 0x83, 0x01, 0xdf, 0x7f, 0xff, 0x3d, 0x6e, 0xbd, 0xf5, 0xd6, 0x4e, 0xab, + 0x68, 0xc1, 0x82, 0x05, 0x18, 0x31, 0x62, 0x04, 0x0a, 0x0b, 0x0b, 0x71, + 0xec, 0xd8, 0x31, 0x68, 0xb5, 0x5a, 0xe8, 0xf5, 0x7a, 0x44, 0x45, 0x45, + 0x0d, 0x08, 0x23, 0xf6, 0xed, 0xdb, 0x87, 0x75, 0xeb, 0xd6, 0xe1, 0xc8, + 0x91, 0x23, 0x57, 0x32, 0x99, 0x11, 0x66, 0xdc, 0xb5, 0x68, 0x31, 0x46, + 0x0d, 0x1f, 0x81, 0xf4, 0xe4, 0x61, 0x88, 0x8f, 0x8a, 0x85, 0x51, 0x77, + 0x65, 0x23, 0xa9, 0xd3, 0xed, 0x42, 0x4d, 0x53, 0x03, 0x8a, 0xca, 0x8a, + 0x51, 0x50, 0x7c, 0x11, 0xbb, 0x0e, 0xef, 0xc7, 0x8e, 0x1d, 0x3b, 0xb0, + 0x63, 0xc7, 0x0e, 0x4c, 0x99, 0x32, 0x05, 0x2f, 0xbe, 0xf8, 0x22, 0x66, + 0xcf, 0x9e, 0xdd, 0xaf, 0x7e, 0x94, 0x96, 0x96, 0xa2, 0xa4, 0xa4, 0x24, + 0x88, 0x19, 0x2c, 0xcb, 0xe2, 0xcc, 0x99, 0x33, 0x28, 0x28, 0x28, 0x40, + 0x7c, 0x7c, 0x3c, 0xb2, 0xb3, 0xb3, 0xe1, 0xf7, 0xfb, 0xa1, 0xd5, 0x6a, + 0x7b, 0x7d, 0x7f, 0x51, 0x14, 0xe1, 0x74, 0x3a, 0x41, 0xd3, 0x34, 0x12, + 0x12, 0x12, 0x50, 0x5a, 0x5a, 0xaa, 0x0c, 0x04, 0x02, 0x09, 0x2c, 0x21, + 0x44, 0x0f, 0x40, 0xd9, 0x93, 0x89, 0x26, 0xd5, 0xbc, 0xb2, 0xdb, 0xed, + 0x9d, 0x20, 0x36, 0x51, 0x51, 0x51, 0x78, 0xea, 0xa9, 0xa7, 0x70, 0xff, + 0xfd, 0xf7, 0xe3, 0xbd, 0xf7, 0xde, 0xc3, 0xa8, 0x51, 0xa3, 0x70, 0xe4, + 0xc8, 0x11, 0xcc, 0x9c, 0x39, 0xb3, 0xcb, 0x92, 0x7e, 0x7d, 0xb1, 0xf1, + 0xef, 0xb9, 0xe7, 0x1e, 0x6c, 0xdb, 0xb6, 0x0d, 0x00, 0x30, 0x66, 0x78, + 0x1a, 0x3e, 0x78, 0xe1, 0xf7, 0x98, 0x32, 0xe5, 0x06, 0xc0, 0xef, 0x03, + 0xba, 0xd9, 0x9c, 0x93, 0x91, 0x9a, 0x8e, 0x85, 0x53, 0x6f, 0x00, 0x18, + 0x06, 0xd0, 0xe9, 0x71, 0xfc, 0xf0, 0x3e, 0x3c, 0xf4, 0xca, 0x5a, 0x1c, + 0x3b, 0x76, 0x0c, 0x73, 0xe6, 0xcc, 0xc1, 0xa2, 0x45, 0x8b, 0xb0, 0x6d, + 0xdb, 0xb6, 0x3e, 0x25, 0xd8, 0xca, 0xca, 0xca, 0x90, 0x97, 0x97, 0xd7, + 0x69, 0x32, 0xba, 0xdd, 0x6e, 0x6c, 0xda, 0xb4, 0x09, 0x82, 0x20, 0x60, + 0xed, 0xda, 0xb5, 0xa0, 0x69, 0x1a, 0x3c, 0xcf, 0x63, 0xd4, 0xa8, 0x51, + 0xbd, 0xb6, 0x29, 0x8a, 0x22, 0xbc, 0x5e, 0xaf, 0x9c, 0xb8, 0x3b, 0x7c, + 0xf8, 0xb0, 0x42, 0x14, 0xc5, 0x68, 0x5a, 0xa9, 0x54, 0x1a, 0x81, 0xde, + 0x77, 0x11, 0x49, 0x3b, 0x8f, 0xba, 0xca, 0x8f, 0x64, 0x67, 0x67, 0xe3, + 0xa1, 0x87, 0x1e, 0x02, 0xc7, 0x71, 0x78, 0xe3, 0x8d, 0x37, 0x00, 0x00, + 0x87, 0x0f, 0x1f, 0x46, 0x7d, 0x7d, 0x7d, 0xbf, 0x45, 0xc3, 0xc4, 0x89, + 0x13, 0xb1, 0x6d, 0xdb, 0x36, 0x64, 0x5f, 0x97, 0x85, 0xaf, 0x3f, 0xfa, + 0x1b, 0xf2, 0x76, 0x1e, 0xc5, 0x94, 0x49, 0xd7, 0x03, 0x6e, 0x57, 0xb7, + 0xcc, 0xb8, 0x4a, 0xf9, 0x01, 0xf6, 0x36, 0x4c, 0x9e, 0x38, 0x15, 0xf9, + 0xbb, 0x8f, 0xe3, 0x9b, 0x0f, 0xff, 0x86, 0xeb, 0x33, 0x27, 0xe2, 0xbb, + 0xef, 0xbe, 0x43, 0x66, 0x66, 0x26, 0xce, 0x9d, 0x3b, 0x17, 0xb2, 0x27, + 0x7e, 0xfe, 0xfc, 0xf9, 0x20, 0x66, 0x48, 0x28, 0x97, 0xf7, 0xdf, 0x7f, + 0x1f, 0x0d, 0x0d, 0x0d, 0xb8, 0xe7, 0x9e, 0x7b, 0x90, 0x9c, 0x9c, 0x0c, + 0x51, 0x14, 0xa1, 0x50, 0x28, 0x42, 0xc2, 0x1b, 0x78, 0xbd, 0x5e, 0x08, + 0x82, 0x00, 0x42, 0x08, 0xe2, 0xe3, 0xe3, 0x01, 0x80, 0x16, 0x04, 0xc1, + 0x4c, 0x03, 0x88, 0x63, 0x59, 0xb6, 0x57, 0xaf, 0x52, 0x10, 0x84, 0x6e, + 0x01, 0x63, 0x43, 0x87, 0x0e, 0xc5, 0xac, 0x59, 0xb3, 0x30, 0x6a, 0xd4, + 0x28, 0x14, 0x16, 0x16, 0x62, 0xd7, 0xae, 0x5d, 0x60, 0x59, 0x16, 0x27, + 0x4f, 0x9e, 0x44, 0x65, 0x65, 0x65, 0x9f, 0x98, 0x51, 0x5e, 0x5e, 0x8e, + 0xec, 0xec, 0x6c, 0xe4, 0xe7, 0xe7, 0xe3, 0xf9, 0x87, 0x1e, 0xc5, 0x8f, + 0x7f, 0xfb, 0x3f, 0xdc, 0x34, 0xf5, 0x06, 0xc0, 0xef, 0xbf, 0xf2, 0xd3, + 0x97, 0xb8, 0x13, 0x45, 0x01, 0x01, 0x3f, 0xe0, 0xf5, 0x62, 0xd1, 0xd4, + 0x19, 0x38, 0xf8, 0x97, 0xaf, 0xb0, 0x7e, 0xf5, 0x73, 0x28, 0x2c, 0x2c, + 0xc4, 0xb4, 0x69, 0xd3, 0x50, 0x5e, 0x5e, 0xde, 0xe3, 0xed, 0x45, 0x45, + 0x45, 0x38, 0x7b, 0xf6, 0x6c, 0x27, 0x31, 0xae, 0x56, 0xab, 0x71, 0xe8, + 0xd0, 0x21, 0xfc, 0xf8, 0xe3, 0x8f, 0x48, 0x4e, 0x4e, 0xc6, 0x82, 0x05, + 0x0b, 0xe0, 0xf3, 0xf9, 0x20, 0x08, 0x02, 0xe2, 0xe3, 0xe3, 0x43, 0x2a, + 0x19, 0xe2, 0xf5, 0x7a, 0xc1, 0xf3, 0x3c, 0x08, 0x21, 0x32, 0x4e, 0x8b, + 0x10, 0x62, 0xa4, 0x05, 0x41, 0x30, 0x33, 0x0c, 0xd3, 0x6b, 0x8c, 0x87, + 0xe7, 0x79, 0x79, 0x4f, 0x5e, 0x57, 0x99, 0xbd, 0x31, 0x63, 0xc6, 0xe0, + 0xb9, 0xe7, 0x9e, 0x43, 0x54, 0x54, 0x14, 0xb6, 0x6e, 0xdd, 0x8a, 0x03, + 0x07, 0x0e, 0x40, 0xa1, 0x50, 0x20, 0x27, 0x27, 0xa7, 0xfb, 0x04, 0x4c, + 0x17, 0xce, 0xd6, 0xc4, 0x89, 0x13, 0xaf, 0xec, 0xef, 0x7e, 0xfa, 0xb7, + 0x58, 0xb7, 0xfa, 0xb7, 0xed, 0x81, 0x73, 0x22, 0x59, 0x18, 0x00, 0xcb, + 0x5e, 0xf9, 0x1d, 0x0a, 0x33, 0x18, 0xf6, 0x8a, 0xe8, 0xba, 0xf2, 0xb6, + 0xa0, 0x29, 0x0a, 0xcf, 0x3e, 0xf8, 0x18, 0xde, 0x7e, 0xf6, 0x15, 0xd9, + 0x07, 0xa8, 0xae, 0xae, 0xee, 0x76, 0x95, 0x5e, 0xbc, 0x78, 0xb1, 0xd3, + 0xb8, 0x30, 0x0c, 0x83, 0x33, 0x67, 0xce, 0xe0, 0xad, 0xb7, 0xde, 0x82, + 0x52, 0xa9, 0xc4, 0xd3, 0x4f, 0x3f, 0x2d, 0xfb, 0x1b, 0x0a, 0x85, 0x02, + 0xa9, 0xa9, 0xa9, 0x21, 0x05, 0x2b, 0x25, 0xf4, 0x24, 0x21, 0x44, 0x06, + 0x8c, 0x50, 0x14, 0xa5, 0xa1, 0x29, 0x8a, 0x32, 0x48, 0x41, 0xb7, 0xde, + 0xea, 0x43, 0x5d, 0x8d, 0x79, 0xea, 0x48, 0x49, 0x49, 0x49, 0x88, 0x88, + 0x88, 0xc0, 0x73, 0xcf, 0x3d, 0x07, 0x8d, 0x46, 0x83, 0xf7, 0xdf, 0x7f, + 0x1f, 0xc5, 0xc5, 0xc5, 0x60, 0x59, 0x16, 0xf9, 0xf9, 0xf9, 0x38, 0x79, + 0xf2, 0x64, 0xb7, 0x95, 0xd9, 0x24, 0x9b, 0xfc, 0xae, 0xbb, 0xee, 0x42, + 0x73, 0x73, 0x33, 0xde, 0x7c, 0xea, 0x45, 0x3c, 0xbd, 0xea, 0x69, 0x80, + 0xfb, 0x57, 0xa6, 0x8f, 0x00, 0x28, 0xa9, 0x28, 0xc3, 0x8f, 0xff, 0x3c, + 0x81, 0xda, 0xfa, 0x5a, 0x80, 0x55, 0xf4, 0x14, 0x45, 0x44, 0x9b, 0xc3, + 0x8e, 0x13, 0xe7, 0x4e, 0x21, 0xbf, 0xb0, 0x00, 0x7c, 0xc7, 0xf7, 0xe2, + 0x79, 0x3c, 0xf6, 0x9b, 0x27, 0xf0, 0xda, 0xea, 0xe7, 0xe0, 0x70, 0x38, + 0x70, 0xe3, 0x8d, 0x37, 0x06, 0x89, 0x62, 0x41, 0x10, 0xf0, 0xe3, 0x8f, + 0x3f, 0xa2, 0xb8, 0xb8, 0xb8, 0xd3, 0xc0, 0x52, 0x14, 0x85, 0x86, 0x86, + 0x06, 0xbc, 0xfe, 0xfa, 0xeb, 0xa0, 0x69, 0x1a, 0x2f, 0xbe, 0xf8, 0x22, + 0xe2, 0xe3, 0xe3, 0xe5, 0x08, 0x72, 0x72, 0x72, 0xb2, 0xe4, 0x53, 0xf4, + 0x4a, 0xed, 0xd5, 0x84, 0x82, 0x6a, 0x74, 0x09, 0x82, 0xa0, 0xa2, 0x05, + 0x41, 0x60, 0x43, 0xe1, 0x28, 0x45, 0x51, 0xb8, 0x78, 0xf1, 0x62, 0xb7, + 0xdf, 0x2b, 0x14, 0x0a, 0x8c, 0x1c, 0x39, 0x12, 0x83, 0x07, 0x0f, 0xc6, + 0xca, 0x95, 0x2b, 0xc1, 0x71, 0x1c, 0x7e, 0xfb, 0xdb, 0xdf, 0xe2, 0xf2, + 0xe5, 0xcb, 0x50, 0xa9, 0x54, 0xa8, 0xab, 0xab, 0xc3, 0xd1, 0xa3, 0x47, + 0x61, 0xb7, 0xdb, 0xbb, 0xbc, 0xff, 0xc8, 0x91, 0x23, 0x38, 0x78, 0xf0, + 0x20, 0xe6, 0x66, 0x4f, 0xc3, 0xe3, 0xf7, 0x3f, 0x0c, 0xd2, 0x91, 0xf9, + 0x34, 0x83, 0xbd, 0xc7, 0x0e, 0x63, 0xc4, 0x8d, 0xd7, 0x63, 0xea, 0xdd, + 0x37, 0x23, 0xfd, 0x97, 0x33, 0xf0, 0xfb, 0x8d, 0x6f, 0x82, 0x74, 0xd5, + 0x6f, 0x9a, 0xc6, 0x8e, 0x7d, 0x3b, 0x91, 0x71, 0xeb, 0x2c, 0x4c, 0xbe, + 0xf3, 0x26, 0x64, 0x2c, 0x9e, 0x85, 0x57, 0x3e, 0x78, 0x03, 0xd0, 0x74, + 0x30, 0x5a, 0xec, 0x6d, 0x78, 0xea, 0xc1, 0xc7, 0x71, 0xfd, 0xf8, 0x89, + 0xc8, 0xcb, 0xcb, 0xc3, 0x57, 0x5f, 0x7d, 0x05, 0xe0, 0x0a, 0xa6, 0xe0, + 0xd0, 0xa1, 0x43, 0x9d, 0x42, 0x22, 0x92, 0xf9, 0x6f, 0xb5, 0x5a, 0xf1, + 0xf2, 0xcb, 0x2f, 0xc3, 0xe9, 0x74, 0x62, 0xc5, 0x8a, 0x15, 0x18, 0x3b, + 0x76, 0xac, 0x2c, 0xc6, 0xd5, 0x6a, 0x35, 0x52, 0x53, 0x53, 0x43, 0xf6, + 0xf4, 0xdd, 0x6e, 0x37, 0x68, 0x9a, 0xc6, 0xc1, 0x83, 0x07, 0xf1, 0xd7, + 0xbf, 0xfe, 0x15, 0xed, 0x8e, 0xb9, 0x8a, 0x51, 0x2a, 0x95, 0x33, 0x01, + 0x4c, 0x19, 0x3c, 0x78, 0x70, 0x48, 0x62, 0x6b, 0xce, 0x9c, 0x39, 0xdd, + 0x7e, 0x6f, 0x34, 0x1a, 0xe1, 0x76, 0xbb, 0x11, 0x11, 0x11, 0x81, 0x41, + 0x83, 0x06, 0xe1, 0xe0, 0xc1, 0x83, 0x38, 0x7e, 0xfc, 0x38, 0xa6, 0x4c, + 0x99, 0x02, 0x9d, 0x4e, 0x07, 0xaf, 0xd7, 0x8b, 0xca, 0xca, 0x4a, 0x18, + 0x8d, 0xc6, 0x4e, 0xb8, 0xab, 0xf9, 0xf3, 0xe7, 0xc3, 0x6a, 0xb5, 0x62, + 0xdf, 0x96, 0x7f, 0x20, 0xc2, 0x68, 0x0a, 0x2e, 0x31, 0xc1, 0x30, 0x58, + 0xfb, 0xd6, 0x3a, 0x5c, 0x28, 0xbe, 0x02, 0xb0, 0xf3, 0x07, 0x02, 0x38, + 0x7c, 0xe6, 0x24, 0x26, 0x8c, 0xca, 0xc0, 0xb0, 0x21, 0x29, 0xff, 0x12, + 0x69, 0x00, 0x2a, 0x1a, 0xeb, 0x30, 0xf7, 0x57, 0xcb, 0xd0, 0x6c, 0x6d, + 0x95, 0x3f, 0x2b, 0xa9, 0x2a, 0xc7, 0x7d, 0x37, 0x2e, 0x86, 0x46, 0xad, + 0x91, 0xc5, 0x19, 0x45, 0x08, 0x96, 0xcc, 0xfb, 0x25, 0xfe, 0xf0, 0xe7, + 0x77, 0x51, 0x51, 0x51, 0x81, 0xa9, 0x53, 0xa7, 0x22, 0x2f, 0x2f, 0x0f, + 0x7e, 0xbf, 0xbf, 0xd3, 0xca, 0x90, 0x40, 0x6f, 0xab, 0x57, 0xaf, 0x96, + 0x95, 0xf8, 0xe2, 0xc5, 0x8b, 0x65, 0x66, 0xf8, 0x7c, 0x3e, 0x4c, 0x9d, + 0x3a, 0x35, 0xe4, 0x3a, 0x2e, 0x79, 0x79, 0x79, 0x70, 0xb9, 0x5c, 0xf8, + 0xf2, 0xcb, 0x2f, 0x65, 0x10, 0x79, 0x7d, 0x7d, 0x3d, 0x08, 0x21, 0x3f, + 0xd2, 0x00, 0x7c, 0xa1, 0xe0, 0x6d, 0x69, 0x9a, 0x96, 0x2b, 0x03, 0xf5, + 0x44, 0xe9, 0xe9, 0xe9, 0x60, 0x59, 0x16, 0x93, 0x27, 0x4f, 0xc6, 0x8a, + 0x15, 0x2b, 0xe0, 0x72, 0xb9, 0xf0, 0xf4, 0xd3, 0x4f, 0x4b, 0xb5, 0x3e, + 0x40, 0x08, 0xc1, 0xf1, 0xe3, 0xc7, 0x71, 0xea, 0xd4, 0x29, 0x59, 0x54, + 0x9c, 0x38, 0x71, 0x02, 0xc5, 0xc5, 0xc5, 0xb8, 0xff, 0x96, 0x65, 0x18, + 0x92, 0x9c, 0x1a, 0x34, 0xc0, 0x92, 0xc0, 0xb2, 0x5f, 0x05, 0x3f, 0x15, + 0x04, 0x01, 0x2f, 0x7e, 0xf0, 0x26, 0x40, 0x75, 0x98, 0x44, 0x7a, 0x3d, + 0xde, 0xdc, 0xf2, 0x01, 0x9c, 0x6e, 0x57, 0xb0, 0x38, 0x0c, 0x04, 0xe0, + 0xf3, 0xfb, 0x82, 0x0d, 0x02, 0x42, 0xa0, 0x0b, 0x0b, 0xc7, 0xb3, 0xbf, + 0x5a, 0x85, 0x9c, 0x9c, 0x1c, 0xec, 0xd8, 0xb1, 0xa3, 0xcb, 0x31, 0x60, + 0x18, 0x06, 0x0e, 0x87, 0x03, 0xab, 0x57, 0xaf, 0x46, 0x73, 0x73, 0x33, + 0x66, 0xce, 0x9c, 0x89, 0x5b, 0x6e, 0xb9, 0x45, 0x66, 0x86, 0x28, 0x8a, + 0x18, 0x33, 0x66, 0x4c, 0xc8, 0x7b, 0xfa, 0x79, 0x9e, 0x87, 0xdb, 0xed, + 0xc6, 0xf1, 0xe3, 0xc7, 0x51, 0x54, 0x54, 0x14, 0x14, 0x0f, 0x03, 0xc0, + 0xd3, 0x14, 0x45, 0x39, 0x04, 0x41, 0x90, 0xd3, 0x8a, 0xbd, 0xd9, 0xce, + 0xfb, 0xf7, 0xef, 0xef, 0xf1, 0x1a, 0x8d, 0x46, 0x83, 0x8c, 0x8c, 0x0c, + 0xf0, 0x3c, 0x8f, 0x25, 0x4b, 0x96, 0xe0, 0x81, 0x07, 0x1e, 0x80, 0xc3, + 0xe1, 0xc0, 0xda, 0xb5, 0x6b, 0x51, 0x58, 0x58, 0x08, 0xc9, 0xa2, 0xab, + 0xab, 0xab, 0xc3, 0xee, 0xdd, 0xbb, 0xd1, 0xd4, 0xd4, 0x84, 0x37, 0xde, + 0x78, 0x03, 0x0c, 0x4d, 0xe3, 0xf6, 0xb9, 0x8b, 0x00, 0xa1, 0x2b, 0x4b, + 0x8e, 0xc2, 0xb4, 0xcc, 0xce, 0x75, 0xd5, 0xcf, 0x9c, 0xcf, 0x05, 0xc4, + 0x0e, 0xd7, 0x1b, 0x8c, 0xd8, 0xbc, 0xed, 0x7f, 0x3b, 0x5d, 0x37, 0x24, + 0x7e, 0x10, 0xe2, 0x12, 0x12, 0x01, 0x49, 0x87, 0x51, 0x14, 0x44, 0x42, + 0x50, 0x59, 0x56, 0x0c, 0x93, 0xc1, 0x00, 0xaa, 0xdd, 0x4c, 0xef, 0x4a, + 0x4c, 0x37, 0x36, 0x36, 0xe2, 0x89, 0x27, 0x9e, 0x40, 0x6d, 0x6d, 0x2d, + 0x66, 0xce, 0x9c, 0x19, 0x84, 0xba, 0x94, 0x14, 0x72, 0x5f, 0xc2, 0x45, + 0x5e, 0xaf, 0x17, 0x07, 0x0f, 0x1e, 0xc4, 0xee, 0xdd, 0xbb, 0x83, 0x5c, + 0x8d, 0xf6, 0xbd, 0xf3, 0x3e, 0x5a, 0xa1, 0x50, 0x34, 0x49, 0x0c, 0x09, + 0x25, 0xe3, 0x76, 0xe0, 0x85, 0x37, 0x72, 0x37, 0x00, 0x00, 0x18, 0xa8, + 0x49, 0x44, 0x41, 0x54, 0xc0, 0x81, 0x5e, 0x6b, 0x7e, 0xc4, 0xc5, 0xc5, + 0x61, 0xec, 0xd8, 0xb1, 0xf0, 0x78, 0x3c, 0xb8, 0xe9, 0xa6, 0x9b, 0xf0, + 0xf0, 0xc3, 0x0f, 0xc3, 0xe7, 0xf3, 0xe1, 0x85, 0x17, 0x5e, 0x90, 0x21, + 0x3a, 0xd2, 0x0b, 0x1d, 0x3b, 0x76, 0x0c, 0x67, 0xce, 0x9c, 0x81, 0x5e, + 0xab, 0xc3, 0xe8, 0x31, 0xd7, 0x01, 0x3c, 0xd7, 0xa5, 0x4f, 0xb1, 0x78, + 0xee, 0x22, 0xe8, 0xbb, 0x52, 0x98, 0xe4, 0xea, 0xbf, 0x3b, 0xcf, 0xf2, + 0xb5, 0x0f, 0x3c, 0x02, 0x80, 0x6a, 0xb7, 0xbc, 0x18, 0xd4, 0x36, 0xd4, + 0xe3, 0xe8, 0x99, 0x13, 0x38, 0x7b, 0x21, 0x1f, 0x31, 0xe6, 0x48, 0x84, + 0x19, 0x4d, 0x28, 0x2e, 0x2e, 0x0e, 0x42, 0xd3, 0xab, 0x54, 0x2a, 0xe4, + 0xe6, 0xe6, 0x62, 0xcd, 0x9a, 0x35, 0xb0, 0x5a, 0xad, 0xb8, 0xed, 0xb6, + 0xdb, 0xf0, 0xf8, 0xe3, 0x8f, 0x07, 0x01, 0xc5, 0x15, 0x0a, 0x05, 0x26, + 0x4c, 0x98, 0xd0, 0xab, 0xcb, 0xd0, 0x91, 0x3e, 0xfa, 0xe8, 0x23, 0xec, + 0xdc, 0xb9, 0xb3, 0x4b, 0xe5, 0x4f, 0x08, 0x71, 0xd3, 0x5e, 0xaf, 0xb7, + 0x56, 0x10, 0x84, 0x90, 0xb0, 0x4b, 0x34, 0x4d, 0xa3, 0xb0, 0xb0, 0xb0, + 0x47, 0xe5, 0xde, 0xd1, 0x37, 0x19, 0x32, 0x64, 0x08, 0xfc, 0x7e, 0x3f, + 0xe6, 0xcc, 0x99, 0x83, 0xd7, 0x5f, 0x7f, 0x1d, 0x0c, 0xc3, 0xe0, 0xc3, + 0x0f, 0x3f, 0xc4, 0x27, 0x9f, 0x7c, 0x22, 0x77, 0x48, 0x10, 0x04, 0xf8, + 0x7c, 0x3e, 0x28, 0x15, 0x0a, 0xe4, 0xe7, 0xe5, 0xc0, 0xeb, 0xf5, 0xa1, + 0x53, 0x91, 0x22, 0x42, 0x30, 0x22, 0x25, 0x15, 0xef, 0xad, 0x0d, 0xc6, + 0x8a, 0x2d, 0x9e, 0xb3, 0xf0, 0x8a, 0x19, 0x2c, 0x91, 0xcd, 0x86, 0x3f, + 0xae, 0x7e, 0x21, 0xe8, 0x9a, 0xff, 0x77, 0xeb, 0x32, 0xdc, 0x3a, 0xef, + 0x46, 0x20, 0xc0, 0xc1, 0xe1, 0x72, 0x62, 0xdf, 0xd1, 0x83, 0x38, 0x73, + 0x21, 0x0f, 0x6d, 0x4e, 0x27, 0x18, 0x86, 0x81, 0x4e, 0xa3, 0x83, 0x4a, + 0xa1, 0x0c, 0x2a, 0xb5, 0xa1, 0xd1, 0x68, 0xb0, 0x7f, 0xff, 0x7e, 0xbc, + 0xfc, 0xf2, 0xcb, 0xb0, 0xdb, 0xed, 0x78, 0xe4, 0x91, 0x47, 0x70, 0xef, + 0xbd, 0xf7, 0x76, 0xf2, 0xc3, 0xb2, 0xb3, 0xb3, 0x65, 0xbd, 0x21, 0x89, + 0xfd, 0xee, 0x7e, 0xaa, 0xaa, 0xaa, 0xb0, 0x62, 0xc5, 0x0a, 0x7c, 0xf1, + 0xc5, 0x17, 0x9d, 0x2c, 0x5a, 0xe9, 0xb9, 0x2c, 0xcb, 0xb6, 0xb1, 0x14, + 0x45, 0xf9, 0x00, 0xc0, 0xe1, 0x70, 0x84, 0xb4, 0x23, 0x2a, 0x10, 0x08, + 0x60, 0xfd, 0xfa, 0xf5, 0x58, 0xb7, 0x6e, 0x1d, 0x92, 0x92, 0x92, 0x7a, + 0xbc, 0x76, 0xdc, 0xb8, 0x71, 0xe0, 0x38, 0x0e, 0x75, 0x75, 0x75, 0x48, + 0x4d, 0x4d, 0xc5, 0xfa, 0xf5, 0xeb, 0xf1, 0xda, 0x6b, 0xaf, 0xe1, 0x8b, + 0x2f, 0xbe, 0xc0, 0xc5, 0x8b, 0x17, 0xb1, 0x7a, 0xf5, 0x6a, 0x18, 0x8d, + 0x46, 0x88, 0xa2, 0x08, 0x96, 0x61, 0xe0, 0x70, 0xb9, 0xf0, 0xfd, 0xd1, + 0x03, 0x88, 0x8b, 0x8a, 0xc6, 0x90, 0x84, 0x41, 0x88, 0x8a, 0xb0, 0x80, + 0x62, 0x98, 0x2b, 0x3a, 0x85, 0xe7, 0xb1, 0xe2, 0xce, 0xfb, 0x90, 0x99, + 0x31, 0x0e, 0x5f, 0xed, 0xfe, 0x06, 0x1a, 0x95, 0x1a, 0x0f, 0x2d, 0xbd, + 0x07, 0xe0, 0x3a, 0x0c, 0x92, 0xcf, 0x83, 0x47, 0xee, 0xfe, 0x7f, 0xd0, + 0xe9, 0xb4, 0x28, 0xaf, 0xa9, 0xc2, 0xac, 0x29, 0xd3, 0x71, 0xc3, 0xd4, + 0x99, 0xa8, 0xab, 0x28, 0x43, 0x59, 0x6d, 0x15, 0x9a, 0x5a, 0x5b, 0x40, + 0x5f, 0x05, 0x60, 0xa3, 0xa8, 0x76, 0x11, 0xd6, 0x2e, 0xb2, 0x03, 0x81, + 0x00, 0x36, 0x6e, 0xdc, 0x88, 0x7d, 0xfb, 0xf6, 0x41, 0xa1, 0x50, 0xe0, + 0xa9, 0xa7, 0x9e, 0xc2, 0xe4, 0xc9, 0x93, 0x83, 0x98, 0xc1, 0xf3, 0x3c, + 0x26, 0x4d, 0x9a, 0x04, 0x83, 0xc1, 0x80, 0xc3, 0x87, 0x0f, 0x23, 0x2f, + 0x2f, 0x0f, 0x4d, 0x4d, 0x4d, 0x72, 0x05, 0x09, 0x95, 0x4a, 0x25, 0x87, + 0xde, 0xdd, 0x6e, 0x37, 0x6a, 0x6a, 0x6a, 0x50, 0x5d, 0x5d, 0x2d, 0x7b, + 0xe6, 0xc1, 0xcf, 0xa7, 0x24, 0x5d, 0xca, 0x03, 0x68, 0xa6, 0x34, 0x1a, + 0x4d, 0xba, 0xd7, 0xeb, 0xfd, 0xe7, 0x90, 0x21, 0x43, 0xb4, 0xa9, 0xa9, + 0xa9, 0x21, 0x81, 0x0c, 0xa4, 0x1a, 0x8a, 0xf3, 0xe6, 0xcd, 0xc3, 0x2f, + 0x7f, 0xf9, 0x4b, 0x24, 0x27, 0x27, 0xf7, 0xa8, 0xc4, 0x8e, 0x1d, 0x3b, + 0x06, 0xab, 0xd5, 0x0a, 0x9a, 0xa6, 0x11, 0x08, 0x04, 0xf0, 0xca, 0x2b, + 0xaf, 0xa0, 0xa0, 0xa0, 0x00, 0x1a, 0x8d, 0x06, 0x4f, 0x3e, 0xf9, 0x24, + 0xb6, 0x6c, 0xd9, 0x02, 0xbf, 0xd7, 0x87, 0x0f, 0x9e, 0xff, 0x3d, 0x34, + 0x6a, 0xcd, 0x95, 0x02, 0x86, 0x82, 0x00, 0x9d, 0x56, 0x87, 0x61, 0x83, + 0x87, 0x20, 0xda, 0x6c, 0x81, 0x4e, 0xa7, 0xbf, 0xc2, 0x18, 0x42, 0xfe, + 0xe5, 0xec, 0x75, 0x25, 0x3a, 0x29, 0x0a, 0x84, 0xa2, 0xe1, 0xf3, 0xba, + 0x50, 0x5d, 0x5f, 0x8f, 0x92, 0xea, 0x0a, 0x78, 0x7d, 0x3e, 0xb0, 0xdd, + 0xbc, 0x97, 0xd7, 0xef, 0xc3, 0x63, 0x7f, 0x7c, 0x11, 0x2a, 0xed, 0x95, + 0xbe, 0xbc, 0xf3, 0xce, 0x3b, 0x28, 0x2f, 0x2f, 0x47, 0x4c, 0x4c, 0x8c, + 0x5c, 0x96, 0xaa, 0xa3, 0x88, 0x26, 0x84, 0x60, 0xd2, 0xa4, 0x49, 0xa8, + 0xa9, 0xa9, 0xc1, 0xba, 0x75, 0xeb, 0xe0, 0x72, 0xb9, 0x42, 0x8a, 0x8b, + 0x11, 0x42, 0xd0, 0xd2, 0xd2, 0xd2, 0x49, 0x35, 0x50, 0x14, 0x85, 0xa6, + 0xa6, 0x26, 0x54, 0x56, 0x56, 0x7a, 0x8d, 0x46, 0xe3, 0x74, 0x2a, 0x3c, + 0x3c, 0x3c, 0xbe, 0xad, 0xad, 0xed, 0x6c, 0x5c, 0x5c, 0x5c, 0xf4, 0x94, + 0x29, 0x53, 0xd0, 0xd2, 0xd2, 0x12, 0x72, 0xe0, 0xcd, 0xe7, 0xf3, 0x21, + 0x3c, 0x3c, 0x1c, 0x6f, 0xbd, 0xf5, 0x56, 0x8f, 0x3b, 0x4c, 0x79, 0x9e, + 0xc7, 0x99, 0x33, 0x67, 0x50, 0x5b, 0x5b, 0x0b, 0x85, 0x42, 0x01, 0x41, + 0x10, 0xf0, 0xfd, 0xf7, 0xdf, 0xe3, 0xd3, 0x4f, 0x3f, 0x85, 0xdf, 0xef, + 0x07, 0xc3, 0x30, 0x60, 0x68, 0x06, 0xef, 0x3d, 0xf7, 0x2a, 0xa2, 0x22, + 0x2c, 0x41, 0x2f, 0x21, 0x88, 0x02, 0xd4, 0x4a, 0x35, 0x74, 0x5a, 0x2d, + 0xcc, 0xa6, 0x30, 0x18, 0x0c, 0x46, 0xe8, 0xb5, 0x3a, 0x68, 0xd5, 0xea, + 0x2b, 0xb2, 0x9b, 0x00, 0x01, 0x8e, 0x83, 0xc7, 0xe7, 0x85, 0xdb, 0xe3, + 0x86, 0xdd, 0xe9, 0x80, 0xd5, 0xde, 0x06, 0xb7, 0xd7, 0x83, 0x00, 0xc7, + 0x81, 0xe9, 0x05, 0xe6, 0xd3, 0xd0, 0xda, 0x8c, 0xa7, 0xdf, 0x78, 0x15, + 0x01, 0x9e, 0x93, 0x6b, 0x2d, 0xde, 0x74, 0xd3, 0x4d, 0x58, 0xba, 0x74, + 0x29, 0x0c, 0x06, 0x43, 0x10, 0x33, 0x78, 0x9e, 0x47, 0x66, 0x66, 0x26, + 0x4a, 0x4b, 0x4b, 0xf1, 0xe6, 0x9b, 0x6f, 0xca, 0x30, 0xa2, 0x50, 0xc7, + 0xaa, 0xad, 0xad, 0xad, 0x53, 0x5f, 0x68, 0x9a, 0x46, 0x69, 0x69, 0x29, + 0xac, 0x56, 0xab, 0x3d, 0x3c, 0x3c, 0x3c, 0x83, 0x35, 0x18, 0x0c, 0x56, + 0xbb, 0xdd, 0xee, 0xe0, 0x79, 0x3e, 0xfa, 0xe6, 0x9b, 0x6f, 0xc6, 0xe5, + 0xcb, 0x97, 0x71, 0xf2, 0xe4, 0xc9, 0x90, 0x1e, 0xa4, 0x56, 0xab, 0xe1, + 0x74, 0x3a, 0xf1, 0xdd, 0x77, 0xdf, 0xe1, 0xa1, 0x87, 0x1e, 0xea, 0xf6, + 0x3a, 0x96, 0x65, 0x31, 0x71, 0xe2, 0x44, 0x1c, 0x3b, 0x76, 0x0c, 0xcd, + 0xcd, 0xcd, 0xa0, 0x28, 0x0a, 0xf3, 0xe7, 0xcf, 0x87, 0xc3, 0xe1, 0xc0, + 0xb6, 0x6d, 0xdb, 0xc0, 0xf3, 0x3c, 0x78, 0x08, 0x38, 0x5d, 0x90, 0x87, + 0xc5, 0xb3, 0xe6, 0xc3, 0xdf, 0xae, 0xcf, 0x28, 0x8a, 0x02, 0xcb, 0xb0, + 0xe0, 0x05, 0x1e, 0x76, 0xa7, 0x03, 0x76, 0xa7, 0x23, 0x38, 0xe7, 0xd1, + 0xae, 0x6b, 0x08, 0xba, 0x36, 0xdb, 0xd9, 0x5e, 0x56, 0x3b, 0x45, 0x51, + 0x68, 0x68, 0x6e, 0x0a, 0x32, 0x93, 0x7f, 0xf7, 0xbb, 0xdf, 0xe1, 0xba, + 0xeb, 0xae, 0x93, 0x77, 0x43, 0x75, 0x9c, 0x1c, 0x13, 0x27, 0x4e, 0x84, + 0xd9, 0x6c, 0xc6, 0x6b, 0xaf, 0xbd, 0xd6, 0x27, 0x3c, 0x17, 0x45, 0x51, + 0x32, 0xde, 0xb7, 0xab, 0x95, 0xe3, 0xf5, 0x7a, 0x41, 0xd3, 0xb4, 0x35, + 0x10, 0x08, 0xb8, 0x19, 0x9a, 0xa6, 0x89, 0x20, 0x08, 0x37, 0xf2, 0x3c, + 0x3f, 0x74, 0xc6, 0x8c, 0x19, 0x18, 0x37, 0x6e, 0x1c, 0x22, 0x23, 0x23, + 0x91, 0x9f, 0x9f, 0x1f, 0x92, 0xf5, 0x40, 0x51, 0x14, 0x8a, 0x8b, 0x8b, + 0x7b, 0xdc, 0x6f, 0x21, 0x5d, 0x37, 0x68, 0xd0, 0x20, 0x04, 0x02, 0x01, + 0x38, 0x1c, 0x0e, 0x7c, 0xf2, 0xc9, 0x27, 0x28, 0x2d, 0x2d, 0x95, 0x22, + 0x9d, 0x70, 0xb9, 0x5c, 0xc8, 0x29, 0xcc, 0x47, 0x41, 0xf1, 0x25, 0xc4, + 0x46, 0x46, 0x21, 0xca, 0x6c, 0x01, 0x43, 0xd3, 0x10, 0x08, 0xe9, 0xb6, + 0x0e, 0x21, 0x69, 0xff, 0x17, 0x2a, 0x11, 0x00, 0x0c, 0x4d, 0x83, 0x61, + 0x18, 0xd4, 0x36, 0x35, 0x60, 0xeb, 0xff, 0x7d, 0x81, 0xad, 0x3b, 0xfe, + 0x01, 0xe0, 0xca, 0xa9, 0x09, 0xeb, 0xd6, 0xad, 0x43, 0x72, 0x72, 0x72, + 0x90, 0xbe, 0x90, 0x22, 0xbb, 0x59, 0x59, 0x59, 0x48, 0x48, 0x48, 0x80, + 0xd5, 0x6a, 0xc5, 0xb6, 0x6d, 0xdb, 0xfa, 0x54, 0x5d, 0xce, 0xe1, 0x70, + 0x74, 0x5b, 0x0f, 0x52, 0x3a, 0x67, 0x85, 0x10, 0x52, 0x30, 0x64, 0xc8, + 0x90, 0x2d, 0xac, 0xcd, 0x66, 0x13, 0x34, 0x1a, 0xcd, 0x31, 0x8f, 0xc7, + 0x33, 0xab, 0xad, 0xad, 0x0d, 0x6d, 0x6d, 0x6d, 0x58, 0xb2, 0x64, 0x09, + 0xb4, 0x5a, 0x2d, 0xfe, 0xfe, 0xf7, 0xbf, 0xf7, 0x3a, 0x0b, 0x28, 0x8a, + 0x42, 0x4b, 0x4b, 0x8b, 0x5c, 0x72, 0xbc, 0x37, 0xca, 0xc8, 0xc8, 0xc0, + 0xd7, 0x5f, 0x7f, 0x8d, 0xb2, 0xb2, 0x32, 0xd9, 0xfc, 0x8d, 0x8f, 0x8f, + 0x47, 0x64, 0x64, 0x24, 0xca, 0xcb, 0xcb, 0x91, 0x77, 0xe9, 0x02, 0xf2, + 0x2e, 0x5d, 0xc0, 0xf8, 0x51, 0x19, 0xb8, 0x73, 0xc1, 0x2d, 0x48, 0x4d, + 0x1a, 0x0a, 0xbe, 0x5d, 0x19, 0x5e, 0x0b, 0x51, 0x14, 0x05, 0x05, 0xcd, + 0xa0, 0xc1, 0xd6, 0x82, 0xed, 0x7b, 0x77, 0x62, 0xe7, 0x91, 0x1f, 0xe4, + 0x67, 0xaf, 0x5c, 0xb9, 0x12, 0xe3, 0xc6, 0x8d, 0x83, 0xd7, 0xeb, 0xed, + 0x64, 0x6d, 0xaa, 0x54, 0x2a, 0x64, 0x67, 0x67, 0xcb, 0x06, 0x0f, 0xc7, + 0x71, 0x7d, 0xea, 0x8b, 0x64, 0x45, 0x76, 0x37, 0x8e, 0x82, 0x20, 0x80, + 0xe3, 0x38, 0xb0, 0x2c, 0x5b, 0x76, 0xf1, 0xe2, 0x45, 0x3f, 0xdb, 0xde, + 0xd9, 0x13, 0x00, 0x90, 0x93, 0x93, 0x83, 0xd1, 0xa3, 0x47, 0xe3, 0xf8, + 0xf1, 0xe3, 0x58, 0xbe, 0x7c, 0x39, 0x54, 0x2a, 0x15, 0xde, 0x7d, 0xf7, + 0xdd, 0x5e, 0xad, 0x2f, 0xa5, 0x52, 0x89, 0x8a, 0x8a, 0x8a, 0x90, 0x18, + 0xe2, 0xf7, 0xfb, 0x51, 0x57, 0x57, 0x87, 0xa8, 0xa8, 0x28, 0xd8, 0xed, + 0x76, 0x79, 0xa6, 0x29, 0x95, 0x4a, 0x0c, 0x1f, 0x3e, 0x1c, 0x0e, 0x87, + 0x03, 0x4d, 0x4d, 0x4d, 0x38, 0x53, 0x90, 0x87, 0xdc, 0xa2, 0x0b, 0x18, + 0x31, 0x24, 0x19, 0xd3, 0xb3, 0x26, 0x63, 0xc6, 0xc4, 0x6c, 0x98, 0xf4, + 0x7a, 0xb8, 0xbd, 0xde, 0x3e, 0x0d, 0x88, 0x46, 0xa5, 0x86, 0x48, 0x08, + 0x8e, 0x9e, 0x3d, 0x85, 0x03, 0xa7, 0x8f, 0x21, 0xef, 0xe2, 0x05, 0x78, + 0xfd, 0x3e, 0x24, 0x25, 0x25, 0xe1, 0xd6, 0x5b, 0x6f, 0xc5, 0xa4, 0x49, + 0x93, 0xa0, 0x56, 0xab, 0xe1, 0xf1, 0x78, 0x82, 0x06, 0x8d, 0xe7, 0x79, + 0xd9, 0x9f, 0xea, 0x98, 0xbc, 0xd3, 0x68, 0x34, 0x60, 0x59, 0x36, 0x24, + 0x37, 0x41, 0x5a, 0x1d, 0x3d, 0xa5, 0x9a, 0xbd, 0xed, 0xef, 0xa3, 0xd1, + 0x68, 0x0e, 0x70, 0x1c, 0x77, 0x05, 0xdb, 0x6b, 0x36, 0x9b, 0xf3, 0xbd, + 0x5e, 0x6f, 0xcb, 0x9e, 0x3d, 0x7b, 0x2c, 0x0f, 0x3f, 0xfc, 0x30, 0x5a, + 0x5a, 0x5a, 0x70, 0xfa, 0xf4, 0x69, 0xdc, 0x7e, 0xfb, 0xed, 0x30, 0x18, + 0x0c, 0x78, 0xf7, 0xdd, 0x77, 0x7b, 0xd4, 0x29, 0x92, 0xb9, 0x18, 0x0a, + 0x49, 0xe6, 0xa5, 0x52, 0xa9, 0x84, 0xc5, 0x62, 0x81, 0xcd, 0x66, 0x0b, + 0x9a, 0x75, 0x46, 0xa3, 0x11, 0x26, 0x93, 0x09, 0x5e, 0xaf, 0x17, 0x97, + 0x2f, 0x5f, 0x46, 0x41, 0xc9, 0x25, 0x14, 0x94, 0x5c, 0xc2, 0xfb, 0x7f, + 0xdf, 0x8a, 0xf9, 0x53, 0x67, 0x60, 0xf9, 0xa2, 0xc5, 0xd0, 0xaa, 0xd4, + 0x3d, 0x96, 0x11, 0x27, 0xe4, 0x8a, 0x20, 0x13, 0x44, 0x01, 0x5f, 0xed, + 0xfc, 0x0a, 0xff, 0xd8, 0xf9, 0x7f, 0xe0, 0xda, 0xab, 0xc8, 0xe9, 0x74, + 0x3a, 0x3c, 0xf3, 0xf8, 0x33, 0x98, 0x3a, 0x75, 0xaa, 0x6c, 0xff, 0x4b, + 0x65, 0xc9, 0x3b, 0xf6, 0x31, 0x25, 0x25, 0x05, 0x5d, 0xed, 0x94, 0x55, + 0xab, 0xd5, 0x30, 0x9b, 0xcd, 0x70, 0xbb, 0xdd, 0xbd, 0x4a, 0x0f, 0xaf, + 0xd7, 0x0b, 0x9f, 0xcf, 0xd7, 0xed, 0xd8, 0x31, 0x0c, 0x03, 0xa9, 0xde, + 0xe2, 0x87, 0x1f, 0x7e, 0xf8, 0xc5, 0xf2, 0xe5, 0xcb, 0xff, 0x25, 0x9e, + 0x59, 0x96, 0x3d, 0xc0, 0xf3, 0xfc, 0x8c, 0xcd, 0x9b, 0x37, 0x23, 0x2a, + 0x2a, 0x0a, 0x82, 0x20, 0x60, 0xd2, 0xa4, 0x49, 0x88, 0x89, 0x89, 0xc1, + 0xf6, 0xed, 0xdb, 0xb1, 0x65, 0xcb, 0x96, 0x6e, 0x07, 0xa1, 0xb5, 0xb5, + 0x15, 0x9f, 0x7e, 0xfa, 0x69, 0xc8, 0xe8, 0xf4, 0x13, 0x27, 0x4e, 0xe0, + 0x95, 0x57, 0x5e, 0x91, 0xb1, 0xbc, 0x2e, 0x97, 0x0b, 0x6e, 0xb7, 0x3b, + 0x68, 0x26, 0x49, 0xcf, 0x72, 0x38, 0x1c, 0x68, 0x6d, 0x6d, 0x85, 0xcd, + 0x66, 0x93, 0x65, 0x7b, 0x7c, 0x74, 0x0c, 0x86, 0xc4, 0x27, 0x22, 0x3e, + 0x2a, 0x16, 0xb1, 0x51, 0xd1, 0x30, 0xe9, 0xae, 0x04, 0x2a, 0x9d, 0x1e, + 0x37, 0x1a, 0x5a, 0x9a, 0x50, 0xdb, 0xd8, 0x80, 0xca, 0xfa, 0x1a, 0x54, + 0xd4, 0x56, 0xcb, 0x68, 0x94, 0x31, 0x63, 0xc6, 0x60, 0xd6, 0xac, 0x59, + 0xc8, 0xcc, 0xcc, 0x84, 0x42, 0xa1, 0xe8, 0x32, 0xb7, 0xc3, 0xf3, 0x3c, + 0x4c, 0x26, 0x13, 0x46, 0x8f, 0x1e, 0xdd, 0x63, 0xd6, 0x6f, 0xfd, 0xfa, + 0xf5, 0x38, 0x7a, 0xf4, 0x68, 0x8f, 0x93, 0x54, 0xda, 0x51, 0xd5, 0xd3, + 0x6a, 0xa6, 0x28, 0x0a, 0xb9, 0xb9, 0xb9, 0xa0, 0x69, 0xfa, 0x9c, 0xdf, + 0xef, 0x1f, 0x97, 0x91, 0x91, 0xf1, 0x2f, 0x86, 0xe8, 0xf5, 0xfa, 0xdf, + 0xb8, 0x5c, 0xae, 0x0f, 0x16, 0x2d, 0x5a, 0x24, 0xa7, 0x63, 0x09, 0x21, + 0x98, 0x37, 0x6f, 0x1e, 0x34, 0x1a, 0x0d, 0x4e, 0x9e, 0x3c, 0x89, 0xf5, + 0xeb, 0xd7, 0x77, 0x52, 0x66, 0x92, 0x27, 0xba, 0x6b, 0xd7, 0xae, 0x3e, + 0xa3, 0x48, 0xd6, 0xad, 0x5b, 0x87, 0x96, 0x96, 0x16, 0xb0, 0x2c, 0x0b, + 0x9e, 0xe7, 0x61, 0xb7, 0xdb, 0x11, 0x08, 0x04, 0xba, 0x34, 0x0d, 0x45, + 0x51, 0x84, 0xcd, 0x66, 0x43, 0x5b, 0x5b, 0x9b, 0x2c, 0xea, 0x7a, 0x12, + 0x05, 0x0c, 0xc3, 0x60, 0xec, 0xd8, 0xb1, 0xf8, 0xc5, 0x2f, 0x7e, 0x81, + 0x49, 0x93, 0x26, 0x21, 0x32, 0x32, 0xb2, 0xc7, 0x6d, 0x78, 0x84, 0x10, + 0x0c, 0x19, 0x32, 0x04, 0xa3, 0x46, 0x8d, 0xea, 0xd5, 0x98, 0xd9, 0xbb, + 0x77, 0x2f, 0xfe, 0xf4, 0xa7, 0x3f, 0xf5, 0x78, 0x0e, 0x49, 0x4b, 0x4b, + 0x4b, 0x8f, 0x25, 0x39, 0xa4, 0xc9, 0x76, 0xe9, 0xd2, 0x25, 0x98, 0x4c, + 0xa6, 0x65, 0x76, 0xbb, 0xfd, 0x73, 0x74, 0x8c, 0x51, 0x18, 0x8d, 0xc6, + 0x64, 0x87, 0xc3, 0x91, 0x9f, 0x94, 0x94, 0xa4, 0x7d, 0xf3, 0xcd, 0x37, + 0x65, 0xf7, 0xde, 0x64, 0x32, 0x61, 0xda, 0xb4, 0x69, 0x60, 0x18, 0x06, + 0x35, 0x35, 0x35, 0xd8, 0xbc, 0x79, 0x33, 0x0e, 0x1f, 0x3e, 0x0c, 0x8d, + 0x46, 0x03, 0x86, 0x61, 0xe0, 0xf5, 0x7a, 0xf1, 0x9b, 0xdf, 0xfc, 0xa6, + 0x5f, 0xfb, 0x2b, 0x5c, 0x2e, 0x17, 0xf6, 0xed, 0xdb, 0x87, 0xad, 0x5b, + 0xb7, 0xca, 0xe7, 0x7b, 0xf8, 0x7c, 0x3e, 0x38, 0x9d, 0x4e, 0xb9, 0x50, + 0x65, 0x57, 0x8c, 0x91, 0xaa, 0x8b, 0x4a, 0xe1, 0x0e, 0x69, 0x92, 0xd0, + 0x34, 0x2d, 0x57, 0x0f, 0x4d, 0x49, 0x49, 0xc1, 0x3d, 0xf7, 0xdc, 0x03, + 0x8d, 0x46, 0x23, 0xef, 0x1c, 0xee, 0xce, 0x47, 0x8a, 0x8b, 0x8b, 0x43, + 0x5a, 0x5a, 0x5a, 0x9f, 0x40, 0x19, 0x3d, 0x95, 0xcf, 0xb5, 0xdb, 0xed, + 0xf0, 0x7a, 0xbd, 0xbd, 0x8a, 0xb4, 0xea, 0xea, 0x6a, 0x34, 0x36, 0x36, + 0xba, 0xf4, 0x7a, 0xfd, 0x68, 0x8b, 0xc5, 0x52, 0x51, 0x51, 0x51, 0x21, + 0x9f, 0x68, 0x80, 0x09, 0x13, 0x26, 0xb8, 0x6b, 0x6a, 0x6a, 0x96, 0xba, + 0xdd, 0xee, 0xa8, 0xeb, 0xaf, 0xbf, 0x5e, 0x3e, 0x38, 0xcb, 0xe7, 0xf3, + 0xc9, 0x85, 0x02, 0x8c, 0x46, 0x23, 0x66, 0xcc, 0x98, 0x81, 0xf1, 0xe3, + 0xc7, 0xa3, 0xa2, 0xa2, 0x02, 0x7e, 0xbf, 0x1f, 0x77, 0xdc, 0x71, 0x07, + 0x96, 0x2c, 0x59, 0xd2, 0xaf, 0x3d, 0x16, 0x4a, 0xa5, 0x12, 0x69, 0x69, + 0x69, 0xb8, 0xe3, 0x8e, 0x3b, 0xe4, 0xb3, 0x9f, 0x68, 0x9a, 0x96, 0xe3, + 0x43, 0xdd, 0x1d, 0x32, 0x26, 0x55, 0x14, 0x55, 0xab, 0xd5, 0x32, 0xec, + 0x48, 0xaf, 0xd7, 0x43, 0xa7, 0xd3, 0xc9, 0x4e, 0xed, 0xd8, 0xb1, 0x63, + 0x31, 0x74, 0xe8, 0xd0, 0x1e, 0x57, 0x12, 0x4d, 0xd3, 0x98, 0x38, 0x71, + 0x22, 0xd2, 0xd3, 0xd3, 0x7b, 0x85, 0x7d, 0x76, 0x35, 0x99, 0x0a, 0x0b, + 0x0b, 0x3b, 0x89, 0x2d, 0x9f, 0xcf, 0x17, 0x92, 0x7e, 0x11, 0x45, 0x11, + 0x55, 0x55, 0x55, 0x00, 0x50, 0xd8, 0xd8, 0xd8, 0xb8, 0xe1, 0xd9, 0x67, + 0x9f, 0x05, 0xae, 0x8e, 0xe2, 0x19, 0x8d, 0xc6, 0x67, 0x1d, 0x0e, 0xc7, + 0xfa, 0xa5, 0x4b, 0x97, 0x62, 0xc5, 0x8a, 0x15, 0x72, 0xbe, 0x82, 0xe7, + 0x79, 0x8c, 0x1c, 0x39, 0x12, 0x69, 0x69, 0x69, 0xf8, 0x29, 0xa9, 0xb6, + 0xb6, 0x16, 0xfb, 0xf6, 0xed, 0xc3, 0x9e, 0x3d, 0x7b, 0xd0, 0xd4, 0xd4, + 0x04, 0x95, 0x4a, 0x05, 0x8f, 0xc7, 0x03, 0x9f, 0xcf, 0xd7, 0x49, 0xf1, + 0xf6, 0x16, 0xa6, 0x88, 0x8d, 0x8d, 0xc5, 0x7d, 0xf7, 0xdd, 0x17, 0x34, + 0x60, 0xd2, 0xaa, 0x8b, 0x88, 0x88, 0xc0, 0xd0, 0xa1, 0x43, 0x91, 0x90, + 0x90, 0xd0, 0xef, 0xfd, 0x22, 0x55, 0x55, 0x55, 0x58, 0xb9, 0x72, 0x65, + 0x10, 0xb3, 0xfd, 0x7e, 0x3f, 0xda, 0xda, 0xda, 0x42, 0xba, 0xdf, 0xed, + 0x76, 0xe3, 0xe2, 0xc5, 0x8b, 0x30, 0x18, 0x0c, 0x0f, 0x39, 0x1c, 0x8e, + 0x4d, 0xb2, 0xa2, 0xbf, 0xca, 0x24, 0xfd, 0x91, 0x61, 0x98, 0xdf, 0x35, + 0x35, 0x35, 0x61, 0xc6, 0x8c, 0x19, 0xb2, 0x9f, 0x20, 0x1d, 0xf1, 0xa3, + 0xd5, 0x6a, 0xfb, 0x55, 0xc1, 0x21, 0x54, 0x32, 0x1a, 0x8d, 0x18, 0x3b, + 0x76, 0x2c, 0x66, 0xcc, 0x98, 0x01, 0x51, 0x14, 0x51, 0x5c, 0x5c, 0x0c, + 0x95, 0x4a, 0x05, 0x8d, 0x46, 0x23, 0x87, 0x5c, 0x42, 0x49, 0x13, 0x48, + 0x9e, 0x31, 0xcb, 0xb2, 0x48, 0x4e, 0x4e, 0x96, 0x19, 0x91, 0x90, 0x90, + 0x80, 0xb1, 0x63, 0xc7, 0x22, 0x3d, 0x3d, 0x1d, 0x26, 0x93, 0xe9, 0x9a, + 0x76, 0x4e, 0xe9, 0x74, 0x3a, 0xec, 0xdf, 0xbf, 0x5f, 0xc6, 0x56, 0xf1, + 0x3c, 0x1f, 0xf2, 0x2e, 0x00, 0x9a, 0xa6, 0x51, 0x57, 0x57, 0x07, 0x9f, + 0xcf, 0xe7, 0x8c, 0x88, 0x88, 0xf8, 0x95, 0xd3, 0xe9, 0xf4, 0x75, 0x62, + 0x48, 0x66, 0x66, 0x26, 0xea, 0xeb, 0xeb, 0xa1, 0xd5, 0x6a, 0xfd, 0x36, + 0x9b, 0x6d, 0x56, 0x5c, 0x5c, 0x1c, 0x86, 0x0c, 0x19, 0x12, 0xf4, 0x92, + 0xf5, 0xf5, 0xf5, 0x50, 0x28, 0x14, 0x3f, 0x79, 0x1d, 0x78, 0xad, 0x56, + 0x8b, 0xac, 0xac, 0x2c, 0x64, 0x67, 0x67, 0xa3, 0xba, 0xba, 0x1a, 0x35, + 0x35, 0x35, 0x50, 0xab, 0xd5, 0xd0, 0x68, 0x34, 0x50, 0xb7, 0xc7, 0xb0, + 0xa4, 0xca, 0x3f, 0x5d, 0x31, 0x48, 0x8a, 0xa8, 0x56, 0x56, 0x56, 0x42, + 0xa9, 0x54, 0xe2, 0xb6, 0xdb, 0x6e, 0xc3, 0xa8, 0x51, 0xa3, 0x30, 0x78, + 0xf0, 0xe0, 0x01, 0x2b, 0x49, 0x4e, 0xd3, 0x34, 0x3c, 0x1e, 0x8f, 0x0c, + 0xbc, 0xee, 0xcb, 0x96, 0x0c, 0x9e, 0xe7, 0x51, 0x5a, 0x5a, 0x0a, 0xa5, + 0x52, 0xf9, 0x61, 0x5b, 0x5b, 0xdb, 0xd7, 0x41, 0xa6, 0xb0, 0xf4, 0x87, + 0x04, 0x6a, 0x53, 0xab, 0xd5, 0x4d, 0x3c, 0xcf, 0xdf, 0x5d, 0x59, 0x59, + 0xa9, 0x9e, 0x3b, 0x77, 0x6e, 0xa7, 0x93, 0x3b, 0x1b, 0x1b, 0x1b, 0x61, + 0x34, 0x1a, 0xbb, 0x2c, 0x38, 0x3c, 0xd0, 0x14, 0x16, 0x16, 0x86, 0x59, + 0xb3, 0x66, 0xc1, 0xe3, 0xf1, 0xc8, 0x50, 0x22, 0x49, 0x71, 0x6b, 0x34, + 0x1a, 0xf9, 0x04, 0x1f, 0x09, 0xb9, 0xaf, 0x50, 0x28, 0xe4, 0x02, 0x62, + 0x61, 0x61, 0x61, 0x30, 0x1a, 0x8d, 0xa8, 0xab, 0xab, 0x43, 0x78, 0x78, + 0x78, 0x9f, 0x8a, 0x00, 0x84, 0x4a, 0x09, 0x09, 0x09, 0xf8, 0xdf, 0xff, + 0xfd, 0xdf, 0x6e, 0x8f, 0xe1, 0xeb, 0x6e, 0xf5, 0x96, 0x96, 0x96, 0xc2, + 0xe7, 0xf3, 0xb9, 0x2d, 0x16, 0xcb, 0xc3, 0x6e, 0xb7, 0xbb, 0xb9, 0x4b, + 0x86, 0x00, 0x57, 0xea, 0x2b, 0x8e, 0x1e, 0x3d, 0xba, 0xad, 0xbe, 0xbe, + 0x7e, 0x82, 0xdd, 0x6e, 0x1f, 0x31, 0x7a, 0xf4, 0x68, 0xc4, 0xc6, 0xc6, + 0x76, 0xf2, 0x0f, 0x6a, 0x6a, 0x6a, 0x40, 0xd3, 0xf4, 0xbf, 0xad, 0x36, + 0xfc, 0xf8, 0xf1, 0xe3, 0x31, 0x6c, 0xd8, 0x30, 0x9c, 0x3a, 0x75, 0x2a, + 0x28, 0x26, 0x24, 0xc5, 0x99, 0xa4, 0xbd, 0x2d, 0x52, 0x1e, 0xa2, 0xe3, + 0x11, 0xa9, 0xd2, 0x6e, 0x57, 0x96, 0x65, 0x07, 0x04, 0x70, 0x7d, 0xb5, + 0xff, 0xb5, 0x77, 0xef, 0xde, 0x20, 0x34, 0x7c, 0x28, 0xab, 0xa3, 0xaa, + 0xaa, 0x0a, 0x2c, 0xcb, 0x9e, 0x98, 0x3b, 0x77, 0xee, 0x9f, 0x52, 0x53, + 0x53, 0x49, 0xc7, 0x84, 0x1f, 0x73, 0xb5, 0x67, 0xd9, 0x5e, 0xf7, 0xb6, + 0xc2, 0xe7, 0xf3, 0xfd, 0xbf, 0xb3, 0x67, 0xcf, 0x52, 0x77, 0xdd, 0x75, + 0x57, 0x27, 0x2f, 0x5c, 0x8a, 0xe1, 0xf7, 0xa7, 0x6e, 0x56, 0x7f, 0x29, + 0x3e, 0x3e, 0x1e, 0xa3, 0x47, 0x8f, 0xc6, 0xbe, 0x7d, 0xfb, 0xfa, 0x7c, + 0xaf, 0x42, 0xa1, 0x40, 0x6e, 0x6e, 0x2e, 0xae, 0xbb, 0xee, 0xba, 0x01, + 0x03, 0x81, 0x57, 0x57, 0x57, 0xe3, 0xec, 0xd9, 0xb3, 0x28, 0x2e, 0x2e, + 0x96, 0xeb, 0x76, 0xf5, 0x46, 0x0c, 0xc3, 0xa0, 0xba, 0xba, 0x1a, 0x2e, + 0x97, 0x0b, 0x09, 0x09, 0x09, 0x4b, 0x4e, 0x9c, 0x38, 0x51, 0x73, 0x75, + 0xf6, 0x95, 0xe9, 0xc6, 0xe5, 0xaf, 0x55, 0xab, 0xd5, 0x43, 0xdd, 0x6e, + 0x77, 0x86, 0xcf, 0xe7, 0x93, 0xc3, 0xd1, 0x57, 0x33, 0xc5, 0x6a, 0xb5, + 0xa2, 0xb9, 0xb9, 0x19, 0x71, 0x71, 0x71, 0x3f, 0xe9, 0xee, 0x59, 0x89, + 0x22, 0x23, 0x23, 0x91, 0x92, 0x92, 0x82, 0x43, 0x87, 0x0e, 0xf5, 0xab, + 0xd2, 0xdb, 0xe1, 0xc3, 0x87, 0xb1, 0x6c, 0xd9, 0xb2, 0x6b, 0xee, 0x47, + 0x4e, 0x4e, 0x0e, 0x8a, 0x8a, 0x8a, 0xc0, 0xb2, 0x2c, 0x8a, 0x8b, 0x8b, + 0xd1, 0xd8, 0xd8, 0xd8, 0xab, 0xb5, 0x46, 0x51, 0x14, 0xdc, 0x6e, 0x37, + 0x2a, 0x2a, 0x2a, 0xa0, 0xd3, 0xe9, 0x3e, 0x6a, 0x69, 0x69, 0xf9, 0x73, + 0x64, 0x64, 0x64, 0xa7, 0x53, 0x76, 0xba, 0x1c, 0x45, 0x8b, 0xc5, 0x02, + 0x9e, 0xe7, 0x73, 0x78, 0x9e, 0x7f, 0xa0, 0xa6, 0xa6, 0x46, 0x79, 0xfd, + 0xf5, 0xd7, 0x77, 0x99, 0xb4, 0x92, 0xce, 0xf4, 0x2b, 0x2b, 0x2b, 0x43, + 0x5c, 0x5c, 0xdc, 0x4f, 0x7a, 0x50, 0x64, 0xc7, 0x95, 0x52, 0x52, 0x52, + 0x82, 0xaa, 0xaa, 0xaa, 0x3e, 0x99, 0xac, 0x92, 0x4f, 0x45, 0x08, 0xe9, + 0xb7, 0x3e, 0xf1, 0xfb, 0xfd, 0x38, 0x79, 0xf2, 0x24, 0x6a, 0x6b, 0x6b, + 0x41, 0xb7, 0x87, 0xf1, 0x8b, 0x8a, 0x8a, 0x42, 0x62, 0x08, 0x21, 0x04, + 0x15, 0x15, 0x15, 0x08, 0x04, 0x02, 0x56, 0xa5, 0x52, 0xb9, 0x2c, 0x2e, + 0x2e, 0xce, 0xd9, 0x7e, 0xfe, 0x63, 0xef, 0x0c, 0xf1, 0x78, 0x3c, 0xe0, + 0x38, 0xce, 0xae, 0xd7, 0xeb, 0xb5, 0x4e, 0xa7, 0xf3, 0x7a, 0x9f, 0xcf, + 0x87, 0xc9, 0x93, 0x27, 0x77, 0x99, 0x03, 0xa0, 0xda, 0xf3, 0xd1, 0xe5, + 0xe5, 0xe5, 0x10, 0x04, 0x01, 0x66, 0xb3, 0xf9, 0x27, 0x3f, 0x5d, 0x21, + 0x33, 0x33, 0x13, 0xdb, 0xb7, 0x6f, 0x97, 0x9f, 0x1f, 0x2a, 0x49, 0x47, + 0xdf, 0xf5, 0xe7, 0x94, 0x83, 0xca, 0xca, 0x4a, 0x9c, 0x3a, 0x75, 0x0a, + 0x6d, 0x6d, 0x6d, 0xb2, 0x34, 0x90, 0x40, 0x1f, 0xbd, 0x31, 0x44, 0x0a, + 0x93, 0xd4, 0xd5, 0xd5, 0x41, 0xab, 0xd5, 0xbe, 0xee, 0x76, 0xbb, 0xbf, + 0xed, 0xce, 0x5f, 0xa1, 0x7b, 0xf1, 0x46, 0x7f, 0xab, 0x52, 0xa9, 0xf2, + 0xf7, 0xec, 0xd9, 0x83, 0xd3, 0xa7, 0x4f, 0x77, 0xfb, 0x50, 0x69, 0x50, + 0x2e, 0x5d, 0xba, 0x84, 0x03, 0x07, 0x0e, 0xf4, 0x88, 0x01, 0x1e, 0x08, + 0x32, 0x18, 0x0c, 0x98, 0x3f, 0x7f, 0x7e, 0x9f, 0x8f, 0x20, 0x22, 0x84, + 0xf4, 0x88, 0xe2, 0xef, 0x2e, 0x62, 0x7b, 0xfc, 0xf8, 0x71, 0x9c, 0x39, + 0x73, 0x46, 0x06, 0x31, 0x74, 0x6c, 0x2f, 0x14, 0x87, 0x95, 0x10, 0x82, + 0x92, 0x92, 0x12, 0xb0, 0x2c, 0x9b, 0xff, 0xd6, 0x5b, 0x6f, 0xbd, 0xd2, + 0xa3, 0x39, 0xdd, 0xdd, 0x17, 0xd2, 0xf1, 0xa1, 0x2a, 0x95, 0xea, 0x6e, + 0x8a, 0xa2, 0xbc, 0x6f, 0xbf, 0xfd, 0x36, 0x3c, 0x1e, 0x4f, 0x8f, 0xe6, + 0x1d, 0x4d, 0xd3, 0x70, 0xb9, 0x5c, 0x38, 0x70, 0xe0, 0x00, 0x4e, 0x9f, + 0x3e, 0x1d, 0x72, 0x48, 0xbe, 0x3f, 0x34, 0x6e, 0xdc, 0xb8, 0x3e, 0xe1, + 0xa1, 0xa4, 0x70, 0x45, 0x4c, 0x4c, 0x4c, 0xc8, 0xf7, 0x15, 0x14, 0x14, + 0xe0, 0x87, 0x1f, 0x7e, 0x40, 0x63, 0x63, 0x63, 0xb7, 0xc7, 0x92, 0xf7, + 0x36, 0x29, 0x28, 0x8a, 0xc2, 0xe5, 0xcb, 0x97, 0x21, 0x8a, 0xa2, 0x5f, + 0xad, 0x56, 0xff, 0xe6, 0xc1, 0x07, 0x1f, 0x14, 0x7a, 0xc2, 0x1f, 0x74, + 0xab, 0x89, 0x25, 0xd8, 0xe4, 0xc5, 0x8b, 0x17, 0x1b, 0x35, 0x1a, 0x4d, + 0x98, 0xcb, 0xe5, 0x9a, 0x5c, 0x55, 0x55, 0x85, 0xd9, 0xb3, 0x67, 0xf7, + 0xd8, 0x09, 0x69, 0xb6, 0x48, 0x91, 0x4c, 0xa9, 0x62, 0xe8, 0x40, 0x2b, + 0x7d, 0xa3, 0xd1, 0x88, 0x83, 0x07, 0x0f, 0xf6, 0x58, 0x59, 0xb4, 0xab, + 0x38, 0xd8, 0xeb, 0xaf, 0xbf, 0xde, 0xe3, 0xee, 0x58, 0x41, 0x10, 0xd0, + 0xd2, 0xd2, 0x82, 0x83, 0x07, 0x0f, 0xca, 0x05, 0xc8, 0x7a, 0xca, 0xbb, + 0xe4, 0xe6, 0xe6, 0x76, 0x09, 0x5e, 0x90, 0xc6, 0xa2, 0xb5, 0xb5, 0x15, + 0x0d, 0x0d, 0x0d, 0x50, 0xa9, 0x54, 0x9f, 0x7a, 0xbd, 0xde, 0xf7, 0xa5, + 0xb1, 0xe9, 0x33, 0x43, 0x00, 0xc8, 0x1b, 0x5a, 0xe6, 0xcf, 0x9f, 0x7f, + 0xa0, 0xb2, 0xb2, 0x32, 0xbb, 0xaa, 0xaa, 0x6a, 0xa8, 0xdb, 0xed, 0xc6, + 0xf8, 0xf1, 0xe3, 0x7b, 0x0d, 0x61, 0x48, 0x88, 0x8c, 0xfa, 0xfa, 0x7a, + 0x54, 0x57, 0x57, 0xcb, 0x7b, 0xef, 0x06, 0xe2, 0x1c, 0x27, 0x29, 0x51, + 0x44, 0x51, 0x14, 0x8e, 0x1e, 0x3d, 0xda, 0x6b, 0x9b, 0x52, 0x52, 0x6c, + 0xfd, 0xfa, 0xf5, 0xdd, 0x56, 0xd5, 0x0e, 0x04, 0x02, 0x57, 0x52, 0xc8, + 0x79, 0x79, 0x28, 0x2e, 0x2e, 0x86, 0x28, 0x8a, 0x21, 0xe9, 0xc2, 0xdc, + 0xdc, 0xdc, 0x6e, 0x01, 0x0c, 0x6e, 0xb7, 0x1b, 0x25, 0x25, 0x25, 0x50, + 0xa9, 0x54, 0xfb, 0xfd, 0x7e, 0xff, 0x6d, 0x21, 0xe9, 0xb9, 0x50, 0x2e, + 0x6a, 0x6c, 0x6c, 0x24, 0x2a, 0x95, 0x6a, 0x67, 0x20, 0x10, 0xb8, 0xfb, + 0xf2, 0xe5, 0xcb, 0x86, 0x21, 0x43, 0x86, 0x60, 0xd0, 0xa0, 0x41, 0x21, + 0xc3, 0x4f, 0xa5, 0x59, 0x57, 0x59, 0x59, 0x09, 0x9b, 0xcd, 0x86, 0xb0, + 0xb0, 0x30, 0x84, 0xb2, 0x49, 0xa8, 0x37, 0x4a, 0x4b, 0x4b, 0x83, 0xd7, + 0xeb, 0x45, 0x51, 0x51, 0x51, 0x97, 0xc9, 0x33, 0x29, 0x57, 0x63, 0x30, + 0x18, 0xb0, 0x7e, 0xfd, 0xfa, 0x4e, 0x7b, 0xff, 0x44, 0x51, 0x84, 0xcf, + 0xe7, 0x43, 0x51, 0x51, 0x11, 0xce, 0x9d, 0x3b, 0x87, 0xba, 0xba, 0x3a, + 0xd9, 0xf1, 0x0c, 0xd5, 0x58, 0xc8, 0xcb, 0xcb, 0xeb, 0x92, 0x21, 0x82, + 0x20, 0xa0, 0xa8, 0xa8, 0x08, 0x00, 0xaa, 0x2c, 0x16, 0xcb, 0x5c, 0x97, + 0xcb, 0xe5, 0x09, 0xc9, 0x1a, 0xec, 0xcb, 0x00, 0x44, 0x45, 0x45, 0x8d, + 0x69, 0x6e, 0x6e, 0xce, 0x53, 0x28, 0x14, 0xf8, 0xfd, 0xef, 0x7f, 0x8f, + 0xe1, 0xc3, 0x87, 0x87, 0xc4, 0x94, 0xae, 0x06, 0xc9, 0x68, 0x34, 0xc2, + 0x62, 0xb1, 0x20, 0x39, 0x39, 0xf9, 0x9a, 0x0f, 0xdb, 0x3a, 0x71, 0xe2, + 0x04, 0x3e, 0xfa, 0xe8, 0x23, 0xd4, 0xd7, 0xd7, 0xcb, 0x03, 0x23, 0x8a, + 0x22, 0x12, 0x13, 0x13, 0x71, 0xfb, 0xed, 0xb7, 0x63, 0xfa, 0xf4, 0xe9, + 0x41, 0xe1, 0xf5, 0x40, 0x20, 0x80, 0xb2, 0xb2, 0x32, 0x34, 0x34, 0x34, + 0xc0, 0x6e, 0xb7, 0x87, 0x04, 0x34, 0xef, 0x4e, 0x0a, 0x7c, 0xf6, 0xd9, + 0x67, 0x28, 0x29, 0x29, 0x09, 0x9a, 0x5c, 0x0c, 0xc3, 0x20, 0x3f, 0x3f, + 0x1f, 0x3e, 0x9f, 0x4f, 0x08, 0x0f, 0x0f, 0xbf, 0xc1, 0x6a, 0xb5, 0x1e, + 0x99, 0x32, 0x65, 0x0a, 0x7e, 0xfc, 0xf1, 0xc7, 0x81, 0x63, 0xc8, 0x90, + 0x21, 0x43, 0x50, 0x5e, 0x5e, 0x0e, 0x93, 0xc9, 0xb4, 0xd0, 0xe1, 0x70, + 0xec, 0xd0, 0x6a, 0xb5, 0x8a, 0x37, 0xdf, 0x7c, 0x13, 0xb1, 0xb1, 0xb1, + 0x7d, 0x66, 0x4a, 0xc7, 0x97, 0x0f, 0x04, 0x02, 0x30, 0x1a, 0x8d, 0x18, + 0x34, 0x68, 0x90, 0x7c, 0x1e, 0xa1, 0x4a, 0xa5, 0x92, 0x71, 0x4f, 0x7d, + 0x19, 0xa8, 0xfa, 0xfa, 0x7a, 0x94, 0x97, 0x97, 0x43, 0xa1, 0x50, 0x60, + 0xf8, 0xf0, 0xe1, 0x30, 0x99, 0x4c, 0x72, 0x32, 0xcb, 0xe3, 0xf1, 0xc0, + 0x66, 0xb3, 0xa1, 0xb2, 0xb2, 0x12, 0xcd, 0xcd, 0xcd, 0x72, 0x31, 0xcf, + 0x8e, 0xfd, 0xe9, 0x18, 0x92, 0xe9, 0xf8, 0xbb, 0x3b, 0x62, 0x59, 0x16, + 0xdb, 0xb7, 0x6f, 0x47, 0x6e, 0x6e, 0xae, 0xac, 0x23, 0xa5, 0x42, 0xd1, + 0x2e, 0x97, 0x8b, 0x37, 0x18, 0x0c, 0x0f, 0x38, 0x9d, 0xce, 0xbf, 0x44, + 0x47, 0x47, 0x87, 0x74, 0x00, 0x40, 0x7f, 0x56, 0x08, 0x9a, 0x9a, 0x9a, + 0xa0, 0xd3, 0xe9, 0x1e, 0x73, 0xbb, 0xdd, 0x6f, 0x87, 0x85, 0x85, 0xe1, + 0xa5, 0x97, 0x5e, 0x42, 0x4a, 0x4a, 0x4a, 0x48, 0xa6, 0xa4, 0x4a, 0xa5, + 0x82, 0x56, 0xab, 0x45, 0x63, 0x63, 0x23, 0xea, 0xeb, 0xeb, 0xe1, 0x70, + 0x38, 0xc0, 0xf3, 0x3c, 0x14, 0x0a, 0x85, 0xcc, 0x94, 0xc8, 0xc8, 0x48, + 0x70, 0x1c, 0x07, 0x85, 0x42, 0x21, 0x07, 0x0f, 0xa5, 0x10, 0xbc, 0x52, + 0xa9, 0x84, 0x42, 0xa1, 0x08, 0x12, 0x77, 0x52, 0x06, 0x91, 0xe3, 0x38, + 0xf9, 0xc7, 0xeb, 0xf5, 0xc2, 0xeb, 0xf5, 0xca, 0x07, 0x05, 0xfb, 0xfd, + 0x7e, 0x04, 0x02, 0x01, 0x39, 0x0c, 0x2f, 0xdd, 0x2b, 0xe9, 0xb4, 0xda, + 0xda, 0x5a, 0x34, 0x34, 0x34, 0xc0, 0xe5, 0x72, 0xc9, 0x35, 0x89, 0x23, + 0x22, 0x22, 0x90, 0x98, 0x98, 0x08, 0x9d, 0x4e, 0x27, 0xf7, 0xf3, 0xea, + 0xc9, 0xa1, 0x50, 0x28, 0x70, 0xf8, 0xf0, 0x61, 0x1c, 0x38, 0x70, 0x40, + 0x6e, 0xb7, 0xb8, 0xb8, 0x18, 0x76, 0xbb, 0x1d, 0x1a, 0x8d, 0xe6, 0x49, + 0xb7, 0xdb, 0xfd, 0xa7, 0x88, 0x88, 0x08, 0x74, 0x3c, 0x38, 0x72, 0x40, + 0x19, 0x02, 0x5c, 0x39, 0x00, 0xde, 0x6e, 0xb7, 0x23, 0x22, 0x22, 0xe2, + 0x49, 0xab, 0xd5, 0xfa, 0x86, 0x5e, 0xaf, 0xc7, 0x1f, 0xff, 0xf8, 0x47, + 0x24, 0x24, 0x24, 0x74, 0x7b, 0x06, 0xa0, 0x64, 0xcf, 0x1f, 0x3b, 0x76, + 0x0c, 0xdf, 0x7e, 0xfb, 0xad, 0x1c, 0x07, 0xeb, 0xb8, 0xb2, 0x18, 0x86, + 0x81, 0x42, 0xa1, 0x40, 0x72, 0x72, 0x32, 0x16, 0x2f, 0x5e, 0x8c, 0x8c, + 0x8c, 0x0c, 0x39, 0x65, 0x2b, 0xad, 0x94, 0xab, 0x7f, 0x3a, 0xea, 0x02, + 0x49, 0x14, 0x76, 0x6c, 0xb3, 0xab, 0x15, 0x26, 0x15, 0x47, 0x70, 0xb9, + 0x5c, 0xd8, 0xbd, 0x7b, 0x37, 0xf6, 0xef, 0xdf, 0x8f, 0xb6, 0xb6, 0x36, + 0x70, 0x1c, 0x17, 0x74, 0xaf, 0x94, 0x0a, 0x1e, 0x39, 0x72, 0x24, 0x96, + 0x2e, 0x5d, 0x8a, 0xa4, 0xa4, 0x24, 0x30, 0x0c, 0xd3, 0x29, 0xd0, 0xda, + 0xd8, 0xd8, 0x88, 0xad, 0x5b, 0xb7, 0x82, 0xe3, 0x38, 0x94, 0x94, 0x94, + 0xc0, 0x6e, 0xb7, 0x43, 0xab, 0xd5, 0xae, 0xf2, 0x78, 0x3c, 0x1f, 0x48, + 0x63, 0xd5, 0x27, 0xe9, 0xd1, 0x1f, 0x99, 0x1d, 0x13, 0x13, 0x83, 0x86, + 0x86, 0x06, 0x68, 0xb5, 0xda, 0xc7, 0x3d, 0x1e, 0xcf, 0x5b, 0x7a, 0xbd, + 0x1e, 0xcf, 0x3d, 0xf7, 0x1c, 0xc6, 0x8c, 0x19, 0x13, 0x84, 0xe6, 0x60, + 0x59, 0x16, 0xad, 0xad, 0xad, 0xd8, 0xbc, 0x79, 0x33, 0xce, 0x9d, 0x3b, + 0x27, 0xc7, 0x6d, 0x18, 0x86, 0x91, 0x6b, 0xe8, 0x4a, 0x4a, 0xdf, 0xef, + 0xf7, 0x07, 0x85, 0xb1, 0xa5, 0x5c, 0xfe, 0xbd, 0xf7, 0xde, 0x0b, 0x85, + 0x42, 0xd1, 0xa7, 0x8c, 0x61, 0x4f, 0x22, 0xa6, 0xaa, 0xaa, 0x0a, 0x5b, + 0xb6, 0x6c, 0x41, 0x7e, 0x7e, 0xbe, 0x6c, 0xbe, 0x2b, 0x14, 0x0a, 0xe8, + 0x74, 0x3a, 0x28, 0x95, 0x4a, 0x50, 0x14, 0x05, 0x9e, 0xe7, 0xe1, 0xf5, + 0x7a, 0x83, 0xe2, 0x4c, 0x31, 0x31, 0x31, 0x98, 0x3f, 0x7f, 0x3e, 0x16, + 0x2f, 0x5e, 0x1c, 0x94, 0x87, 0x61, 0x59, 0x16, 0x9f, 0x7e, 0xfa, 0x29, + 0x76, 0xed, 0xda, 0x05, 0xb7, 0xdb, 0x0d, 0x8d, 0x46, 0xf3, 0x92, 0xc7, + 0xe3, 0x79, 0x45, 0xa3, 0xd1, 0xc8, 0xc9, 0xab, 0x9f, 0x9c, 0x21, 0x92, + 0xb7, 0xec, 0x74, 0x3a, 0x61, 0x30, 0x18, 0x7e, 0xed, 0x72, 0xb9, 0xde, + 0xa3, 0x28, 0x4a, 0xf9, 0xf4, 0xd3, 0x4f, 0x23, 0x3b, 0x3b, 0x5b, 0xc6, + 0xc5, 0x1e, 0x3a, 0x74, 0x08, 0xef, 0xbd, 0xf7, 0x1e, 0x80, 0x2b, 0xf9, + 0xf3, 0xb0, 0xb0, 0x30, 0x44, 0x46, 0x46, 0x42, 0xa7, 0xd3, 0x05, 0x9d, + 0xaa, 0xd9, 0x71, 0x26, 0x3b, 0x1c, 0x0e, 0xb4, 0xb4, 0xb4, 0xc8, 0xf0, + 0x4b, 0x8d, 0x46, 0x83, 0x67, 0x9e, 0x79, 0x06, 0x99, 0x99, 0x99, 0x7d, + 0xf2, 0xb0, 0xaf, 0x5e, 0x15, 0x7e, 0xbf, 0x1f, 0x3b, 0x76, 0xec, 0xc0, + 0x3f, 0xfe, 0xf1, 0x0f, 0xf9, 0xe4, 0xce, 0xf0, 0xf0, 0x70, 0x58, 0x2c, + 0x16, 0xa8, 0xd5, 0xea, 0x2e, 0xfb, 0x43, 0x08, 0x81, 0xcd, 0x66, 0x43, + 0x6b, 0x6b, 0xab, 0x0c, 0xbc, 0x88, 0x8b, 0x8b, 0xc3, 0xb3, 0xcf, 0x3e, + 0x8b, 0xc1, 0x83, 0x07, 0x03, 0x00, 0x4e, 0x9e, 0x3c, 0x89, 0xd7, 0x5f, + 0x7f, 0x1d, 0x82, 0x20, 0x04, 0xb4, 0x5a, 0xed, 0x6f, 0xdd, 0x6e, 0xf7, + 0x06, 0xa3, 0xd1, 0xd8, 0xef, 0x68, 0xc5, 0x35, 0x4d, 0xb9, 0xf0, 0xf0, + 0x70, 0xd8, 0x6c, 0x36, 0xe8, 0xf5, 0xfa, 0x05, 0x5e, 0xaf, 0xf7, 0x1b, + 0x51, 0x14, 0x99, 0x39, 0x73, 0xe6, 0xe0, 0xee, 0xbb, 0xef, 0xc6, 0xbb, + 0xef, 0xbe, 0x8b, 0xd3, 0xa7, 0x4f, 0x83, 0x61, 0x18, 0x24, 0x26, 0x26, + 0xc2, 0x64, 0x32, 0x81, 0x65, 0xd9, 0x5e, 0xcf, 0x0f, 0x91, 0x18, 0xc3, + 0x71, 0x1c, 0xac, 0x56, 0x2b, 0x6a, 0x6b, 0x6b, 0xc1, 0x30, 0x0c, 0xe6, + 0xcd, 0x9b, 0x87, 0x5f, 0xff, 0xfa, 0xd7, 0x5d, 0xa2, 0x51, 0x7a, 0x33, + 0xbb, 0xad, 0x56, 0x2b, 0x5e, 0x7d, 0xf5, 0x55, 0x94, 0x95, 0x95, 0x41, + 0xa5, 0x52, 0x21, 0x31, 0x31, 0x11, 0x7a, 0xbd, 0x5e, 0x3e, 0x1f, 0x37, + 0x14, 0x03, 0xc4, 0xef, 0xf7, 0xa3, 0xa5, 0xa5, 0x05, 0x8d, 0x8d, 0x8d, + 0x50, 0xab, 0xd5, 0x58, 0xb2, 0x64, 0x09, 0x5a, 0x5b, 0x5b, 0xf1, 0xfd, + 0xf7, 0xdf, 0x83, 0xa2, 0x28, 0xaf, 0x46, 0xa3, 0x59, 0xe6, 0x72, 0xb9, + 0xbe, 0x91, 0x26, 0x6a, 0x7f, 0xe9, 0x9a, 0x4f, 0x83, 0xb7, 0x58, 0x2c, + 0x68, 0x69, 0x69, 0x41, 0x5c, 0x5c, 0xdc, 0xa0, 0xc6, 0xc6, 0xc6, 0xc3, + 0x82, 0x20, 0x24, 0x49, 0xb2, 0x5f, 0xa3, 0xd1, 0x60, 0xf8, 0xf0, 0xe1, + 0x9d, 0x64, 0x6f, 0x5f, 0x23, 0xb4, 0x25, 0x25, 0x25, 0x08, 0x04, 0x02, + 0xb8, 0xf5, 0xd6, 0x5b, 0xb1, 0x62, 0xc5, 0x8a, 0x90, 0x63, 0x58, 0x52, + 0x6e, 0xfd, 0xf1, 0xc7, 0x1f, 0x87, 0xcd, 0x66, 0x43, 0x78, 0x78, 0xb8, + 0x9c, 0x63, 0xef, 0x0f, 0xd1, 0x34, 0x0d, 0x87, 0xc3, 0x81, 0xb2, 0xb2, + 0x32, 0xb9, 0x0d, 0x86, 0x61, 0x2a, 0xc2, 0xc2, 0xc2, 0xe6, 0xb6, 0xb6, + 0xb6, 0x5e, 0xee, 0xab, 0x02, 0xef, 0xb7, 0x63, 0xd8, 0x13, 0x79, 0x3c, + 0x1e, 0x24, 0x25, 0x25, 0xa1, 0xba, 0xba, 0xda, 0x3e, 0x7a, 0xf4, 0xe8, + 0xbf, 0x5a, 0xad, 0xd6, 0x25, 0x82, 0x20, 0x84, 0x1b, 0x0c, 0x06, 0xb9, + 0x54, 0x6a, 0x77, 0x83, 0x15, 0xca, 0x4c, 0x97, 0x72, 0xf8, 0x4e, 0xa7, + 0x13, 0xf9, 0xf9, 0xf9, 0xf0, 0xfb, 0xfd, 0x18, 0x37, 0x6e, 0x5c, 0xaf, + 0x0c, 0x96, 0xa0, 0x42, 0x8f, 0x3d, 0xf6, 0x18, 0x9a, 0x9b, 0x9b, 0x11, + 0x1d, 0x1d, 0x8d, 0xc4, 0xc4, 0xc4, 0x90, 0x26, 0x46, 0x77, 0x7d, 0x93, + 0xf6, 0x1e, 0x9a, 0x4c, 0x26, 0x58, 0xad, 0x56, 0x10, 0x42, 0xa0, 0xd5, + 0x6a, 0x5f, 0xb1, 0xdb, 0xed, 0x3b, 0xe3, 0xe2, 0xe2, 0xd0, 0xd4, 0xd4, + 0x74, 0xcd, 0x11, 0x88, 0x01, 0x09, 0x30, 0x49, 0xa1, 0x64, 0xb7, 0xdb, + 0xfd, 0xa0, 0xcf, 0xe7, 0xbb, 0x43, 0xa7, 0xd3, 0x61, 0xc4, 0x88, 0x11, + 0x3d, 0xe2, 0xa1, 0xea, 0xeb, 0xeb, 0xe1, 0x76, 0xbb, 0x43, 0x72, 0x0a, + 0x69, 0x9a, 0x86, 0xc9, 0x64, 0x82, 0xcd, 0x66, 0xc3, 0xc5, 0x8b, 0x17, + 0x71, 0xdd, 0x75, 0xd7, 0x21, 0x32, 0x32, 0xb2, 0xd7, 0x40, 0xe7, 0xba, + 0x75, 0xeb, 0x70, 0xe9, 0xd2, 0x25, 0x98, 0xcd, 0x66, 0x0c, 0x1a, 0x34, + 0x28, 0x24, 0x66, 0x70, 0x1c, 0x87, 0xca, 0xca, 0x4a, 0x79, 0x6b, 0x5a, + 0x77, 0x93, 0x44, 0x62, 0x8a, 0x20, 0x08, 0xbf, 0x30, 0x99, 0x4c, 0x7f, + 0x6f, 0x6e, 0x6e, 0xb6, 0x0f, 0xc4, 0x58, 0x0e, 0x48, 0xe2, 0xa2, 0x5d, + 0x51, 0xc7, 0x7a, 0x3c, 0x9e, 0x75, 0x2c, 0xcb, 0x22, 0x29, 0x29, 0xa9, + 0xc7, 0xb3, 0xcd, 0xa5, 0x42, 0xc2, 0xa1, 0x62, 0x98, 0x24, 0xa3, 0x60, + 0xf0, 0xe0, 0xc1, 0x10, 0x04, 0x41, 0xae, 0x38, 0xd4, 0xdd, 0x0a, 0x63, + 0x18, 0x06, 0xe7, 0xcf, 0x9f, 0x47, 0x4e, 0x4e, 0x0e, 0x94, 0x4a, 0x25, + 0x12, 0x12, 0x12, 0x42, 0x76, 0x5e, 0xa5, 0x63, 0x8a, 0xca, 0xcb, 0xcb, + 0xbb, 0x35, 0x22, 0xda, 0xd1, 0xea, 0xd2, 0x29, 0x07, 0xa6, 0x40, 0x20, + 0xb0, 0x41, 0xb2, 0xc4, 0x7e, 0x76, 0x86, 0xc4, 0xc6, 0xc6, 0x4a, 0x47, + 0x4e, 0xfc, 0x56, 0x14, 0x45, 0x7d, 0x74, 0x74, 0x74, 0x8f, 0x99, 0x43, + 0xbf, 0xdf, 0x2f, 0x1f, 0x51, 0xa1, 0xd7, 0xeb, 0x43, 0x8e, 0x67, 0x11, + 0x42, 0x10, 0x1e, 0x1e, 0x8e, 0x88, 0x88, 0x08, 0x34, 0x36, 0x36, 0x62, + 0xdb, 0xb6, 0x6d, 0xdd, 0x46, 0x90, 0x29, 0x8a, 0x92, 0x77, 0x66, 0x49, + 0xfe, 0x43, 0x5f, 0x18, 0xcf, 0xb2, 0x2c, 0x04, 0x41, 0x40, 0x69, 0x69, + 0x69, 0xb7, 0xa1, 0x7a, 0x42, 0x08, 0xcc, 0x66, 0x33, 0x0c, 0x06, 0x03, + 0x3c, 0x1e, 0xcf, 0x92, 0xf8, 0xf8, 0xf8, 0x31, 0x0d, 0x0d, 0x0d, 0x3f, + 0x3f, 0x43, 0xea, 0xeb, 0xeb, 0x91, 0x95, 0x95, 0x65, 0x71, 0xbb, 0xdd, + 0x0f, 0x4b, 0xf5, 0xd4, 0x7b, 0x12, 0x55, 0x35, 0x35, 0x35, 0xf2, 0x6c, + 0x95, 0x8e, 0x06, 0x0a, 0x95, 0x24, 0x1c, 0x2e, 0x4d, 0xd3, 0x38, 0x7c, + 0xf8, 0x70, 0x97, 0x76, 0xbe, 0xb4, 0xa3, 0x2b, 0x2f, 0x2f, 0x0f, 0x61, + 0x61, 0x61, 0x30, 0x18, 0x0c, 0x7d, 0x7a, 0x06, 0xc3, 0x30, 0x72, 0xf4, + 0xd8, 0xe3, 0xf1, 0xc8, 0x65, 0xc4, 0xbb, 0x63, 0x7c, 0x74, 0x74, 0xb4, + 0xe4, 0x20, 0x6e, 0xfc, 0x8f, 0x11, 0x59, 0x05, 0x05, 0x05, 0xab, 0x24, + 0xd1, 0xd5, 0x53, 0x56, 0xd1, 0xe5, 0x72, 0xc9, 0x9e, 0xab, 0x74, 0xbc, + 0x5c, 0x5f, 0xe3, 0x60, 0x12, 0x26, 0xab, 0xb9, 0xb9, 0x19, 0xb5, 0xb5, + 0xb5, 0x5d, 0x0e, 0xd6, 0xde, 0xbd, 0x7b, 0xe5, 0x50, 0x4f, 0x5f, 0xdb, + 0x97, 0x42, 0xfb, 0x12, 0xb5, 0xb4, 0xb4, 0x74, 0x2b, 0x7e, 0x09, 0x21, + 0xb2, 0x43, 0x29, 0x8a, 0x62, 0xba, 0xc9, 0x64, 0x4a, 0xb8, 0x56, 0xb8, + 0xed, 0x35, 0x33, 0x24, 0x2b, 0x2b, 0x8b, 0xe5, 0x38, 0x6e, 0x82, 0x84, + 0x99, 0xed, 0xa9, 0xf3, 0x1d, 0x97, 0x34, 0xc3, 0x30, 0x7d, 0xce, 0xf8, + 0x49, 0x8c, 0xb4, 0x58, 0x2c, 0x72, 0x21, 0x9b, 0xab, 0x27, 0x00, 0xcf, + 0xf3, 0x28, 0x28, 0x28, 0x80, 0x42, 0xa1, 0xe8, 0x17, 0xe8, 0x42, 0x72, + 0x1a, 0x25, 0x92, 0xc0, 0xd3, 0x3d, 0xad, 0xa8, 0xf6, 0x89, 0x15, 0x4e, + 0x08, 0x49, 0x69, 0x0f, 0xb9, 0xff, 0x7c, 0x0c, 0xb9, 0x74, 0xe9, 0x92, + 0x9e, 0x10, 0x32, 0xb4, 0xb7, 0xaa, 0x74, 0x3c, 0xcf, 0xcb, 0x07, 0x2d, + 0x4a, 0x88, 0x8d, 0xfe, 0xe4, 0x43, 0xa4, 0x2d, 0x12, 0xc0, 0x95, 0x5a, + 0x88, 0x57, 0xc7, 0xb7, 0xdc, 0x6e, 0x37, 0x5c, 0x2e, 0x97, 0x1c, 0x84, + 0xec, 0x0f, 0x49, 0x8c, 0x94, 0x8e, 0xbf, 0x73, 0x38, 0x1c, 0x3d, 0x9a, + 0xe8, 0x92, 0xa5, 0x28, 0x08, 0x42, 0xf6, 0xb5, 0x8e, 0x27, 0x7b, 0xad, + 0x0d, 0x08, 0x82, 0xa0, 0x26, 0x84, 0x44, 0xf4, 0x36, 0xc0, 0xd2, 0x5e, + 0x0e, 0x83, 0xc1, 0x00, 0x97, 0xcb, 0x05, 0x86, 0x61, 0xfa, 0x1d, 0x9b, + 0x92, 0x0a, 0xae, 0xe5, 0xe4, 0xe4, 0x60, 0xe7, 0xce, 0x9d, 0x72, 0xa8, + 0x9e, 0xe3, 0x38, 0x39, 0xcc, 0x71, 0x2d, 0x50, 0x57, 0x95, 0x4a, 0x25, + 0x33, 0x58, 0xa5, 0x52, 0xa1, 0xb5, 0xb5, 0x55, 0xde, 0x2d, 0xdc, 0x15, + 0x49, 0x78, 0x61, 0x9e, 0xe7, 0xd3, 0x7f, 0x76, 0x86, 0xf8, 0xfd, 0x7e, + 0x56, 0x14, 0x45, 0xa6, 0xa7, 0xc1, 0xa5, 0x69, 0x5a, 0xd6, 0x1d, 0x6a, + 0xb5, 0x3a, 0x88, 0x21, 0xfd, 0xdd, 0x5d, 0xab, 0x50, 0x28, 0x50, 0x53, + 0x53, 0x83, 0x8f, 0x3e, 0xfa, 0xa8, 0xd3, 0x22, 0x02, 0x40, 0x49, 0x80, + 0xec, 0xfe, 0xac, 0x40, 0x85, 0x42, 0x21, 0x07, 0x19, 0xc3, 0xc2, 0xc2, + 0xd0, 0xdc, 0xdc, 0x0c, 0xbf, 0xdf, 0xdf, 0xa5, 0x08, 0x94, 0xae, 0x6f, + 0x17, 0x77, 0x51, 0x3f, 0x3b, 0x43, 0x18, 0x86, 0x11, 0xdb, 0x0f, 0x29, + 0xee, 0x95, 0x21, 0x1d, 0x99, 0x20, 0xcd, 0xea, 0xfe, 0x30, 0x44, 0x2a, + 0xd1, 0xc1, 0x30, 0x4c, 0x81, 0x4a, 0xa5, 0x7a, 0x8c, 0xe7, 0x79, 0x25, + 0x75, 0x65, 0xf4, 0x05, 0x8a, 0xa2, 0xa2, 0xfd, 0x7e, 0xff, 0xc7, 0x3c, + 0xcf, 0x2b, 0xae, 0x25, 0x2a, 0x2c, 0x31, 0x44, 0x1a, 0x6c, 0x87, 0xc3, + 0x81, 0xa8, 0xa8, 0xa8, 0x4e, 0xfd, 0x95, 0xae, 0x93, 0x02, 0x17, 0x3f, + 0xbb, 0x95, 0x65, 0x30, 0x18, 0x1c, 0x0c, 0xc3, 0x54, 0x48, 0xe1, 0xf3, + 0xab, 0x83, 0x72, 0x1d, 0x63, 0x52, 0x1d, 0xc5, 0x5a, 0x5f, 0x14, 0xfa, + 0xd5, 0xb9, 0x8f, 0xca, 0xca, 0x4a, 0x10, 0x42, 0xa0, 0x56, 0xab, 0x3f, + 0xf1, 0x78, 0x3c, 0x07, 0x02, 0x81, 0xc0, 0x6e, 0xbf, 0xdf, 0xff, 0xbd, + 0xdf, 0xef, 0xdf, 0x6b, 0x32, 0x99, 0xbe, 0xa6, 0x69, 0xba, 0xc6, 0x6e, + 0xb7, 0xc3, 0xe9, 0x74, 0xf6, 0x9b, 0xe1, 0x57, 0x4f, 0x9c, 0xab, 0x15, + 0x7b, 0xc7, 0x54, 0xb1, 0xb4, 0x73, 0x80, 0x65, 0xd9, 0x5d, 0xd7, 0x3c, + 0xc1, 0x07, 0x20, 0x96, 0x15, 0x30, 0x1a, 0x8d, 0xb5, 0x81, 0x40, 0xe0, + 0x4e, 0xab, 0xd5, 0xda, 0x69, 0xbf, 0x77, 0x47, 0x0b, 0x4b, 0xb2, 0x7c, + 0xdc, 0x6e, 0x37, 0xf4, 0x7a, 0x7d, 0xc7, 0x6a, 0x9c, 0x9d, 0xe2, 0x47, + 0x52, 0xb2, 0x49, 0x2a, 0x1d, 0xe5, 0xf1, 0x78, 0xd0, 0xd4, 0xd4, 0x84, + 0x9a, 0x9a, 0x1a, 0x49, 0x69, 0x9f, 0x57, 0xab, 0xd5, 0x4f, 0xf8, 0x7c, + 0x3e, 0xcf, 0xec, 0xd9, 0xb3, 0x51, 0x56, 0x56, 0x26, 0x85, 0x6f, 0xfc, + 0x26, 0x93, 0xa9, 0xd8, 0xef, 0xf7, 0x2f, 0xb7, 0x5a, 0xad, 0x70, 0x38, + 0x1c, 0xb2, 0xe5, 0x77, 0x35, 0x73, 0x3a, 0xa6, 0x89, 0x3b, 0xfe, 0xb0, + 0x2c, 0x8b, 0xfa, 0xfa, 0x7a, 0x88, 0xa2, 0x08, 0xbd, 0x5e, 0x2f, 0xd7, + 0x47, 0xb4, 0x58, 0x2c, 0x32, 0xd0, 0xce, 0xef, 0xf7, 0xc3, 0x66, 0xb3, + 0xa1, 0xba, 0xba, 0x1a, 0x6e, 0xb7, 0x1b, 0x0a, 0x85, 0xa2, 0xd0, 0x68, + 0x34, 0x3e, 0xa6, 0x56, 0xab, 0x03, 0xfd, 0xc9, 0x83, 0x0c, 0x18, 0x49, + 0x27, 0xf2, 0x98, 0x4c, 0xa6, 0x99, 0x2c, 0xcb, 0xe6, 0xb7, 0x97, 0x7b, + 0x22, 0x00, 0x08, 0xcb, 0xb2, 0x44, 0xa5, 0x52, 0x11, 0x8d, 0x46, 0x43, + 0x00, 0x10, 0x8a, 0xa2, 0x08, 0x4d, 0xd3, 0xf2, 0x69, 0x6c, 0x06, 0x83, + 0x81, 0xe8, 0xf5, 0x7a, 0xa2, 0xd3, 0xe9, 0xe4, 0x1f, 0xad, 0x56, 0x4b, + 0xb4, 0x5a, 0x2d, 0x51, 0xab, 0xd5, 0x44, 0xa9, 0x54, 0x06, 0x9d, 0xd2, + 0x06, 0x80, 0xa7, 0x69, 0xba, 0x46, 0xad, 0x56, 0xbf, 0x37, 0x74, 0xe8, + 0x50, 0x53, 0x4f, 0xfd, 0x89, 0x88, 0x88, 0xc8, 0x54, 0x28, 0x14, 0xc7, + 0x29, 0x8a, 0x6a, 0xed, 0x70, 0x7f, 0xd0, 0x29, 0x70, 0x5a, 0xad, 0x36, + 0xe8, 0xd9, 0x3a, 0x9d, 0x8e, 0xe8, 0xf5, 0x7a, 0x62, 0x30, 0x18, 0xe4, + 0xd3, 0xdb, 0xa4, 0xfe, 0xd2, 0x34, 0x4d, 0x34, 0x1a, 0x0d, 0x51, 0x2a, + 0x95, 0xf2, 0x67, 0xed, 0x9f, 0xdb, 0xd4, 0x6a, 0xf5, 0xe7, 0x23, 0x46, + 0x8c, 0x30, 0x0f, 0xc4, 0x78, 0x52, 0x03, 0xd1, 0x88, 0x94, 0xaa, 0x8c, + 0x8f, 0x8f, 0xd7, 0xd8, 0x6c, 0xb6, 0x61, 0x0c, 0xc3, 0xa4, 0x73, 0x1c, + 0x37, 0x89, 0x10, 0x32, 0x52, 0x14, 0xc5, 0x44, 0x9a, 0xa6, 0xa3, 0x04, + 0x41, 0x50, 0x53, 0x14, 0xa5, 0x96, 0x8a, 0x07, 0x77, 0x5c, 0xfa, 0x92, + 0xd5, 0xc4, 0x30, 0x0c, 0x38, 0x8e, 0xf3, 0xd0, 0x34, 0xed, 0xa3, 0x69, + 0xda, 0x29, 0x8a, 0x62, 0x13, 0xc3, 0x30, 0x75, 0x14, 0x45, 0x5d, 0x64, + 0x18, 0xe6, 0x8c, 0x20, 0x08, 0xe5, 0x5a, 0xad, 0xb6, 0xa2, 0xa5, 0xa5, + 0xa5, 0x55, 0xf2, 0x7b, 0xba, 0x0a, 0x77, 0x9b, 0xcd, 0x66, 0xb4, 0xb6, + 0xb6, 0x22, 0x29, 0x29, 0x89, 0xb1, 0xd9, 0x6c, 0x89, 0x81, 0x40, 0x20, + 0x91, 0x65, 0xd9, 0x34, 0x8e, 0xe3, 0xc6, 0x89, 0xa2, 0x38, 0x94, 0x10, + 0x12, 0x4b, 0x51, 0x94, 0x99, 0x10, 0xa2, 0x27, 0x84, 0x28, 0x69, 0x9a, + 0x56, 0x75, 0x3c, 0x30, 0x4c, 0x5a, 0x4d, 0xd2, 0x8a, 0x51, 0x2a, 0x95, + 0xe0, 0x38, 0xce, 0xcd, 0x30, 0x8c, 0x13, 0x40, 0x23, 0x80, 0x32, 0x85, + 0x42, 0x91, 0x4b, 0x08, 0x39, 0x4e, 0xd3, 0x74, 0x49, 0x56, 0x56, 0x56, + 0xd5, 0xc1, 0x83, 0x07, 0x45, 0x09, 0x73, 0x70, 0x2d, 0xf4, 0xff, 0x01, + 0x46, 0x68, 0x89, 0xce, 0x97, 0x61, 0x39, 0x59, 0x00, 0x00, 0x00, 0x00, + 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82 +}; +unsigned int cow_png_len = 14672; diff --git a/NeoTracker/profile/test.sh b/NeoTracker/profile/test.sh new file mode 100644 index 0000000..7652ab5 --- /dev/null +++ b/NeoTracker/profile/test.sh @@ -0,0 +1 @@ +./TestAPI_Profile "-s" "sky" "-d" "Y16" diff --git a/NeoTracker/profile/utils.cpp b/NeoTracker/profile/utils.cpp new file mode 100644 index 0000000..1d33079 --- /dev/null +++ b/NeoTracker/profile/utils.cpp @@ -0,0 +1,398 @@ +#include +#include "utils.h" +#include "opencv2/opencv.hpp" +#include // 添加随机数生成相关头文件 + +using namespace std; +using namespace cv; + + + + + +SimTargetImage_Y16::SimTargetImage_Y16(int w, int h) +{ + pSrc = new unsigned short[w * h]; + + Y8Mat = cv::Mat(h,w,CV_8UC1); + + nImageWidth = w; + nImageHeight = h; +} + +SimTargetImage_Y16::~SimTargetImage_Y16() +{ + if (pSrc) + { + delete[]pSrc; + pSrc = nullptr; + } +} + + + +void SimTargetImage_Y16::setBackGround(int gray, int std) +{ + for (size_t i = 0; i < nImageHeight; i++) + { + for (size_t j = 0; j < nImageWidth; j++) + { + pSrc[i * nImageWidth + j] = rand() % std + gray; + } + } +} + +void SimTargetImage_Y16::addTarget(int x, int y, int w, int h, int gray) +{ + for (size_t i = y - h/2; i < y + h/2; i++) + { + for (size_t j = x - w/2; j < x+w/2; j++) + { + pSrc[i * nImageWidth + j] = gray; + } + } + +} + +unsigned short* SimTargetImage_Y16::getImageData() +{ + return pSrc; +} + +cv::Mat SimTargetImage_Y16::getMatRGB() +{ + Map16BitTo8Bit(pSrc, nImageHeight * nImageWidth, Y8Mat.data); + cv::Mat rgb; + cv::cvtColor(Y8Mat,rgb,COLOR_GRAY2RGB); + return rgb.clone(); + +} + + + +SimTargetImage::SimTargetImage(int w,int h) +{ + m_BaseMat = cv::Mat(h,w,CV_8UC3); + m_CurMat = m_BaseMat.clone(); + m_imgW = w; + m_imgH = h; +} + + +void SimTargetImage::update() +{ + m_CurMat = m_BaseMat.clone(); + + // 绘制目标 + for (int i = 0; i < m_targetList.size(); ++i) + { + Target* target = &m_targetList[i]; + // 更新目标位置 + target->updatePosition(m_imgW, m_imgH); + target->updateTexture(); + + //target->color = cv::Scalar(target->color[0] + target->vc, target->color[0] + target->vc, target->color[0] + target->vc); + + drawObj(*target); + } + + // 绘制遮挡 + for (int i = 0; i < m_OccList.size(); ++i) + { + Target* target = &m_OccList[i]; + // 绘制目标 + drawOcc(*target); + } + +} + +void SimTargetImage::setBackGround(int gray, int std) +{ + cv::Mat noise(m_BaseMat.size(), CV_8UC3); + cv::randn(noise, cv::Scalar::all(gray), cv::Scalar::all(std)); // 高斯噪声 + m_BaseMat = noise; + m_CurMat = noise.clone(); +} + +void SimTargetImage::addTarget(Target t) +{ + m_targetList.push_back(t); +} + +void SimTargetImage::addOcc(Target t) +{ + m_OccList.push_back(t); +} + +cv::Mat SimTargetImage::getImageRGB() +{ + return m_CurMat; +} + +cv::Mat SimTargetImage::getImageY16() +{ + cvtColor(m_CurMat,matY8,COLOR_BGR2GRAY); + matY8.convertTo(matY16,CV_16UC1); + return matY16*3+4000; +} + +cv::Mat SimTargetImage::getImageY8() +{ + cvtColor(m_CurMat,matY8,COLOR_BGR2GRAY); + return matY8; +} + +cv::Mat SimTargetImage::getImageNV12() +{ + matNV12 = cv::Mat(m_imgH*1.5, m_imgW, CV_8UC1); + cv::Mat matYUV_I420(m_imgH*1.5, m_imgW, CV_8UC1); + cvtColor(m_CurMat, matYUV_I420, COLOR_BGR2YUV_I420); + + int nLenY = m_imgW * m_imgH; + int nLenU = nLenY / 4; + + uchar* pNV12 = matNV12.data; + uchar* pUV = matNV12.data + nLenY; + + uchar* pI420 = matYUV_I420.data; + + memcpy(pNV12, pI420, nLenY); + + for (int i = 0; i < nLenU; i++) + { + pUV[2 * i] = pI420[nLenY + i]; // U + pUV[2 * i + 1] = pI420[nLenY + nLenU + i]; // V + } + return matNV12; +} + +Target* SimTargetImage::getTarget(int id) +{ + if (m_targetList.size() > 0) + { + return &m_targetList[id]; + } + else + { + return nullptr; + } + +} + +void SimTargetImage::drawObj(Target t) +{ + if (t.useTexture) + { + // 设置叠加位置 + int offsetX = t.x - t.width/2, offsetY = t.y - t.height/2; + cv::Rect roi(offsetX, offsetY, t.width, t.height); + // // 将前景叠加到背景，使用 Alpha 通道作为掩码 + t.texture_cur.copyTo(m_CurMat(roi),t.alaph_cur); + return; + } + + if (t.bGrayComplex) + { + cv::Rect rect(t.x - t.width / 2, t.y - t.height / 2, t.width, t.height/2); + cv::rectangle(m_CurMat, rect, cv::Scalar(t.color), cv::FILLED); + cv::Rect rect2(t.x - t.width / 2, t.y - t.height / 4, t.width, t.height/2); + cv::rectangle(m_CurMat, rect2, cv::Scalar(t.color2), cv::FILLED); + } + else + { + cv::Rect rect(t.x - t.width / 2, t.y - t.height / 2, t.width, t.height); + cv::rectangle(m_CurMat, rect, cv::Scalar(t.color), cv::FILLED); + } +} + +void SimTargetImage::drawOcc(Target t) +{ + cv::Rect rect(t.x - t.width/2, t.y - t.height/2, t.width, t.height); + cv::rectangle(m_CurMat, rect, cv::Scalar(t.color), cv::FILLED); +} + +void SimTargetImage::setCheckerboardBackGround(int gray1, int gray2, int blockSize) +{ + m_BaseMat = cv::Mat(m_imgH, m_imgW, CV_8UC3); + for (int y = 0; y < m_imgH; ++y) + { + for (int x = 0; x < m_imgW; ++x) + { + int bx = x / blockSize; + int by = y / blockSize; + bool isWhite = (bx + by) % 2 == 0; + int gray = isWhite ? gray1 : gray2; + m_BaseMat.at(y, x) = cv::Vec3b(gray, gray, gray); + } + } + m_CurMat = m_BaseMat.clone(); +} + +void Map16BitTo8Bit(unsigned short* psh16BitData, long lDataLen, unsigned char* pby8BitData) +{ + if (psh16BitData == NULL || pby8BitData == NULL || lDataLen <= 0) + { + return; + } + + //指向直方图的数据指针 + int* pHist = new int[65536]; + memset(pHist, 0, 65536 * sizeof(int)); + + int i = 0; + for (i = 0; i < lDataLen; i += 10) + { + pHist[psh16BitData[i]]++; + } + + //设置阈值大小为: AreaSigma*图象大小/100 + int nSigma = (int)(0.03 * lDataLen); + int nSum = 0; + int nMin = 0; + int nMax = 0; + + //求映射的最大最小值 + for (i = 0; i < 65536; i++) + { + nSum += pHist[i]; + if (nSum >= nSigma) + { + nMin = i; + break; + } + } + + nSum = 0; + + for (i = 65535; i >= 0; i--) + { + nSum += pHist[i]; + if (nSum >= nSigma) + { + nMax = i; + break; + } + } + + //计算对比度亮度 + float K = (float)(120.0 / (nMax - nMin + 1)); + float C = (float)(-K * nMin); + + //图像映射 + for (i = 0; i < lDataLen; i++) + { + int nValue = (int)(K * psh16BitData[i] + C); + if (nValue < 0) + { + pby8BitData[i] = 0; + } + else if (nValue > 255) + { + pby8BitData[i] = 255; + } + else + { + pby8BitData[i] = nValue; + } + } + + delete[] pHist; +} + +void showArithInfo(cv::Mat src, ARIDLL_OUTPUT * stOutput) +{ + auto detNum = stOutput->nAlarmObjCnts; + auto detObjs = stOutput->stAlarmObjs; + + + for (size_t i = 0; i < detNum; i++) + { + cv::Rect outRect; + outRect.width = MAX(15,int(detObjs[i].nObjW)); + outRect.height= MAX(15,int(detObjs[i].nObjH)); + outRect.x = detObjs[i].nX-outRect.width/2.0; + outRect.y = detObjs[i].nY-outRect.height/2.0; + cv::rectangle(src,outRect,cv::Scalar(255,0,0),2); + cv::putText(src,to_string(detObjs[i].nOutputID),cv::Point(outRect.x - 10,outRect.y),1,2,cv::Scalar(255,255,0)); + } + + auto trackerOut = stOutput->stTrackers[0]; + cv::Rect outRect; + outRect.width = MAX(25,int(trackerOut.nObjW)); + outRect.height= MAX(25,int(trackerOut.nObjH)); + outRect.x = trackerOut.nX-outRect.width/2.0; + outRect.y = trackerOut.nY-outRect.height/2.0; + cv::rectangle(src,outRect,cv::Scalar(0,0,255),2); + char str[100]; + sprintf(str,"%d,%d,%d,%d",int(trackerOut.nX),int(trackerOut.nY),int(trackerOut.nObjW),int(trackerOut.nObjH)); + cv::putText(src,cv::String(str),cv::Point(outRect.x - 10,outRect.y),1,2,cv::Scalar(255,255,0)); +} + +std::vector generateRandomLockUnlockSequence(int totalFrames, int minLockDuration, int maxLockDuration) +{ + std::vector sequence(totalFrames, 0); // 初始化为全0 + std::random_device rd; + std::mt19937 gen(rd()); + std::uniform_int_distribution<> actionDist(0, 1); // 0:普通帧, 1:锁定 + std::uniform_int_distribution<> durationDist(1, 5); // 连续动作的持续时间 + std::uniform_int_distribution<> unlockProbDist(0, 100); // 解锁概率分布 + std::uniform_int_distribution<> waitFramesDist(1, 3); // 锁定后等待帧数 + std::uniform_int_distribution<> waitProbDist(0, 100); // 是否等待的概率分布 + + int currentFrame = 0; + bool isLocked = false; // 当前是否处于锁定状态 + bool justLocked = false; // 是否刚刚执行了锁定操作 + + while (currentFrame < totalFrames) + { + if (isLocked) + { + // 如果当前是锁定状态，有20%的概率解锁 + if (unlockProbDist(gen) < 20) + { + sequence[currentFrame] = 2; // 解锁 + isLocked = false; + currentFrame++; + continue; + } + } + + // 如果刚刚执行了锁定操作，有50%的概率添加等待帧 + if (justLocked && waitProbDist(gen) < 50) + { + int waitFrames = waitFramesDist(gen); + for (int i = 0; i < waitFrames && currentFrame < totalFrames; i++) + { + sequence[currentFrame] = 0; // 等待帧 + currentFrame++; + } + } + justLocked = false; + + // 随机决定当前帧的动作类型 + int action = actionDist(gen); + // 随机决定这个动作持续多少帧 + int duration = durationDist(gen); + + // 确保不会超出总帧数 + if (currentFrame + duration > totalFrames) + { + duration = totalFrames - currentFrame; + } + + // 填充动作序列 + for (int i = 0; i < duration && currentFrame < totalFrames; i++) + { + sequence[currentFrame] = action; + if (action == 1) + { + isLocked = true; + justLocked = true; // 标记刚刚执行了锁定操作 + } + currentFrame++; + } + } + + return sequence; +} + diff --git a/NeoTracker/profile/utils.h b/NeoTracker/profile/utils.h new file mode 100644 index 0000000..539cf23 --- /dev/null +++ b/NeoTracker/profile/utils.h @@ -0,0 +1,177 @@ +#pragma once +#include +#include "NeoArithStandardDll.h" +class SimTargetImage_Y16 +{ + +public: + SimTargetImage_Y16(int w,int h); + ~SimTargetImage_Y16(); + + +public: + void setBackGround(int gray,int std); + void addTarget(int x, int y, int w, int h, int gray); + + // 获取Y16数据 + unsigned short* getImageData(); + + cv::Mat getMatRGB(); +private: + cv::Mat Y8Mat;//显示图像 + unsigned short* pSrc; + int nImageWidth; + int nImageHeight; +}; + + + + +// 目标结构体 +struct Target +{ + float x, y; // 目标位置 + float width, height; // 目标尺寸 + float vx, vy; // 水平和垂直速度 + float vw, vh; // 尺寸变化速度 + cv::Scalar color; // 目标颜色（适用于 RGB） + float vc; // 颜色变化率 + + bool useTexture; // 使用贴图 + + bool bGrayComplex; //花目标 + cv::Scalar color2; //花目标颜色（适用于 RGB） + + cv::Mat texture_cur; // 贴图 + cv::Mat alaph_cur; // 贴图alaph + + // 保存原始贴图状态 + cv::Mat texture; // 贴图 + cv::Mat alaph; // 贴图alaph + + Target() + { + useTexture = false; + }; + + + void updatePosition(int frameWidth, int frameHeight) + { + // 更新位置 + x += vx; + y += vy; + + width += vw; + height += vh; + + // 检测边界并反弹 + if (x <= width || x + width >= frameWidth) vx = -vx; + if (y <= height || y + height >= frameHeight) vy = -vy; + + // 保持目标在图像范围内 + x = std::max(0.0f, std::min(x, frameWidth - width)); + y = std::max(0.0f, std::min(y, frameHeight - height)); + } + + void updateTexture() + { + if(useTexture && (texture_cur.cols != height || texture_cur.rows != width)) + { + texture_cur = cv::Mat(height,width,CV_8UC3); + alaph_cur = cv::Mat(height,width,CV_8UC1); + cv::resize(texture,texture_cur,cv::Size(width,height)); + cv::resize(alaph,alaph_cur,cv::Size(width,height)); + } + } + + + void addTexture(unsigned char* png_data,int Len) + { + std::vector img_data(png_data, png_data + Len); + cv::Mat pic = cv::imdecode(img_data, cv::IMREAD_UNCHANGED); + + //cv::imshow("pic",pic); + // cv::waitKey(0); + + // 分离前景的 RGB 和 Alpha 通道 + cv::Mat bgr, alpha; + std::vector channels(4); + cv::split(pic, channels); + cv::merge(std::vector{channels[0], channels[1], channels[2]}, bgr); + + + useTexture = true; + alaph = channels[3]; // Alpha 通道 + texture = bgr; + + alaph_cur = channels[3]; + texture_cur = bgr; + } + +}; + + +class SimTargetImage +{ +public: + SimTargetImage(int w,int h); + ~SimTargetImage(){}; + +public: + + // 状态更新 + void update(); + + // 设置背景 + void setBackGround(int gray,int std); + // 新增：设置棋盘格背景 + void setCheckerboardBackGround(int gray1, int gray2, int blockSize); + + // 增加一个目标 + void addTarget(Target t); + + // 增加一个遮挡 + void addOcc(Target t); + +public: + cv::Mat getImageRGB(); + cv::Mat getImageY16(); + cv::Mat getImageY8(); + cv::Mat getImageNV12(); + + Target* getTarget(int id); + + +private: + void drawObj(Target t); + void drawOcc(Target t); + cv::Mat m_BaseMat;//图像帧(RGB) + cv::Mat m_CurMat;//图像帧(RGB) + + std::vector m_targetList; + std::vector m_OccList; + + int m_imgW; + int m_imgH; + +// 各类型输出结果 +private: + cv::Mat matY8; + cv::Mat matY16; + cv::Mat matNV12; + +}; + + + + +// 16位调光 +void Map16BitTo8Bit(unsigned short* psh16BitData, long lDataLen, unsigned char* pby8BitData); + + +void showArithInfo(cv::Mat src,ARIDLL_OUTPUT* output); + +// 生成随机锁定解锁序列 +// 返回值：锁定和解锁的帧编号数组，1表示锁定，2表示解锁，0表示普通帧 +std::vector generateRandomLockUnlockSequence(int totalFrames, int minLockDuration = 10, int maxLockDuration = 30); + diff --git a/NeoTracker/src/Arith_TrackSAObj.cpp b/NeoTracker/src/Arith_TrackSAObj.cpp index acaa7ae..f110121 100644 --- a/NeoTracker/src/Arith_TrackSAObj.cpp +++ b/NeoTracker/src/Arith_TrackSAObj.cpp @@ -1311,7 +1311,7 @@ SINT32 SA_Tracker::FindMatchTarget(PIPE* pPipe, TARGET_OBJECT* ptTargetArray, SI // 阈值调整 - if (pPipe->unLostCnt < 3) + if (pPipe->unLostCnt < 2) { fSScaleChangeLowThres = 0.3; fSScaleChangeHighThres = 3.f; @@ -1328,10 +1328,10 @@ SINT32 SA_Tracker::FindMatchTarget(PIPE* pPipe, TARGET_OBJECT* ptTargetArray, SI fSScaleChangeHighThres = 3.f; fAScaleChangeLowThres = 0.5; fAScaleChangeHighThres = 2.0; - nLastDiffThresX = MAX(nMoveMin,12); - nLastDiffThresY = MAX(nMoveMin, 12); - nPredictDiffThresX = MAX(nFThreMin, 12); - nPredictDiffThresY = MAX(nFThreMin, 12); + nLastDiffThresX = MAX(nMoveMin,50); + nLastDiffThresY = MAX(nMoveMin, 50); + nPredictDiffThresX = MAX(nFThreMin, 25); + nPredictDiffThresY = MAX(nFThreMin, 25); } else if (pPipe->unLostCnt < 50) { @@ -1339,8 +1339,8 @@ SINT32 SA_Tracker::FindMatchTarget(PIPE* pPipe, TARGET_OBJECT* ptTargetArray, SI fSScaleChangeHighThres = 5.f; fAScaleChangeLowThres = 0.33; fAScaleChangeHighThres = 3.0; - nLastDiffThresX = MAX(nMoveMin, 24); - nLastDiffThresY = MAX(nMoveMin, 24); + nLastDiffThresX = MAX(nMoveMin, 70); + nLastDiffThresY = MAX(nMoveMin, 70); nPredictDiffThresX = MAX(nFThreMin, 36); nPredictDiffThresY = MAX(nFThreMin, 36); } @@ -1350,8 +1350,8 @@ SINT32 SA_Tracker::FindMatchTarget(PIPE* pPipe, TARGET_OBJECT* ptTargetArray, SI fSScaleChangeHighThres = 8.f; fAScaleChangeLowThres = 0.33; fAScaleChangeHighThres = 3.0; - nLastDiffThresX = MAX(nMoveMin, 36); - nLastDiffThresY = MAX(nMoveMin, 36); + nLastDiffThresX = MAX(nMoveMin, 120); + nLastDiffThresY = MAX(nMoveMin, 120); nPredictDiffThresX = MAX(nFThreMin, 48); nPredictDiffThresY = MAX(nFThreMin, 48); } @@ -1367,6 +1367,22 @@ SINT32 SA_Tracker::FindMatchTarget(PIPE* pPipe, TARGET_OBJECT* ptTargetArray, SI nPredictDiffThresY = MAX(nFThreMin, 60); } + + // 小目标特殊处理 + if (pPipe->ObjectFilter.fPxlsCnt < 9) + { + fSScaleChangeLowThres = 0.3; + fSScaleChangeHighThres = 3.f; + fAScaleChangeLowThres = 0.5; + fAScaleChangeHighThres = 2.0; + nLastDiffThresX = MAX(nMoveMin, 6); + nLastDiffThresY = MAX(nMoveMin, 6); + nPredictDiffThresX = MAX(nFThreMin, 6); + nPredictDiffThresY = MAX(nFThreMin, 6); + } + + + SINT32 nEnd = pPipe->ubEnd; // 尺寸变化强逻辑防跳变// by wcw04046 @ 2020/06/22 if (nSimTargetId != -1 && m_ObjStatus.unContiLostCnt < 200) diff --git a/NeoTracker/src/Detect/Arith_DetectSmallObj.h b/NeoTracker/src/Detect/Arith_DetectSmallObj.h index 6a02408..b9e08a9 100644 --- a/NeoTracker/src/Detect/Arith_DetectSmallObj.h +++ b/NeoTracker/src/Detect/Arith_DetectSmallObj.h @@ -21,7 +21,7 @@ // 定义dst最大检测个数 -#define DST_MAX_NUM 50 +#define DST_MAX_NUM 150 //20170331,雷达导引中心区域恒虚警个数 #define DST_FA_GUIDE_TARGET_NUM 10 diff --git a/NeoTracker/src/Version.h.in b/NeoTracker/src/Version.h.in index 784a52a..81581d3 100644 --- a/NeoTracker/src/Version.h.in +++ b/NeoTracker/src/Version.h.in @@ -3,4 +3,4 @@ #pragma once #include std::string BUILD_TIME = "BUILD_TIME @build_time@"; -std::string VERSION = "BUILD_VERSION 1.3.2"; +std::string VERSION = "BUILD_VERSION 1.3.3"; diff --git a/NeoTracker/tests/TestAPI_SOT_Sky_Y16.cpp b/NeoTracker/tests/TestAPI_SOT_Sky_Y16.cpp index a927e5c..a89f7e2 100644 --- a/NeoTracker/tests/TestAPI_SOT_Sky_Y16.cpp +++ b/NeoTracker/tests/TestAPI_SOT_Sky_Y16.cpp @@ -108,8 +108,8 @@ int main() char str[100]; sprintf(str,"%d-%d,%d,%d",i,int(stOutput.stTrackers[0].nX - moveX),int(stOutput.stTrackers[0].nY - moveY),stOutput.stTrackers->nPipeLostCnt); cv::putText(src,cv::String(str),cv::Point(outRect.x - 10,outRect.y),1,2,cv::Scalar(255,255,0)); - //imshow("res",src); - //cv::waitKey(2); + imshow("res",src); + cv::waitKey(2); if ((stOutput.nStatus == GLB_STATUS_TRACK || stOutput.nStatus == GLB_STATUS_MOTRACK) && stOutput.nTrackObjCnts == 1) { diff --git a/QGuideArithStudio/src/QFileList.cpp b/QGuideArithStudio/src/QFileList.cpp index 5c39f5f..e4ea6d8 100644 --- a/QGuideArithStudio/src/QFileList.cpp +++ b/QGuideArithStudio/src/QFileList.cpp @@ -59,7 +59,7 @@ void QFileList::DisplayFileList(QString path) foreach(QString str, m_vecFileList) { //str.toLower(); - QString es = "raw$|xraw$|rawx$|GD$|avi$|mp4$|yuv|MP4|AVI";//by wcw04046 + QString es = "raw$|xraw$|rawx$|GD$|avi$|mp4$|yuv|MP4|AVI|data";//by wcw04046 nPos = str.indexOf(QRegExp(es), 0); if (-1 == nPos) { diff --git a/QGuideArithStudio/src/QVideoPlayer.cpp b/QGuideArithStudio/src/QVideoPlayer.cpp index 82587b0..0fb878f 100644 --- a/QGuideArithStudio/src/QVideoPlayer.cpp +++ b/QGuideArithStudio/src/QVideoPlayer.cpp @@ -964,10 +964,10 @@ void QVideoPlayer::DrawFrameDetectObjs() int cx = obj->pfCenPos.x; int cy = obj->pfCenPos.y; - //int w = MAX(15, obj->snSize.w); - //int h = MAX(15, obj->snSize.h); - int w = obj->snSize.w; - int h = obj->snSize.h; + int w = MAX(10, obj->snSize.w); + int h = MAX(10, obj->snSize.h); + //int w = obj->snSize.w; + //int h = obj->snSize.h; QRectF bbox(cx - w / 2, cy - h / 2, w, h); scene->addRect(bbox, QPen(QColor(255, 20, 147), 0.3));