diff --git a/arch/arm/boot/dts/overlays/README b/arch/arm/boot/dts/overlays/README index 3076ead83fe8dc..93261363245acb 100644 --- a/arch/arm/boot/dts/overlays/README +++ b/arch/arm/boot/dts/overlays/README @@ -5964,6 +5964,8 @@ Params: 3_4_inch_c 3.4" 800x800 2lane 4_0_inch_c 4.0" 720x720 2lane 5_0_inch_a 5.0" 720x1280 2lane 5_5_inch_a 5.5" 720x1280 2lane + 6_25_inch_a 6.25" 720x1560 2lane + 6_25_inch_a_4lane 6.25" 720x1560 4lane 7_0_inch_a 7.0" A 720x1280 2lane 7_0_inch_b 7.0" B 720x1280 2lane 7_0_inch_c 7.0" C 1024x600 2lane diff --git a/arch/arm/boot/dts/overlays/vc4-kms-dsi-waveshare-panel-v2-overlay.dts b/arch/arm/boot/dts/overlays/vc4-kms-dsi-waveshare-panel-v2-overlay.dts index ddb085d03cfa4b..c1c3f369a0f73a 100644 --- a/arch/arm/boot/dts/overlays/vc4-kms-dsi-waveshare-panel-v2-overlay.dts +++ b/arch/arm/boot/dts/overlays/vc4-kms-dsi-waveshare-panel-v2-overlay.dts @@ -25,7 +25,7 @@ enable-gpio = <&display_mcu 2 GPIO_ACTIVE_HIGH>; }; - touch: goodix@5d { + touch: touch@5d { compatible = "goodix,gt9271"; reg = <0x5d>; reset-gpio = <&display_mcu 9 GPIO_ACTIVE_HIGH>; @@ -82,6 +82,12 @@ 4_0_inch_c = <&dsi_panel>, "compatible=waveshare,4.0-dsi-touch-c"; 5_0_inch_a = <&dsi_panel>, "compatible=waveshare,5.0-dsi-touch-a"; 5_5_inch_a = <&dsi_panel>, "compatible=waveshare,5.5-dsi-touch-a"; + 6_25_inch_a = <&dsi_panel>, "compatible=waveshare,6.25-dsi-touch-a", + <&touch>, "compatible=sitronix_ts,st7123", + <&touch>, "reg:0=0x55"; + 6_25_inch_a_4lane = <&dsi_panel>, "compatible=waveshare,6.25-dsi-touch-a,4lane", + <&touch>, "compatible=sitronix_ts,st7123", + <&touch>, "reg:0=0x55"; 7_0_inch_a = <&dsi_panel>, "compatible=waveshare,7.0-dsi-touch-a"; 7_0_inch_b = <&dsi_panel>, "compatible=waveshare,7.0-dsi-touch-b"; 7_0_inch_c = <&dsi_panel>, "compatible=waveshare,7.0-dsi-touch-c"; diff --git a/arch/arm64/configs/bcm2711_defconfig b/arch/arm64/configs/bcm2711_defconfig index 3ca12507d0f683..b5291c535ee99e 100644 --- a/arch/arm64/configs/bcm2711_defconfig +++ b/arch/arm64/configs/bcm2711_defconfig @@ -707,6 +707,7 @@ CONFIG_TOUCHSCREEN_RASPBERRYPI_FW=m CONFIG_TOUCHSCREEN_USB_COMPOSITE=m CONFIG_TOUCHSCREEN_TSC2007=m CONFIG_TOUCHSCREEN_TSC2007_IIO=y +CONFIG_TOUCHSCREEN_ST7123=m CONFIG_TOUCHSCREEN_STMPE=m CONFIG_TOUCHSCREEN_IQS5XX=m CONFIG_INPUT_MISC=y diff --git a/arch/arm64/configs/bcm2711_rt_defconfig b/arch/arm64/configs/bcm2711_rt_defconfig index a90c06af912be9..372275e744592d 100644 --- a/arch/arm64/configs/bcm2711_rt_defconfig +++ b/arch/arm64/configs/bcm2711_rt_defconfig @@ -706,6 +706,7 @@ CONFIG_TOUCHSCREEN_RASPBERRYPI_FW=m CONFIG_TOUCHSCREEN_USB_COMPOSITE=m CONFIG_TOUCHSCREEN_TSC2007=m CONFIG_TOUCHSCREEN_TSC2007_IIO=y +CONFIG_TOUCHSCREEN_ST7123=m CONFIG_TOUCHSCREEN_STMPE=m CONFIG_TOUCHSCREEN_IQS5XX=m CONFIG_INPUT_MISC=y diff --git a/arch/arm64/configs/bcm2712_defconfig b/arch/arm64/configs/bcm2712_defconfig index 1d27063139c6d6..513640a49c5bda 100644 --- a/arch/arm64/configs/bcm2712_defconfig +++ b/arch/arm64/configs/bcm2712_defconfig @@ -710,6 +710,7 @@ CONFIG_TOUCHSCREEN_RASPBERRYPI_FW=m CONFIG_TOUCHSCREEN_USB_COMPOSITE=m CONFIG_TOUCHSCREEN_TSC2007=m CONFIG_TOUCHSCREEN_TSC2007_IIO=y +CONFIG_TOUCHSCREEN_ST7123=m CONFIG_TOUCHSCREEN_STMPE=m CONFIG_TOUCHSCREEN_IQS5XX=m CONFIG_INPUT_MISC=y diff --git a/drivers/gpu/drm/panel/panel-waveshare-dsi-v2.c b/drivers/gpu/drm/panel/panel-waveshare-dsi-v2.c index e15dae58a19db1..4419907e39491d 100644 --- a/drivers/gpu/drm/panel/panel-waveshare-dsi-v2.c +++ b/drivers/gpu/drm/panel/panel-waveshare-dsi-v2.c @@ -1393,6 +1393,139 @@ static const struct panel_init_cmd ws_panel_7_c_init[] = { {}, }; +static const struct panel_init_cmd ws_panel_6_25_a_4lane_init[] = { + _INIT_DCS_CMD(0x60, 0x71, 0x23, 0xa2), + _INIT_DCS_CMD(0x60, 0x71, 0x23, 0xa3), + _INIT_DCS_CMD(0x60, 0x71, 0x23, 0xa4), + _INIT_DCS_CMD(0xB0, 0x22, 0x61, 0x11, 0x6B, 0x25, 0x39, 0x39), + _INIT_DCS_CMD(0xB7, 0x00, 0x00, 0x64, 0x64), + _INIT_DCS_CMD(0xBF, 0x95, 0x95), + _INIT_DCS_CMD(0xC8, 0x00, 0x00, 0x10, 0x1F, 0x3A, 0x00, 0x66, 0x03, + 0xA8, 0x04, 0x11, 0x02, 0x06, 0x73, 0x01, 0x21, 0xC1, + 0x02, 0x01, 0x02, 0x22, 0x3E, 0x00, 0x84, 0x09, 0x32, + 0xE9, 0x0B, 0x3B, 0x0D, 0xF3, 0x7E, 0x0D, 0xB2, 0xE6, + 0x03, 0xFC), + _INIT_DCS_CMD(0xC9, 0x00, 0x00, 0x10, 0x1F, 0x3A, 0x00, 0x66, 0x03, + 0xA8, 0x04, 0x11, 0x02, 0x06, 0x73, 0x01, 0x21, 0xC1, + 0x02, 0x01, 0x02, 0x22, 0x3E, 0x00, 0x84, 0x09, 0x32, + 0xE9, 0x0B, 0x3B, 0x0D, 0xF3, 0x7E, 0x0D, 0xB2, 0xE6, + 0x03, 0xFC), + _INIT_DCS_CMD(0xD7, 0x10, 0x12, 0x49, 0x3B, 0x0C, 0x0C), + _INIT_DCS_CMD(0x90, 0x71, 0x23, 0x5A, 0x20, 0x24, 0x09, 0x09), + _INIT_DCS_CMD(0xA3, 0x80, 0x01, 0x88, 0x30, 0x05, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x46, 0x00, 0x00, 0x1E, 0x5C, 0x1E, 0x80, + 0x00, 0x4F, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, + 0x00, 0x00, 0x1E, 0x5C, 0x1E, 0x80, 0x00, 0x6F, 0x58, + 0x00, 0x00, 0x00, 0xFF), + _INIT_DCS_CMD(0xA6, 0x50, 0x00, 0x24, 0x55, 0x3A, 0x00, 0x00, 0x01, + 0x54, 0x54, 0x91, 0xFF, 0x00, 0x24, 0x55, 0x3B, 0x00, + 0x00, 0x00, 0x54, 0x54, 0x91, 0xFF, 0x00, 0x24, 0x11, + 0x00, 0x00, 0x00, 0x00, 0x54, 0x54, 0x91, 0xFF, 0x00, + 0xAC, 0x11, 0x00, 0x00, 0x00, 0x00, 0x54, 0x54, 0xFF, + 0xFF, 0x00, 0x08, 0x80, 0x08, 0x80, 0x06, 0x00, 0x00, + 0x00, 0x00), + _INIT_DCS_CMD(0xA7, 0x1D, 0x1D, 0x80, 0x64, 0x40, 0x07, 0x16, 0x41, + 0x02, 0x48, 0x07, 0x54, 0x54, 0x91, 0xFF, 0x08, 0x80, + 0x64, 0x40, 0x25, 0x34, 0x43, 0x04, 0x06, 0x05, 0x54, + 0x54, 0x91, 0xFF, 0x08, 0x80, 0x64, 0x40, 0x00, 0x00, + 0x40, 0x00, 0x00, 0x00, 0x54, 0x54, 0x91, 0xFF, 0x08, + 0x80, 0x64, 0x40, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x54, 0x54, 0x84, 0xFF, 0x08, 0x80, 0x44), + _INIT_DCS_CMD(0xAC, 0x1C, 0x02, 0x09, 0x0B, 0x12, 0x10, 0x18, 0x19, + 0x1C, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x08, 0x0A, + 0x13, 0x11, 0x18, 0x19, 0x1C, 0x03, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00), + _INIT_DCS_CMD(0xAD, 0xF0, 0x00, 0x46, 0x00, 0x05, 0x50, 0x50, 0xFF, + 0xFF, 0xF0, 0x40, 0x06, 0x01, 0x07, 0x42, 0x42, 0xFF, + 0xFF, 0x01, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF), + _INIT_DCS_CMD(0xAE, 0xFF, 0x03, 0x00, 0xFF, 0x03, 0x00, 0x01), + _INIT_DCS_CMD(0xB2, 0x15, 0x19, 0x05, 0x23, 0x49, 0xAF, 0x03, 0x2E, + 0x5C, 0xD2, 0xFF, 0x10, 0x20, 0xFD, 0x20, 0xC0, 0x00), + _INIT_DCS_CMD(0xE8, 0x20, 0x6F, 0x04, 0x7C, 0x7C, 0x3E, 0x04, 0xDC, + 0xDC, 0x3E, 0x06, 0xFA, 0x26, 0x3E), + _INIT_DCS_CMD(0x75, 0x03, 0x04), + _INIT_DCS_CMD(0xE7, 0x3B, 0x00, 0x00, 0x7C, 0xA1, 0x8C, 0x20, 0x1A, + 0xF0, 0xB1, 0x50, 0x00, 0x50, 0xB1, 0x50, 0xB1, 0x50, + 0xD8, 0x00, 0x55, 0x00, 0xB1, 0x00, 0x45, 0xC9, 0x6A, + 0xFF, 0x5A, 0xD8, 0x18, 0x88, 0x15, 0xB1, 0x01, 0x01, + 0x77), + _INIT_DCS_CMD(0xEA, 0x13, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x2C), + _INIT_DCS_CMD(0x60, 0x71, 0x23, 0x00), + _INIT_DCS_CMD(0x11), + _INIT_DELAY_CMD(120), + _INIT_DCS_CMD(0x29), + _INIT_DELAY_CMD(50), + {}, +}; + +static const struct panel_init_cmd ws_panel_6_25_a_init[] = { + _INIT_DCS_CMD(0x60, 0x71, 0x23, 0xa2), + _INIT_DCS_CMD(0x60, 0x71, 0x23, 0xa3), + _INIT_DCS_CMD(0x60, 0x71, 0x23, 0xa4), + _INIT_DCS_CMD(0xB0, 0x22, 0x61, 0x11, 0x6B, 0x25, 0x39, 0x39), + _INIT_DCS_CMD(0xB7, 0x00, 0x00, 0x64, 0x64), + _INIT_DCS_CMD(0xBF, 0x95, 0x95), + _INIT_DCS_CMD(0xA4, 0x31), + _INIT_DCS_CMD(0xC8, 0x00, 0x00, 0x10, 0x1F, 0x3A, 0x00, 0x66, 0x03, + 0xA8, 0x04, 0x11, 0x02, 0x06, 0x73, 0x01, 0x21, 0xC1, + 0x02, 0x01, 0x02, 0x22, 0x3E, 0x00, 0x84, 0x09, 0x32, + 0xE9, 0x0B, 0x3B, 0x0D, 0xF3, 0x7E, 0x0D, 0xB2, 0xE6, + 0x03, 0xFC), + _INIT_DCS_CMD(0xC9, 0x00, 0x00, 0x10, 0x1F, 0x3A, 0x00, 0x66, 0x03, + 0xA8, 0x04, 0x11, 0x02, 0x06, 0x73, 0x01, 0x21, 0xC1, + 0x02, 0x01, 0x02, 0x22, 0x3E, 0x00, 0x84, 0x09, 0x32, + 0xE9, 0x0B, 0x3B, 0x0D, 0xF3, 0x7E, 0x0D, 0xB2, 0xE6, + 0x03, 0xFC), + _INIT_DCS_CMD(0xD7, 0x10, 0x12, 0x49, 0x3B, 0x0C, 0x0C), + _INIT_DCS_CMD(0x90, 0x71, 0x23, 0x5A, 0x20, 0x24, 0x09, 0x09), + _INIT_DCS_CMD(0xA3, 0x80, 0x01, 0x88, 0x30, 0x05, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x46, 0x00, 0x00, 0x1E, 0x5C, 0x1E, 0x80, + 0x00, 0x4F, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, + 0x00, 0x00, 0x1E, 0x5C, 0x1E, 0x80, 0x00, 0x6F, 0x58, + 0x00, 0x00, 0x00, 0xFF), + _INIT_DCS_CMD(0xA6, 0x50, 0x00, 0x24, 0x55, 0x3A, 0x00, 0x00, 0x01, + 0x54, 0x54, 0x91, 0xFF, 0x00, 0x24, 0x55, 0x3B, 0x00, + 0x00, 0x00, 0x54, 0x54, 0x91, 0xFF, 0x00, 0x24, 0x11, + 0x00, 0x00, 0x00, 0x00, 0x54, 0x54, 0x91, 0xFF, 0x00, + 0xAC, 0x11, 0x00, 0x00, 0x00, 0x00, 0x54, 0x54, 0xFF, + 0xFF, 0x00, 0x08, 0x80, 0x08, 0x80, 0x06, 0x00, 0x00, + 0x00, 0x00), + _INIT_DCS_CMD(0xA7, 0x1D, 0x1D, 0x80, 0x64, 0x40, 0x07, 0x16, 0x41, + 0x02, 0x48, 0x07, 0x54, 0x54, 0x91, 0xFF, 0x08, 0x80, + 0x64, 0x40, 0x25, 0x34, 0x43, 0x04, 0x06, 0x05, 0x54, + 0x54, 0x91, 0xFF, 0x08, 0x80, 0x64, 0x40, 0x00, 0x00, + 0x40, 0x00, 0x00, 0x00, 0x54, 0x54, 0x91, 0xFF, 0x08, + 0x80, 0x64, 0x40, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x54, 0x54, 0x84, 0xFF, 0x08, 0x80, 0x44), + _INIT_DCS_CMD(0xAC, 0x1C, 0x02, 0x09, 0x0B, 0x12, 0x10, 0x18, 0x19, + 0x1C, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x08, 0x0A, + 0x13, 0x11, 0x18, 0x19, 0x1C, 0x03, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00), + _INIT_DCS_CMD(0xAD, 0xF0, 0x00, 0x46, 0x00, 0x05, 0x50, 0x50, 0xFF, + 0xFF, 0xF0, 0x40, 0x06, 0x01, 0x07, 0x42, 0x42, 0xFF, + 0xFF, 0x01, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF), + _INIT_DCS_CMD(0xAE, 0xFF, 0x03, 0x00, 0xFF, 0x03, 0x00, 0x01), + _INIT_DCS_CMD(0xB2, 0x15, 0x19, 0x05, 0x23, 0x49, 0xAF, 0x03, 0x2E, + 0x5C, 0xD2, 0xFF, 0x10, 0x20, 0xFD, 0x20, 0xC0, 0x00), + _INIT_DCS_CMD(0xE8, 0x20, 0x6F, 0x04, 0x7C, 0x7C, 0x3E, 0x04, 0xDC, + 0xDC, 0x3E, 0x06, 0xFA, 0x26, 0x3E), + _INIT_DCS_CMD(0x75, 0x03, 0x04), + _INIT_DCS_CMD(0xE7, 0x3B, 0x00, 0x00, 0x7C, 0xA1, 0x8C, 0x20, 0x1A, + 0xF0, 0xB1, 0x50, 0x00, 0x50, 0xB1, 0x50, 0xB1, 0x50, + 0xD8, 0x00, 0x55, 0x00, 0xB1, 0x00, 0x45, 0xC9, 0x6A, + 0xFF, 0x5A, 0xD8, 0x18, 0x88, 0x15, 0xB1, 0x01, 0x01, + 0x77), + _INIT_DCS_CMD(0xEA, 0x13, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x2C), + _INIT_DCS_CMD(0x60, 0x71, 0x23, 0x00), + _INIT_DCS_CMD(0x11), + _INIT_DELAY_CMD(120), + _INIT_DCS_CMD(0x29), + _INIT_DELAY_CMD(50), + {}, +}; + static const struct panel_init_cmd ws_panel_5_5_a_init[] = { _INIT_DCS_CMD(0xB9, 0xFF, 0x83, 0x94), _INIT_DCS_CMD(0xBA, 0x61, 0x03, 0x68, 0x6B, 0xB2, 0xC0), @@ -1935,6 +2068,34 @@ static const struct drm_display_mode ws_panel_7_c_mode = { .height_mm = 85, }; +static const struct drm_display_mode ws_panel_6_25_a_4lane_mode = { + .clock = 93000, + .hdisplay = 720, + .hsync_start = 720 + 40, + .hsync_end = 720 + 40 + 20, + .htotal = 720 + 40 + 20 + 40, + .vdisplay = 1560, + .vsync_start = 1560 + 320, + .vsync_end = 1560 + 320 + 2, + .vtotal = 1560 + 320 + 2 + 16, + .width_mm = 62, + .height_mm = 110, +}; + +static const struct drm_display_mode ws_panel_6_25_a_mode = { + .clock = 83000, + .hdisplay = 720, + .hsync_start = 720 + 20, + .hsync_end = 720 + 20 + 20, + .htotal = 720 + 20 + 20 + 20, + .vdisplay = 1560, + .vsync_start = 1560 + 200, + .vsync_end = 1560 + 200 + 8, + .vtotal = 1560 + 200 + 8 + 10, + .width_mm = 62, + .height_mm = 110, +}; + static const struct drm_display_mode ws_panel_5_5_a_mode = { .clock = 65000, .hdisplay = 720, @@ -2243,6 +2404,24 @@ static const struct ws_panel_desc ws_panel_7_inch_c_desc = { .format = MIPI_DSI_FMT_RGB888, }; +static const struct ws_panel_desc ws_panel_6_25_inch_a_4lane_desc = { + .init = ws_panel_6_25_a_4lane_init, + .mode = &ws_panel_6_25_a_4lane_mode, + .mode_flags = MIPI_DSI_MODE_VIDEO_HSE | MIPI_DSI_MODE_VIDEO | + MIPI_DSI_MODE_LPM | MIPI_DSI_CLOCK_NON_CONTINUOUS, + .lanes = 4, + .format = MIPI_DSI_FMT_RGB888, +}; + +static const struct ws_panel_desc ws_panel_6_25_inch_a_desc = { + .init = ws_panel_6_25_a_init, + .mode = &ws_panel_6_25_a_mode, + .mode_flags = MIPI_DSI_MODE_VIDEO_HSE | MIPI_DSI_MODE_VIDEO | + MIPI_DSI_MODE_LPM | MIPI_DSI_CLOCK_NON_CONTINUOUS, + .lanes = 2, + .format = MIPI_DSI_FMT_RGB888, +}; + static const struct ws_panel_desc ws_panel_5_5_inch_a_desc = { .init = ws_panel_5_5_a_init, .mode = &ws_panel_5_5_a_mode, @@ -2301,6 +2480,9 @@ static const struct of_device_id ws_panel_of_match[] = { { .compatible = "waveshare,7.0-dsi-touch-a", &ws_panel_7_inch_a_desc }, { .compatible = "waveshare,7.0-dsi-touch-b", &ws_panel_7_inch_a_desc }, { .compatible = "waveshare,7.0-dsi-touch-c", &ws_panel_7_inch_c_desc }, + { .compatible = "waveshare,6.25-dsi-touch-a,4lane", + &ws_panel_6_25_inch_a_4lane_desc }, + { .compatible = "waveshare,6.25-dsi-touch-a", &ws_panel_6_25_inch_a_desc }, { .compatible = "waveshare,5.5-dsi-touch-a", &ws_panel_5_5_inch_a_desc }, { .compatible = "waveshare,5.0-dsi-touch-a", &ws_panel_5_inch_a_desc }, diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig index 9d543ad267ce01..14758c25420479 100644 --- a/drivers/input/touchscreen/Kconfig +++ b/drivers/input/touchscreen/Kconfig @@ -1251,6 +1251,18 @@ config TOUCHSCREEN_SIS_I2C To compile this driver as a module, choose M here: the module will be called sis_i2c. +config TOUCHSCREEN_ST7123 + tristate "Sitronix ST7123 touchscreen controllers" + depends on I2C + help + Say Y here if you want to support the Sitronix ST7123 + touchscreen controller. + + If unsure, say N. + + To compile this driver as a module, choose M here: the + module will be called sitronix-st7123. + config TOUCHSCREEN_ST1232 tristate "Sitronix ST1232 or ST1633 touchscreen controllers" depends on I2C diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile index 53930469552ee8..d251ebf646e3ac 100644 --- a/drivers/input/touchscreen/Makefile +++ b/drivers/input/touchscreen/Makefile @@ -83,6 +83,7 @@ obj-$(CONFIG_TOUCHSCREEN_RM_TS) += raydium_i2c_ts.o obj-$(CONFIG_TOUCHSCREEN_S6SY761) += s6sy761.o obj-$(CONFIG_TOUCHSCREEN_SILEAD) += silead.o obj-$(CONFIG_TOUCHSCREEN_SIS_I2C) += sis_i2c.o +obj-$(CONFIG_TOUCHSCREEN_ST7123) += sitronix_st7123/ obj-$(CONFIG_TOUCHSCREEN_ST1232) += st1232.o obj-$(CONFIG_TOUCHSCREEN_STMFTS) += stmfts.o obj-$(CONFIG_TOUCHSCREEN_STMPE) += stmpe-ts.o diff --git a/drivers/input/touchscreen/sitronix_st7123/Makefile b/drivers/input/touchscreen/sitronix_st7123/Makefile new file mode 100644 index 00000000000000..abe68496e36527 --- /dev/null +++ b/drivers/input/touchscreen/sitronix_st7123/Makefile @@ -0,0 +1,2 @@ +sitronix-st7123-objs = sitronix_ts.o sitronix_ts_i2c.o sitronix_ts_utility.o sitronix_ts_mt.o sitronix_ts_upgrade.o +obj-m += sitronix-st7123.o diff --git a/drivers/input/touchscreen/sitronix_st7123/sitronix_st7123.h b/drivers/input/touchscreen/sitronix_st7123/sitronix_st7123.h new file mode 100644 index 00000000000000..dd1044d9ec5f86 --- /dev/null +++ b/drivers/input/touchscreen/sitronix_st7123/sitronix_st7123.h @@ -0,0 +1,49 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#define ST_CHIPID 0x83 + +/* common */ +#define ST_DISPLAY_DUMP_OFF 0x1D7FE +#define ST_DISPLAY_SIZE 0x800 + +/* flash */ +#define ST_FLASH_PAGE_SIZE 4096 +#define ST_FLASH_SIZE 0x20000 +#define ST_ICP_DISPLAY_FLASH_OFF 0x1D7FE + +/* ICP */ +#define ST_ADDR_MODE_I2C_ADDR 0x28 + +/* HDL */ +#define ST_RAM_MODE_RETRY_MAX 3 +#define ST_FW_LEN 0x010000 +#define ST_HDL_PRAM_ADDR 0x7F0000 +#define ST_FW_LEN_PART2 0x002000 +#define ST_HDL_PRAM_ADDR_PART2 0x400000 +#define ST_HDL_URAM_ADDR 0x000000 +#define ST_HDL_DISPLAY_RAM_ADDR 0x030000 + +/* IC register */ +#define ST_MISC_INFO_PROX_FLAG 0x20 +#define ST_MISC_INFO_COORD_CHKSUM_FLAG 0x10 + +enum sitronix_mode_switch { + ST_MODE_SWU = 1, + ST_MODE_GLOVE = 2, + ST_MODE_CHARGE = 3, + ST_MODE_JITTERSUPPRESS = 4, + ST_MODE_PALM = 5, + ST_MODE_HEADPHONE = 6, + ST_MODE_GRIP = 7, + ST_MODE_SIZE = 8, + ST_MODE_RESTORE_START = 2, + ST_MODE_SWITCH_OFF = 0, + ST_MODE_SWITCH_ON = 0x80 +}; + +enum st_mode_grip_rotate_value { + ST_MODE_GRIP_ROTATE_0 = 0, + ST_MODE_GRIP_ROTATE_90 = 1, + ST_MODE_GRIP_ROTATE_180 = 2, + ST_MODE_GRIP_ROTATE_270 = 3, +}; diff --git a/drivers/input/touchscreen/sitronix_st7123/sitronix_ts.c b/drivers/input/touchscreen/sitronix_st7123/sitronix_ts.c new file mode 100644 index 00000000000000..346cecc6f2dae2 --- /dev/null +++ b/drivers/input/touchscreen/sitronix_st7123/sitronix_ts.c @@ -0,0 +1,1018 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Sitronix Touchscreen Controller Driver + * + * Copyright (C) 2018 Sitronix Technology Co., Ltd. + * CT Chen + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#include "sitronix_ts.h" +#include "sitronix_st7123.h" + +struct sitronix_ts_data *gts; +//unsigned char wbuf[SITRONIX_RW_BUF_LEN+8] = {0}; +//unsigned char rbuf[SITRONIX_RW_BUF_LEN+8] = {0}; +unsigned char *wbuf; +unsigned char *rbuf; + +#define POLL_INTERVAL_MS 17 /* 17ms = 60fps */ +/* #define SITRONIX_TS_INPUT_PHYS_NAME "sitronix_ts/input0" */ + +#if defined(CONFIG_FB) +static void sitronix_ts_resume_work(struct work_struct *work); +static int sitronix_ts_suspend(struct device *dev); +static int sitronix_ts_resume(struct device *dev); +#ifdef _MSM_DRM_NOTIFY_H_ +static int sitronix_drm_notifier_callback(struct notifier_block *self, + unsigned long event, void *data); +#else +static int sitronix_fb_notifier_callback(struct notifier_block *self, + unsigned long event, void *data); +#endif +#elif defined(CONFIG_DRM) +static void sitronix_ts_resume_work(struct work_struct *work); +static int sitronix_ts_suspend(struct device *dev); +static int sitronix_ts_resume(struct device *dev); +#if defined(CONFIG_DRM_PANEL) +static int sitronix_drm_notifier_callback(struct notifier_block *self, + unsigned long event, void *data); +#endif /* CONFIG_DRM_PANEL */ +#elif defined(CONFIG_HAS_EARLYSUSPEND) +static void sitronix_ts_early_suspend(struct early_suspend *h); +static void sitronix_ts_late_resume(struct early_suspend *h); +#endif + +static inline void sitronix_ts_pen_down(struct sitronix_ts_data *ts_data, + int id, uint16_t x, uint16_t y) +{ +#ifdef SITRONIX_TS_MT_SLOT + input_mt_slot(ts_data->input_dev, id); + input_mt_report_slot_state(ts_data->input_dev, MT_TOOL_FINGER, true); + // input_report_abs(ts_data->input_dev, ABS_MT_POSITION_X, x); + // input_report_abs(ts_data->input_dev, ABS_MT_POSITION_Y, y); + touchscreen_report_pos(ts_data->input_dev, &ts_data->prop, x, y, true); + input_report_abs(ts_data->input_dev, ABS_MT_TOUCH_MAJOR, 1); + input_report_abs(ts_data->input_dev, ABS_MT_PRESSURE, 255); + //input_report_abs(ts_data->input_dev, ABS_MT_TRACKING_ID, id); +#else /* SITRONIX_TS_MT_SLOT */ + input_report_abs(ts_data->input_dev, ABS_MT_TRACKING_ID, id); + // input_report_abs(ts_data->input_dev, ABS_MT_POSITION_X, x); + // input_report_abs(ts_data->input_dev, ABS_MT_POSITION_Y, y); + touchscreen_report_pos(ts_data->input_dev, &ts_data->prop, x, y, true); + input_report_abs(ts_data->input_dev, ABS_MT_TOUCH_MAJOR, 10); + input_report_abs(ts_data->input_dev, ABS_MT_TOUCH_MINOR, 10); + input_report_abs(ts_data->input_dev, ABS_MT_PRESSURE, 10); + input_mt_sync(ts_data->input_dev); +#endif /* SITRONIX_TS_MT_SLOT */ +} + +static inline void sitronix_ts_pen_up(struct input_dev *input_dev, int id) +{ +#ifdef SITRONIX_TS_MT_SLOT + input_mt_slot(input_dev, id); + input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, false); + input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, 0); + input_report_abs(input_dev, ABS_MT_PRESSURE, 0); +#endif /* SITRONIX_TS_MT_SLOT */ +} + +static inline void sitronix_ts_pen_allup(struct sitronix_ts_data *ts_data) +{ + int i; + + for (i = 0; i < ts_data->ts_dev_info.max_touches; i++) + sitronix_ts_pen_up(ts_data->input_dev, i); + + input_report_key(ts_data->input_dev, BTN_TOUCH, 0); + input_sync(ts_data->input_dev); +} + +static void sitronix_process_events(struct sitronix_ts_data *ts_data) +{ + int i; + int ret; + uint16_t x, y; + uint8_t z; + uint8_t read_len = (ts_data->ts_dev_info.max_touches * 7) + 5; + uint8_t touch_count = 0; + uint8_t *p; + uint16_t coordCkhsum = 0x5A; //since v01.12.01 + uint16_t recvCkhsum = 0x00; + + if (ts_data->irq_wait_mode == STDEV_IRQ_WAITMODE_RAW) { + ts_data->irq_wait_flag = 1; + wake_up_interruptible(&ts_data->irq_wait_queue); + // return IRQ_HANDLED; + return; + } + + sitronix_mt_pause_one(); + + mutex_lock(&ts_data->mutex); + + ret = sitronix_ts_reg_read(ts_data, TOUCH_INFO, ts_data->coord_buf, + read_len); + if (ret < 0) { + sterr("%s: Read finger touch error!(%d)\n", __func__, ret); + goto exit_invalid_data; + } + + if (ts_data->coord_buf[0] & 0x80) { + /* ESD check fail */ + sterr("Firmware RstChip = 1 , reset device\n"); +#ifdef SITRONIX_HDL_IN_IRQ + sitronix_ts_pen_allup(ts_data); + sitronix_ts_reset_device(ts_data); + ts_data->is_reset_chip = true; + goto exit_invalid_data; +#else + sitronix_ts_pen_allup(ts_data); + sitronix_ts_reset_device(ts_data); +#endif + } + + if (ts_data->exdiff_flag) { //enable ex-diff data + sitronix_ts_get_exdiff(ts_data, ts_data->exdiff_buf); + } + + //if((ts_data->coord_buf[0] & 0x0A) == 0x0A){ + if (ts_data->is_support_coord_chksum) { + /* support coord checksum*/ + STChecksumCalculation(&coordCkhsum, ts_data->coord_buf, + 4); //part 1 + if (ts_data->coord_buf[0] & 0x08) { + //with Coord + STChecksumCalculation( + &coordCkhsum, ts_data->coord_buf + 4, + (ts_data->ts_dev_info.max_touches * + 7)); //part 2 + } + //coordCkhsum = coordCkhsum & 0xFF; + recvCkhsum = ts_data->coord_buf[read_len - 1]; + + coordCkhsum = coordCkhsum & 0xFF; + + if (coordCkhsum != recvCkhsum) { + sterr("coord checksum error: expect = 0x%02X, received = 0x%02X\n", + coordCkhsum, recvCkhsum); + goto exit_invalid_data; + } + } + + if (!ts_data->in_suspend) { + touch_count = 0; + p = &ts_data->coord_buf[4]; + for (i = 0; i < ts_data->ts_dev_info.max_touches; i++) { + if (*p & 0x80) { + touch_count++; + x = (uint16_t)(((uint16_t)(*p & 0x3F) << 8) | + ((uint16_t)*(p + 1) & 0xFF)); + y = (uint16_t)(((uint16_t)(*(p + 2) & 0x3F) + << 8) | + ((uint16_t)*(p + 3) & 0xFF)); + z = *(p + 4); + + sitronix_ts_pen_down(ts_data, i, x, y); + } else { +#ifdef SITRONIX_TS_MT_SLOT + sitronix_ts_pen_up(ts_data->input_dev, i); +#endif /* SITRONIX_TS_MT_SLOT */ + } + p += 7; + } +#ifndef SITRONIX_TS_MT_SLOT + if (touch_count == 0) + sitronix_ts_pen_up(ts_data->input_dev, 0); +#endif /* SITRONIX_TS_MT_SLOT */ + input_report_key(ts_data->input_dev, BTN_TOUCH, + (touch_count > 0)); + input_sync(ts_data->input_dev); + } + +exit_invalid_data: + + if (ts_data->irq_wait_mode == STDEV_IRQ_WAITMODE_COORD) { + ts_data->irq_wait_flag = 1; + wake_up_interruptible(&ts_data->irq_wait_queue); + } + mutex_unlock(&ts_data->mutex); +} + +static irqreturn_t sitronix_ts_irq_handler(int irq, void *data) +{ + struct sitronix_ts_data *ts_data = (struct sitronix_ts_data *)data; + + sitronix_process_events(ts_data); + return IRQ_HANDLED; +} + +/* Timer poll function */ +static void sitronix_ts_irq_poll_timer(struct timer_list *t) +{ + struct sitronix_ts_data *ts_data = + container_of(t, struct sitronix_ts_data, timer); + + schedule_work(&ts_data->work_i2c_poll); /* schedule work queue */ + mod_timer(&ts_data->timer, + jiffies + msecs_to_jiffies(POLL_INTERVAL_MS)); +} + +static void sitronix_ts_work_i2c_poll(struct work_struct *work) +{ + struct sitronix_ts_data *ts_data = + container_of(work, struct sitronix_ts_data, work_i2c_poll); + + sitronix_process_events(ts_data); +} + +void sitronix_enable_irq(struct sitronix_ts_data *ts_data) +{ + if (ts_data->irq) { + dev_dbg(&ts_data->pdev->dev, "%s - 0\n", __func__); + enable_irq(ts_data->irq); + } else { + dev_dbg(&ts_data->pdev->dev, "%s - 1\n", __func__); + ts_data->timer.expires = + jiffies + msecs_to_jiffies(POLL_INTERVAL_MS); + add_timer(&ts_data->timer); + } +} + +void sitronix_disable_irq(struct sitronix_ts_data *ts_data) +{ + if (ts_data->irq) { + dev_dbg(&ts_data->pdev->dev, "%s - 0\n", __func__); + disable_irq(ts_data->irq); + } else { + dev_dbg(&ts_data->pdev->dev, "%s - 1\n", __func__); + timer_delete(&ts_data->timer); + cancel_work_sync(&ts_data->work_i2c_poll); + } +} + +static void sitronix_free_irq(struct sitronix_ts_data *ts_data) +{ + if (ts_data->irq) { + devm_free_irq(&ts_data->pdev->dev, ts_data->irq, ts_data); + } else { + timer_delete(&ts_data->timer); + cancel_work_sync(&ts_data->work_i2c_poll); + } +} + +static int sitronix_request_irq(struct sitronix_ts_data *ts_data) +{ + if (ts_data->irq) { + dev_dbg(&ts_data->pdev->dev, "%s - 0\n", __func__); + dev_dbg(&ts_data->pdev->dev, "%s - irq = %d\n", __func__, + ts_data->irq); + return devm_request_threaded_irq(&ts_data->pdev->dev, + ts_data->irq, NULL, + sitronix_ts_irq_handler, + ts_data->irq_flags, + ts_data->name, ts_data); + } else { /* poll when no IRQ */ + dev_dbg(&ts_data->pdev->dev, "%s - 1\n", __func__); + INIT_WORK(&ts_data->work_i2c_poll, + sitronix_ts_work_i2c_poll); /* init work queue */ + timer_setup(&ts_data->timer, sitronix_ts_irq_poll_timer, + 0); /* init timer */ + sitronix_enable_irq(ts_data); + return 0; + } +} + +int sitronix_ts_reset_device(struct sitronix_ts_data *ts_data) +{ + return 0; +} + +static void sitronix_ts_input_set_params(struct sitronix_ts_data *ts_data) +{ + struct sitronix_ts_device_info *ts_dev_info = &ts_data->ts_dev_info; + +#ifdef SITRONIX_TS_MT_SLOT + input_mt_init_slots(ts_data->input_dev, ts_dev_info->max_touches, + INPUT_MT_DIRECT); + set_bit(INPUT_PROP_DIRECT, ts_data->input_dev->propbit); + input_set_abs_params(ts_data->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, + 0); + input_set_abs_params(ts_data->input_dev, ABS_MT_PRESSURE, 0, 255, 0, 0); + input_set_abs_params(ts_data->input_dev, ABS_MT_TRACKING_ID, 0, + ts_dev_info->max_touches, 0, 0); +#else /* SITRONIX_TS_MT_SLOT */ + set_bit(ABS_X, ts_data->input_dev->absbit); + set_bit(ABS_Y, ts_data->input_dev->absbit); + set_bit(ABS_MT_TOUCH_MAJOR, ts_data->input_dev->absbit); + set_bit(ABS_MT_TOUCH_MINOR, ts_data->input_dev->absbit); + set_bit(ABS_MT_POSITION_X, ts_data->input_dev->absbit); + set_bit(ABS_MT_POSITION_Y, ts_data->input_dev->absbit); + set_bit(ABS_MT_TOOL_TYPE, ts_data->input_dev->absbit); + set_bit(ABS_MT_BLOB_ID, ts_data->input_dev->absbit); + set_bit(ABS_MT_TRACKING_ID, ts_data->input_dev->absbit); + set_bit(INPUT_PROP_DIRECT, ts_data->input_dev->propbit); + input_set_abs_params(ts_data->input_dev, ABS_MT_TRACKING_ID, 0, + ts_dev_info->max_touches, 0, 0); + input_set_abs_params(ts_data->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, + 0); + input_set_abs_params(ts_data->input_dev, ABS_MT_TOUCH_MINOR, 0, 255, 0, + 0); + input_set_abs_params(ts_data->input_dev, ABS_MT_PRESSURE, 0, 255, 0, 0); +#endif /* SITRONIX_TS_MT_SLOT */ + input_set_abs_params(ts_data->input_dev, ABS_MT_POSITION_X, 0, + (ts_dev_info->x_res - 1), 0, 0); + input_set_abs_params(ts_data->input_dev, ABS_MT_POSITION_Y, 0, + (ts_dev_info->y_res - 1), 0, 0); +} + +static int sitronix_ts_input_dev_init(struct sitronix_ts_data *ts_data) +{ + int ret = 0; + + ts_data->input_dev = input_allocate_device(); + if (ts_data->input_dev == NULL) { + sterr("%s: Can not allocate input device!\n", __func__); + return -ENOMEM; + } + + ts_data->input_dev->name = ts_data->name; + /* ts_data->input_dev->phys = SITRONIX_TS_INPUT_PHYS_NAME; */ + ts_data->input_dev->id.bustype = ts_data->host_if->bus_type; + ts_data->input_dev->id.product = 0; + ts_data->input_dev->id.version = 0; + ts_data->input_dev->dev.parent = ts_data->pdev->dev.parent; + input_set_drvdata(ts_data->input_dev, ts_data); + + set_bit(EV_SYN, ts_data->input_dev->evbit); + set_bit(EV_KEY, ts_data->input_dev->evbit); + set_bit(EV_ABS, ts_data->input_dev->evbit); + set_bit(BTN_TOUCH, ts_data->input_dev->keybit); + /* set_bit(KEY_POWER, ts_data->input_dev->keybit); */ + /* set_bit(KEY_MENU, ts_data->input_dev->keybit); */ + sitronix_ts_input_set_params(ts_data); + touchscreen_parse_properties(ts_data->input_dev, true, &ts_data->prop); + + ret = input_register_device(ts_data->input_dev); + if (ret) { + sterr("%s: Failed to register input device\n", __func__); + goto err_register_input; + } + + return 0; + +err_register_input: + input_free_device(ts_data->input_dev); + ts_data->input_dev = NULL; + + return ret; +} + +static bool sitronix_ts_check_ic_sfrver(void) +{ + int ret = 0; + + ret = sitronix_get_chip_id(); + gts->ts_dev_info.chip_id = ret; + stmsg("IC Chip ID = 0x%X\n", ret); + + ret = sitronix_get_ic_sfrver(); + gts->ts_dev_info.chip_ver = ret; + stmsg("IC SFR VER = 0x%X\n", ret); + + return true; +} + +/** + * sitronix_ts_probe() + * + */ +static int sitronix_ts_probe(struct platform_device *pdev) +{ + int ret; + struct sitronix_ts_data *ts_data = NULL; + const struct sitronix_ts_host_interface *host_if; + int irq; + int status; + + wbuf = NULL; + rbuf = NULL; + + stmsg("%s:%u\n", __func__, __LINE__); + + ST_START_PRINT; + host_if = pdev->dev.platform_data; + if (!host_if) { + sterr("%s: No hardware interface found!\n", __func__); + return -EINVAL; + } + + ts_data = kzalloc(sizeof(*ts_data), GFP_KERNEL); + if (!ts_data) { + sterr("%s: Alloc memory for ts_data failed!\n", __func__); + return -ENOMEM; + } + + mutex_init(&ts_data->mutex); + + ts_data->skip_first_resume = true; + ts_data->name = pdev->name; + ts_data->pdev = pdev; + ts_data->host_if = host_if; + ts_data->in_suspend = false; + ts_data->wr_len = STDEV_WR_DF; + ts_data->fw_request_status = 0; //not ready + ts_data->exdiff_flag = false; +#if defined(CONFIG_FB) || defined(CONFIG_DRM) + ts_data->workqueue = NULL; +#endif //defined(CONFIG_FB) || defined(CONFIG_DRM) + ts_data->sitronix_kobj = NULL; + gts = ts_data; + + platform_set_drvdata(pdev, ts_data); + + wbuf = kzalloc((SITRONIX_RW_BUF_LEN + 32), GFP_KERNEL); + if (!wbuf) { + sterr("%s: Alloc memory for wbuf failed!\n", __func__); + ret = -ENOMEM; + goto err_return; + } + rbuf = kzalloc((SITRONIX_RW_BUF_LEN + 32), GFP_KERNEL); + if (!rbuf) { + sterr("%s: Alloc memory for rbuf failed!\n", __func__); + ret = -ENOMEM; + goto err_return; + } + + sitronix_ts_reset_device(ts_data); + if (!sitronix_ts_check_ic_sfrver()) { + sterr("%s: Failed to sitronix_ts_check_ic_sfrver\n", __func__); + ret = -EINVAL; + goto err_return; + } + sitronix_replace_dump_buf(NULL); + +#ifdef SITRONIX_HDL_IN_PROBE +#ifndef ST_SKIP_HDL_IN_PROBE + ret = sitronix_do_upgrade(); + if (ret < 0) { + sterr("%s: Failed to Host Download!\n", __func__); + ret = -EINVAL; + goto err_return; + } +#endif //ST_SKIP_HDL_IN_PROBE +#else //SITRONIX_HDL_IN_PROBE + sitronix_ts_reset_device(ts_data); +#endif //SITRONIX_HDL_IN_PROBE + +#ifndef ST_SKIP_HDL_IN_PROBE + status = sitronix_ts_get_device_status(ts_data); + ret = sitronix_ts_get_device_info(ts_data); /* get TP device info */ + if (ret) { + sterr("%s: Failed to get device info.\n", __func__); +#ifndef SITRONIX_TP_WITH_FLASH + ret = -EINVAL; + goto err_return; +#endif //SITRONIX_TP_WITH_FLASH + } +#else //ST_SKIP_HDL_IN_PROBE + status = 0; + ts_data->skip_first_resume = false; + //set default information + ts_data->ts_dev_info.x_res = ST_DEFAULT_RES_X; + ts_data->ts_dev_info.y_res = ST_DEFAULT_RES_Y; + ts_data->ts_dev_info.max_touches = ST_DEFAULT_MAX_TOUCH; +#endif //ST_SKIP_HDL_IN_PROBE + +#ifdef SITRONIX_FLASH_UPGRADE_IN_PROBE + ret = sitronix_do_upgrade(); + if (ret < 0) { + sterr("%s: Failed to Upgrade Flash!\n", __func__); + ret = -EINVAL; + goto err_return; + } +#endif //SITRONIX_FLASH_UPGRADE_IN_PROBE + + ret = sitronix_ts_input_dev_init(ts_data); + if (ret) { + sterr("%s: Failed to set up input device\n", __func__); + ret = -EINVAL; + goto err_return; + } + + irq = gpio_to_irq(host_if->irq_gpio); + if (irq > 0) + ts_data->irq = irq; + sitronix_request_irq(ts_data); + +#if defined(CONFIG_FB) + ts_data->workqueue = + create_singlethread_workqueue("sitronix_ts_workqueue"); + if (!ts_data->workqueue) { + sterr("create sitronix_ts_workqueue fail"); + ret = -ENOMEM; + goto err_return; + } + INIT_WORK(&ts_data->resume_work, sitronix_ts_resume_work); +#ifdef _MSM_DRM_NOTIFY_H_ + ts_data->drm_notif.notifier_call = sitronix_drm_notifier_callback; + ret = msm_drm_register_client(&ts_data->drm_notif); + if (ret) { + sterr("register drm_notifier failed. ret=%d\n", ret); + ret = -EINVAL; + goto err_return; + } +#else + ts_data->fb_notif.notifier_call = sitronix_fb_notifier_callback; + ret = fb_register_client(&ts_data->fb_notif); + if (ret) { + sterr("register fb_notifier failed. ret=%d\n", ret); + ret = -EINVAL; + goto err_return; + } +#endif +#elif defined(CONFIG_DRM) + ts_data->workqueue = + create_singlethread_workqueue("sitronix_ts_workqueue"); + if (!ts_data->workqueue) { + sterr("create sitronix_ts_workqueue fail"); + ret = -ENOMEM; + goto err_return; + } + INIT_WORK(&ts_data->resume_work, sitronix_ts_resume_work); + + ts_data->drm_notif.notifier_call = sitronix_drm_notifier_callback; +#if defined(CONFIG_DRM_PANEL) + if (ts_data->active_panel) { + ret = drm_panel_notifier_register(ts_data->active_panel, + &ts_data->drm_notif); + if (ret) + sterr("[DRM]drm_panel_notifier_register fail: %d\n", + ret); + } +#else + ret = msm_drm_register_client(&ts_data->drm_notif); + if (ret) { + sterr("register drm_notifier failed. ret=%d\n", ret); + ret = -EINVAL; + goto err_return; + } +#endif /* CONFIG_DRM_PANEL */ +#elif defined(CONFIG_HAS_EARLYSUSPEND) + ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1; + ts->early_suspend.suspend = sitronix_ts_early_suspend; + ts->early_suspend.resume = sitronix_ts_late_resume; + ret = register_early_suspend(&ts_data->early_suspend); + if (ret) { + sterr("register early suspend failed. ret=%d\n", ret); + ret = -EINVAL; + goto err_return; + } +#endif + + sitronix_mode_backup(); //Backup mode from device. + sitronix_swk_config_backup(); //Backup SWK config from device. + +#ifdef SITRONIX_MONITOR_THREAD + ts_data->enable_monitor_thread = true; + ts_data->sitronix_mt_fp = sitronix_ts_monitor_thread_v3; + sitronix_mt_start(DELAY_MONITOR_THREAD_START_PROBE); +#endif /* SITRONIX_MONITOR_THREAD */ + + //return ret; + return 0; + +err_return: + +#if defined(CONFIG_FB) + if (ts_data->workqueue) + destroy_workqueue(ts_data->workqueue); +#ifdef _MSM_DRM_NOTIFY_H_ + if (msm_drm_unregister_client(&ts->drm_notif)) + sterr("Error occurred while unregistering drm_notifier.\n"); +#else + if (fb_unregister_client(&ts_data->fb_notif)) + sterr("Error occurred while unregistering fb_notifier.\n"); +#endif +#elif defined(CONFIG_DRM) + if (ts_data->workqueue) + destroy_workqueue(ts_data->workqueue); +#if defined(CONFIG_DRM_PANEL) + if (ts_data->active_panel) + drm_panel_notifier_unregister(ts_data->active_panel, + &ts_data->drm_notif); +#endif /* CONFIG_DRM_PANEL */ +#elif defined(CONFIG_HAS_EARLYSUSPEND) + unregister_early_suspend(&ts_data->early_suspend); +#endif + +#ifdef SITRONIX_MONITOR_THREAD + sitronix_mt_stop(); +#endif /* SITRONIX_MONITOR_THREAD */ + + if (ts_data->irq > 0) + free_irq(ts_data->irq, ts_data); + + if (ts_data->input_dev) { + input_unregister_device(ts_data->input_dev); + // input_free_device(ts_data->input_dev); + ts_data->input_dev = NULL; + } + + kfree(rbuf); + rbuf = NULL; + + kfree(wbuf); + wbuf = NULL; + + mutex_destroy(&ts_data->mutex); + + if (ts_data) { + platform_set_drvdata(pdev, NULL); + kfree(ts_data); + gts = NULL; + } + + return ret; +} + +static void sitronix_ts_remove(struct platform_device *pdev) +{ + //struct sitronix_ts_data *ts_data = platform_get_drvdata(pdev); + struct sitronix_ts_data *ts_data = NULL; + + stmsg("%s:%u\n", __func__, __LINE__); + + ts_data = platform_get_drvdata(pdev); + +#ifdef SITRONIX_MONITOR_THREAD + if (ts_data) + sitronix_mt_stop(); +#endif /* SITRONIX_MONITOR_THREAD */ + +#if defined(CONFIG_FB) + if (ts_data && ts_data->workqueue) + destroy_workqueue(ts_data->workqueue); +#ifdef _MSM_DRM_NOTIFY_H_ + if (ts_data && msm_drm_unregister_client(&ts_data->drm_notif)) + sterr("Error occurred while unregistering drm_notifier.\n"); +#else + if (ts_data && fb_unregister_client(&ts_data->fb_notif)) + sterr("Error occurred while unregistering fb_notifier.\n"); +#endif +#elif defined(CONFIG_DRM) + if (ts_data && ts_data->workqueue) + destroy_workqueue(ts_data->workqueue); +#if defined(CONFIG_DRM_PANEL) + if (ts_data && ts_data->active_panel) + drm_panel_notifier_unregister(ts_data->active_panel, + &ts_data->drm_notif); +#endif /* CONFIG_DRM_PANEL */ +#elif defined(CONFIG_HAS_EARLYSUSPEND) + if (ts_data) + unregister_early_suspend(&ts_data->early_suspend); +#endif + + if (ts_data) + sitronix_free_irq(ts_data); + + if (ts_data && ts_data->input_dev) { + input_unregister_device(ts_data->input_dev); + // input_free_device(ts_data->input_dev); + } + + if (ts_data) + mutex_destroy(&ts_data->mutex); + + kfree(rbuf); + rbuf = NULL; + + kfree(wbuf); + wbuf = NULL; + + kfree(ts_data); +} + +#if (defined(CONFIG_FB) || defined(CONFIG_DRM)) +static int sitronix_ts_suspend(struct device *dev) +{ + /* struct sitronix_ts_data *ts_data = dev_get_drvdata(dev); */ + + /* stdbg("%s:%u, ts_data=0x%x\n", __FUNCTION__, __LINE__, (uint32_t)ts_data); */ + stmsg("run %s\n", __func__); + + gts->skip_first_resume = false; + mutex_lock(>s->mutex); + /* + * if (gts->in_suspend) { + * stdbg("%s:%u, Already in suspend!\n", __func__, __LINE__); + * mutex_unlock(>s->mutex); + * return 0; + * } + */ + +#ifdef SITRONIX_MONITOR_THREAD +#ifdef MONITOR_THREAD_STOP_IN_SUSPEND + sitronix_mt_stop(); +#endif /* MONITOR_THREAD_STOP_IN_SUSPEND */ +#endif /* SITRONIX_MONITOR_THREAD */ + + // sitronix_ts_irq_enable(gts, false); + sitronix_disable_irq(gts); + + msleep(20); + sitronix_ts_powerdown(gts, true); + usleep_range(10000, 11000); + + sitronix_ts_pen_allup(gts); + + gts->in_suspend = true; + mutex_unlock(>s->mutex); + return 0; +} + +static int sitronix_ts_resume(struct device *dev) +{ + /* struct sitronix_ts_data *ts_data = dev_get_drvdata(dev); */ + /* stdbg("%s:%u, ts_data=0x%x\n", __FUNCTION__, __LINE__, (uint32_t)ts_data); */ + stmsg("run %s\n", __func__); + + if (gts->skip_first_resume) { + gts->skip_first_resume = false; + return 0; + } +#ifdef SITRONIX_TP_RESUME_BEFORE_DISPON + msleep(SITRONIX_RESUME_DELAY); +#endif /* SITRONIX_TP_RESUME_BEFORE_DISPON */ + mutex_lock(>s->mutex); +#ifdef SITRONIX_TP_WITH_FLASH + sitronix_ts_reset_device(gts); +#endif + +#ifdef SITRONIX_HDL_IN_RESUME + sitronix_do_upgrade(); +#endif /* SITRONIX_HDL_IN_RESUME */ + + sitronix_ts_powerdown(gts, false); + /* kthread_run(sitronix_ts_powerdown_thread, gts, "Sitronix powerdown Thread"); */ + /* msleep(200); */ + /* sitronix_ts_reset_device(gts); */ + + // sitronix_ts_irq_enable(gts, true); + sitronix_enable_irq(gts); + + gts->in_suspend = false; + + sitronix_mode_restore(); + sitronix_swk_config_restore(); + mutex_unlock(>s->mutex); + +#ifdef SITRONIX_MONITOR_THREAD +#ifdef MONITOR_THREAD_STOP_IN_SUSPEND + sitronix_mt_start(DELAY_MONITOR_THREAD_START_RESUME); +#else + +#endif /* MONITOR_THREAD_STOP_IN_SUSPEND */ +#endif /* SITRONIX_MONITOR_THREAD */ + return 0; +} + +static void sitronix_ts_resume_work(struct work_struct *work) +{ + sitronix_ts_resume(>s->pdev->dev); +} +#endif + +#if defined(CONFIG_FB) +#ifdef _MSM_DRM_NOTIFY_H_ +static int sitronix_drm_notifier_callback(struct notifier_block *self, + unsigned long event, void *data) +{ + struct msm_drm_notifier *evdata = data; + int *blank; + struct ts_sitronix *ts = + container_of(self, struct ts_sitronix, drm_notif); + + if (!evdata || (evdata->id != 0)) + return 0; + + if (evdata->data && ts) { + blank = evdata->data; +#ifdef SITRONIX_TP_RESUME_BEFORE_DISPON + if (event == MSM_DRM_EARLY_EVENT_BLANK) { + if (*blank == MSM_DRM_BLANK_UNBLANK) { + //stdbg("event=%lu, *blank=%d\n", event, *blank); + queue_work(ts->workqueue, &ts->resume_work); + //sitronix_ts_resume(&ts->pdev->dev); + } + } +#endif /* SITRONIX_TP_RESUME_BEFORE_DISPON */ + if (event == MSM_DRM_EVENT_BLANK) { + if (*blank == MSM_DRM_BLANK_POWERDOWN) { + //stdbg("event=%lu, *blank=%d\n", event, *blank); + cancel_work_sync(&ts->resume_work); + sitronix_ts_suspend(&ts->pdev->dev); + } +#ifndef SITRONIX_TP_RESUME_BEFORE_DISPON + if (*blank == MSM_DRM_BLANK_UNBLANK) { + //stdbg("event=%lu, *blank=%d\n", event, *blank); + queue_work(ts->workqueue, &ts->resume_work); + } +#endif /* SITRONIX_TP_RESUME_BEFORE_DISPON */ + } + } + + return 0; +} +#else +static int sitronix_fb_notifier_callback(struct notifier_block *self, + unsigned long event, void *data) +{ + struct fb_event *evdata = data; + int *blank; + struct sitronix_ts_data *ts = + container_of(self, struct sitronix_ts_data, fb_notif); + //blank = evdata->data; + //stmsg("event = 0x%02X ,blank = 0x%02X\n",(int)event , *blank); + //stmsg("event = 0x%02X\n",(int)event ); +#ifdef SITRONIX_TP_RESUME_BEFORE_DISPON + if (evdata && evdata->data && event == FB_EARLY_EVENT_BLANK) { + blank = evdata->data; + if (*blank == FB_BLANK_UNBLANK) { + /* stmsg("event=%lx, *blank=%d\n", event, *blank); */ + queue_work(ts->workqueue, &ts->resume_work); + //sitronix_ts_resume(&ts->pdev->dev); + } + } +#endif /* SITRONIX_TP_RESUME_BEFORE_DISPON */ + + if (evdata && evdata->data && event == FB_EVENT_BLANK) { + blank = evdata->data; + if (*blank == FB_BLANK_POWERDOWN) { + /* stmsg("event=%lx, *blank=%d\n", event, *blank); */ + cancel_work_sync(&ts->resume_work); + sitronix_ts_suspend(&ts->pdev->dev); + } +#ifndef SITRONIX_TP_RESUME_BEFORE_DISPON + if (*blank == FB_BLANK_UNBLANK) { + /* stmsg("event=%lu, *blank=%d\n", event, *blank); */ + /* sitronix_ts_resume(&ts->pdev->dev); */ + queue_work(ts->workqueue, &ts->resume_work); + } +#endif /* SITRONIX_TP_RESUME_BEFORE_DISPON */ + } + return 0; +} +#endif + +#elif defined(CONFIG_DRM) +static void sitronix_ts_resume_work(struct work_struct *work) +{ + sitronix_ts_resume(>s->pdev->dev); +} +#if defined(CONFIG_DRM_PANEL) +static int sitronix_drm_notifier_callback(struct notifier_block *self, + unsigned long event, void *data) +{ + struct drm_panel_notifier *evdata = data; + int *blank; + struct sitronix_ts_data *ts = + container_of(self, struct sitronix_ts_data, drm_notif); + /* blank = evdata->data; */ + /* stmsg("event = 0x%02X ,blank = 0x%02X\n",(int)event , *blank); */ + /* stmsg("event = 0x%02X\n",(int)event ); */ +#ifdef SITRONIX_TP_RESUME_BEFORE_DISPON + if (evdata && evdata->data && event == DRM_PANEL_EARLY_EVENT_BLANK) { + blank = evdata->data; + if (*blank == DRM_PANEL_BLANK_UNBLANK) { + stmsg("event=%lx, *blank=%d\n", event, *blank); + queue_work(ts->workqueue, &ts->resume_work); + //sitronix_ts_resume(&ts->pdev->dev); + } + } +#endif /* SITRONIX_TP_RESUME_BEFORE_DISPON */ + + if (evdata && evdata->data && event == DRM_PANEL_EVENT_BLANK) { + blank = evdata->data; + if (*blank == DRM_PANEL_BLANK_POWERDOWN) { + stmsg("event=%lx, *blank=%d\n", event, *blank); + cancel_work_sync(&ts->resume_work); + sitronix_ts_suspend(&ts->pdev->dev); + } +#ifndef SITRONIX_TP_RESUME_BEFORE_DISPON + if (*blank == DRM_PANEL_BLANK_UNBLANK) { + stmsg("event=%lu, *blank=%d\n", event, *blank); + /* sitronix_ts_resume(&ts->pdev->dev); */ + queue_work(ts->workqueue, &ts->resume_work); + } +#endif /* SITRONIX_TP_RESUME_BEFORE_DISPON */ + } + return 0; +} +#endif /* CONFIG_DRM_PANEL */ +#elif defined(CONFIG_HAS_EARLYSUSPEND) +static void sitronix_ts_early_suspend(struct early_suspend *h) +{ + struct sitronix_ts_data *ts_data = + container_of(h, struct sitronix_ts_data, early_suspend); + + sitronix_ts_suspend(&ts_data->pdev->dev); +} + +static void sitronix_ts_late_resume(struct early_suspend *h) +{ + struct sitronix_ts_data *ts_data = + container_of(h, struct sitronix_ts_data, early_suspend); + + sitronix_ts_resume(&ts_data->pdev->dev); +} +#endif /* CONFIG_HAS_EARLYSUSPEND */ + +//#ifdef CONFIG_PM +#if (!defined(CONFIG_FB) && !defined(CONFIG_HAS_EARLYSUSPEND) && \ + defined(CONFIG_PM)) +static int sitronix_pm_suspend(struct device *dev) +{ + stmsg("pm suspend\n"); + return 0; +} + +static int sitronix_pm_resume(struct device *dev) +{ + stmsg("pm resume"); + return 0; +} + +static const struct dev_pm_ops sitronix_ts_dev_pm_ops = { + .suspend = sitronix_pm_suspend, + .resume = sitronix_pm_resume, +}; +#endif /* CONFIG_PM */ + +#ifdef SITRONIX_INTERFACE_I2C +static struct platform_driver sitronix_ts_i2c_driver = { + .driver = { + .name = SITRONIX_TS_I2C_DRIVER_NAME, + .owner = THIS_MODULE, +//#ifdef CONFIG_PM +#if (!defined(CONFIG_FB) && !defined(CONFIG_HAS_EARLYSUSPEND) && \ + defined(CONFIG_PM)) + .pm = &sitronix_ts_dev_pm_ops, +#endif + }, + .probe = sitronix_ts_probe, + /*.remove = __exit_p(sitronix_ts_remove),*/ + .remove = sitronix_ts_remove, +}; +#endif /* SITRONIX_INTERFACE_I2C */ + +void sitronix_ts_reset_input_dev(void) +{ + stmsg("sitronix_ts_reprobe!\n"); + if (gts->input_dev) { + sitronix_ts_get_device_info(gts); + input_unregister_device(gts->input_dev); + // input_free_device(gts->input_dev); + + sitronix_ts_input_dev_init(gts); + } +} + +static int __init sitronix_ts_init(void) +{ + int ret; + + stmsg("%s\n", SITRONIX_TP_DRIVER_VERSION); + +#ifdef SITRONIX_INTERFACE_I2C + ret = sitronix_ts_i2c_init(); + if (ret == 0) + platform_driver_register(&sitronix_ts_i2c_driver); +#endif /* #SITRONIX_INTERFACE_I2C */ + return ret; +} + +static void __exit sitronix_ts_exit(void) +{ +#ifdef SITRONIX_INTERFACE_I2C + platform_driver_unregister(&sitronix_ts_i2c_driver); + sitronix_ts_i2c_exit(); +#endif /* #ifdef SITRONIX_INTERFACE_I2C */ +} + +late_initcall(sitronix_ts_init); +// module_init(sitronix_ts_init); +module_exit(sitronix_ts_exit); + +MODULE_AUTHOR("Sitronix Technology Co., Ltd."); +MODULE_DESCRIPTION("Sitronix Touchscreen Controller Driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/input/touchscreen/sitronix_st7123/sitronix_ts.h b/drivers/input/touchscreen/sitronix_st7123/sitronix_ts.h new file mode 100644 index 00000000000000..fbe013f87e6c4c --- /dev/null +++ b/drivers/input/touchscreen/sitronix_st7123/sitronix_ts.h @@ -0,0 +1,557 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Sitronix Touchscreen Controller Driver + * + * Copyright (C) 2018 Sitronix Technology Co., Ltd. + * CT Chen + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#ifndef __SITRONIX_TS_H__ +#define __SITRONIX_TS_H__ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define SITRONIX_PLATFORM_NORMAL + +#include +#include + +#if defined(CONFIG_FB) +#ifdef CONFIG_DRM_MSM +#include +#endif +#ifdef CONFIG_DRM +#include +#endif +#elif defined(CONFIG_DRM) +#if defined(CONFIG_DRM_PANEL) +#include +#endif /* CONFIG_DRM_PANEL */ +#elif defined(CONFIG_HAS_EARLYSUSPEND) +#include +#endif + +/* FB_EVENT_BLANK was removed in Linux 6.11+, define if missing */ +#ifndef FB_EVENT_BLANK +#define FB_EVENT_BLANK 0x09 +#endif + +#ifndef FB_EARLY_EVENT_BLANK +#define FB_EARLY_EVENT_BLANK FB_EVENT_BLANK +#endif //FB_EARLY_EVENT_BLANK + +#ifndef usleep +#define usleep(n) usleep_range(n, n + 10) +#endif //usleep + +#define SITRONIX_TP_DRIVER_VERSION "Sitronix TDDI Touch Driver v43.00.250117" + +#define SITRONIX_INTERFACE_I2C +#define SITRONIX_TP_WITH_FLASH + +#define SITRONIX_MONITOR_THREAD +#define SITRONIX_TS_MT_SLOT +#define SITRONIX_DO_TP_HW_RESET +#define SITRONIX_PROC_DIR_CREATE +#define SITRONIX_TP_RESUME_BEFORE_DISPON +//#define SITRONIX_TS_FLIP_X +//#define SITRONIX_TS_FLIP_Y + +#ifdef SITRONIX_INTERFACE_I2C +//# define SITRONIX_I2C_ADDRESS_DETECT +#define ST_PLATFORM_WRITE_LEN_MAX 0x100 +#define ST_PLATFORM_READ_LEN_MAX 0x100 +#define ST_ICP_READ_BLOCK_SIZE ST_PLATFORM_READ_LEN_MAX +#endif + +#ifdef SITRONIX_TP_WITH_FLASH /* factory programmed FW */ +#define SITRONIX_FLASH_CHECK_FWVER +#define SITRONIX_FLASH_CFG_TAB_VER_OFF 0x0E +//# define SITRONIX_FLASH_UPGRADE_IN_PROBE +#else +#define SITRONIX_HDL_IN_PROBE +#define SITRONIX_HDL_IN_RESUME +#define SITRONIX_HDL_IN_MT +#define SITRONIX_HDL_IN_IRQ +#define SITRONIX_HDL_VALIDATE_BY_RANDOM +//# define ST_SKIP_HDL_IN_PROBE +#endif /* SITRONIX_TP_WITH_FLASH */ + +#define ST_UPGRADE_USE_REQUESTFW_BUF +#define ST_REQUESTFW_DF_PATH "st7123.dump" + +#ifdef ST_SKIP_HDL_IN_PROBE +#define ST_DEFAULT_RES_X 720 +#define ST_DEFAULT_RES_Y 1600 +#define ST_DEFAULT_MAX_TOUCH 10 +#endif //ST_SKIP_HDL_IN_PROBE + +#ifdef SITRONIX_PROC_DIR_CREATE +#define SITRONIX_PROC_DIR_NAME "sitronix" +#endif /* SITRONIX_PROC_DIR_CREATE */ + +#define SITRONIX_TS_I2C_DRIVER_NAME "sitronix_ts_i2c" + +struct sitronix_ts_i2c_data { + struct i2c_client *client; +}; + +#define SITRONIX_TS_SPI_DRIVER_NAME "sitronix_ts_spi" + +struct sitronix_ts_spi_data { + struct spi_device *spi_dev; + uint32_t spi_max_freq; + uint32_t byte_delay_us; + uint8_t spi_mode; + uint32_t reg; +}; + +#ifdef SITRONIX_TS_MT_SLOT +#include +#endif /* SITRONIX_TS_MT_SLOT */ + +#define sterr(format, ...) pr_debug(format, ##__VA_ARGS__) + +#define stmsg(format, ...) pr_debug(format, ##__VA_ARGS__) + +#define stdbg(format, ...) /* printk("[ST DBG] " format, ## __VA_ARGS__) */ + +#define ST_START_PRINT stmsg("start of %s\n", __func__) + +#define SITRONIX_RW_BUF_LEN 0x1000 + +extern struct sitronix_ts_data *gts; +//extern unsigned char wbuf[SITRONIX_RW_BUF_LEN+8]; +//extern unsigned char rbuf[SITRONIX_RW_BUF_LEN+8]; +extern unsigned char *wbuf; +extern unsigned char *rbuf; + +#define DELAY_MONITOR_THREAD_START_PROBE 10000 +#define DELAY_MONITOR_THREAD_START_RESUME 3000 +#define DELAY_MONITOR_THREAD_PEROID_NORMAL 2000 +#define DELAY_MONITOR_THREAD_PEROID_ERROR 500 +//#define MONITOR_THREAD_STOP_IN_SUSPEND +//#define SITRONIX_MT_CHECK_DIS +#define SITRONIX_MT_DIS_LIMIT 10000 + +#define SITRONIX_RESUME_DELAY 200 //MTK 40, Inforce 200 + +#define ST_DIFF_DATA_TABLE_LEN 101 + +/* TS register addresses */ +enum { + FIRMWARE_VERSION = 0, + STATUS_REG, + DEVICE_CONTROL_REG, + TIMEOUT_TO_IDLE_REG, + X_RESOLUTION_HIGH = 0x05, + X_RESOLUTION_LOW = 0x06, + Y_RESOLUTION_HIGH = 0x07, + Y_RESOLUTION_LOW = 0x08, + MAX_NUM_TOUCHES = 0x09, + SENSING_COUNTER_H = 0x0A, + SENSING_COUNTER_L = 0x0B, + DEVICE_CONTROL_REG2 = 0x09, + FIRMWARE_REVISION_3 = 0x0C, + FIRMWARE_REVISION_2, + FIRMWARE_REVISION_1, + FIRMWARE_REVISION_0, + TOUCH_INFO = 0x10, + GESTURES = 0x12, + PROX_RAW_HEADER = 0x5A, + MISC_INFO = 0xF0, + MISC_CONTROL = 0xF1, + SMART_WAKE_UP_REG = 0xF2, + CHIP_ID = 0xF4, + XY_CHS = 0xF5, + CMDIO_CONTROL = 0xF8, + PAGE_REG = 0xFF, + CMDIO_PORT = 0x110, + EX_DIFF_EN = 0x130, + DATA_OUTPUT_BUFFER = 0x140, +}; + +#define STDEV_IOC_MAGIC 0xF1 + +/* STDEV ioctl function codes */ +enum { + STDEV_WR_DF = 2, + STDEV_GET_DRIVER_INFO = 16, + STDEV_ADDR_MODE_ON = 9, + STDEV_ADDR_MODE_OFF = 10, + STDEV_WRITE_DUMP = 11, + STDEV_READ_DUMP = 12, + STDEV_EXECUTE_UPGRADE = 13, + STDEV_RETURN_MODE = 15, + STDEV_ENABLE_IRQ = 17, + STDEV_DISABLE_IRQ = 18, + STDEV_HW_RESET = 19, + STDEV_IRQ_WAITMODE_DO = 14, + STDEV_IRQ_WAITMODE_RAW = 20, + STDEV_IRQ_WAITMODE_COORD = 21, + STDEV_IRQ_WAITMODE_OFF = 22, + STDEV_CONTINUE_READ = 23, + STDEV_PROXIMITY_STATUS = 24, + STDEV_PROXIMITY_ON = 25, + STDEV_PROXIMITY_OFF = 26, + STDEV_RESET_INPUT_DEV = 27, + STDEV_GET_COORD_BUF = 80, + STDEV_GET_DATA_OUTPUT = 125, + SMT_IOC_MAXNR, +}; + +#define IOCTL_STDEV_GET_DRIVER_INFO \ + _IOC(_IOC_NONE, STDEV_IOC_MAGIC, STDEV_GET_DRIVER_INFO, 0) +#define IOCTL_STDEV_ADDR_MODE_ON \ + _IOC(_IOC_NONE, STDEV_IOC_MAGIC, STDEV_ADDR_MODE_ON, 0) +#define IOCTL_STDEV_ADDR_MODE_OFF \ + _IOC(_IOC_NONE, STDEV_IOC_MAGIC, STDEV_ADDR_MODE_OFF, 0) +#define IOCTL_STDEV_WRITE_DUMP \ + _IOC(_IOC_NONE, STDEV_IOC_MAGIC, STDEV_WRITE_DUMP, 0) +#define IOCTL_STDEV_READ_DUMP \ + _IOC(_IOC_NONE, STDEV_IOC_MAGIC, STDEV_READ_DUMP, 0) +#define IOCTL_STDEV_EXECUTE_UPGRADE \ + _IOC(_IOC_NONE, STDEV_IOC_MAGIC, STDEV_EXECUTE_UPGRADE, 0) +#define IOCTL_STDEV_ENABLE_IRQ \ + _IOC(_IOC_NONE, STDEV_IOC_MAGIC, STDEV_ENABLE_IRQ, 0) +#define IOCTL_STDEV_DISABLE_IRQ \ + _IOC(_IOC_NONE, STDEV_IOC_MAGIC, STDEV_DISABLE_IRQ, 0) +#define IOCTL_STDEV_HW_RESET _IOC(_IOC_NONE, STDEV_IOC_MAGIC, STDEV_HW_RESET, 0) + +#define ST_SWK_CONFIG_LEN 4 + +struct sitronix_ts_device_info { + uint8_t chip_id; + uint8_t fw_version; + uint8_t fw_revision[4]; + uint8_t customer_info[4]; + uint8_t max_touches; + uint16_t x_res; + uint16_t y_res; + uint8_t x_chs; + uint8_t y_chs; + uint8_t k_chs; + uint8_t n_chs; + uint8_t misc_info; + uint8_t chip_ver; + uint8_t max_swk_touch_num; +}; + +struct sitronix_ts_data { + const char *name; + struct platform_device *pdev; + struct input_dev *input_dev; + const struct sitronix_ts_host_interface *host_if; + struct sitronix_ts_device_info ts_dev_info; + struct kobject *sitronix_kobj; + struct touchscreen_properties prop; + +#if defined(CONFIG_FB) + struct workqueue_struct *workqueue; + struct work_struct resume_work; +#ifdef _MSM_DRM_NOTIFY_H_ + struct notifier_block drm_notif; +#else + struct notifier_block fb_notif; +#endif +#elif defined(CONFIG_DRM) + struct workqueue_struct *workqueue; + struct work_struct resume_work; + //#if defined(CONFIG_DRM_PANEL) + struct notifier_block drm_notif; +//#endif /* CONFIG_DRM_PANEL */ +#elif defined(CONFIG_HAS_EARLYSUSPEND) + struct early_suspend early_suspend; +#endif + int irq; + int irq_flags; + bool in_suspend; + struct mutex mutex; + bool skip_first_resume; + + struct timer_list timer; + struct work_struct work_i2c_poll; + + /* coord checksum */ + bool is_support_coord_chksum; + /* MT */ + bool is_pause_mt; + bool upgrade_doing; + int upgrade_result; + char upgrade_msg[100]; + bool is_reset_chip; + bool is_suspend_mt; + + bool enable_monitor_thread; + int sitronix_ts_delay_monitor_thread_start; + struct task_struct *SitronixMonitorThread; + int (*sitronix_mt_fp)(void *data); + + /* CMDIO */ + int cmdio_result; + char cmdio_msg[100]; + int cmdio_rwflag; + uint16_t cmdio_addr[8]; + uint32_t cmdio_len; + int cmdio_iotype; + + /* Mode switch */ + bool mode_flag[20]; + uint8_t mode_value[20]; + + /* SWK config */ + uint8_t swk_config[ST_SWK_CONFIG_LEN]; + uint8_t swk_config_def[ST_SWK_CONFIG_LEN]; + + /* sitronix dev */ + bool wr_mode; + uint8_t wr_len; + uint8_t stdev_mode; + uint8_t cr_mode; + + /* coord buf */ + uint8_t coord_buf[80]; + /* ProxAlgRaw Buf */ + uint8_t prox_raw_buf[130]; + /* IRQ wait mode */ + uint8_t irq_wait_mode; + wait_queue_head_t irq_wait_queue; + uint8_t irq_wait_flag; + + /* self test */ + int self_test_result; + int self_test_short_max; + int self_test_open_min; + int self_test_open_max; + int self_test_open_mux_on_off_min; + int self_test_uniformity_shift; + int self_test_uniformity_min; + int self_test_uniformity_max; + int self_test_std_max; + int self_test_std_square100_max; + int self_test_normal_min; + int self_test_normal_max; + + /* palm suspend */ + uint8_t palm_suspend_frames; + bool palm_suspend_status; + + /* flash powerful upgrade */ + bool flash_powerful_upgrade; + + uint8_t fw_request_status; + + //ExDiff data enable + bool exdiff_flag; + uint8_t ex_diff_pac_num; + int ex_diff_reg_map; + uint8_t exdiff_buf[ST_DIFF_DATA_TABLE_LEN]; +}; + +struct sitronix_ts_host_interface { + uint8_t bus_type; + bool is_use_flash; + int irq_gpio; + uint32_t irq_gpio_flags; + int rst_gpio; + uint32_t rst_gpio_flags; + void *if_data; + int (*read)(uint16_t addr, uint8_t *data, uint16_t length, + void *if_data); + int (*write)(uint16_t addr, uint8_t *data, uint16_t length, + void *if_data); + int (*dread)(uint8_t *data, uint16_t length, void *if_data); + int (*dwrite)(uint8_t *data, uint16_t length, void *if_data); + int (*aread)(uint8_t *tx_buf, uint16_t tx_len, uint8_t *rx_buf, + uint16_t rx_len, void *if_data); + int (*awrite)(uint8_t *tx_buf, uint16_t tx_len, void *if_data); + int (*sread)(uint8_t *tx_buf, uint16_t tx_len, uint8_t *rx_buf, + uint16_t rx_len, void *if_data); + int (*ram_mode_rw)(bool isread, uint16_t cmd, uint16_t addr, + uint8_t *txbuf, uint8_t *rxbuf, int len, + void *if_data); + int (*ram_mode_cmd)(uint16_t cmd, void *if_data); +}; + +extern int sitronix_ts_bus_init(void); + +extern void sitronix_bus_exit(void); + +static inline int sitronix_ts_reg_read(struct sitronix_ts_data *ts_data, + uint16_t addr, uint8_t *data, + uint16_t len) +{ + return ts_data->host_if->read(addr, data, len, + ts_data->host_if->if_data); +} + +static inline int sitronix_ts_reg_write(struct sitronix_ts_data *ts_data, + uint16_t addr, uint8_t *data, + uint16_t len) +{ + return ts_data->host_if->write(addr, data, len, + ts_data->host_if->if_data); +} + +static inline int sitronix_ts_reg_dread(struct sitronix_ts_data *ts_data, + uint8_t *data, uint16_t len) +{ + return ts_data->host_if->dread(data, len, ts_data->host_if->if_data); +} + +static inline int sitronix_ts_reg_dwrite(struct sitronix_ts_data *ts_data, + uint8_t *data, uint16_t len) +{ + return ts_data->host_if->dwrite(data, len, ts_data->host_if->if_data); +} + +static inline int sitronix_ts_addrmode_read(struct sitronix_ts_data *ts_data, + uint8_t *tx_buf, uint16_t tx_len, + uint8_t *rx_buf, uint16_t rx_len) +{ + return ts_data->host_if->aread(tx_buf, tx_len, rx_buf, rx_len, + ts_data->host_if->if_data); +} + +static inline int sitronix_ts_addrmode_write(struct sitronix_ts_data *ts_data, + uint8_t *tx_buf, uint16_t tx_len) +{ + return ts_data->host_if->awrite(tx_buf, tx_len, + ts_data->host_if->if_data); +} + +static inline int +sitronix_ts_addrmode_split_read(struct sitronix_ts_data *ts_data, + uint8_t *tx_buf, uint16_t tx_len, + uint8_t *rx_buf, uint16_t rx_len) +{ + return ts_data->host_if->sread(tx_buf, tx_len, rx_buf, rx_len, + ts_data->host_if->if_data); +} + +static inline int sitronix_ts_ram_mode_rw(struct sitronix_ts_data *ts_data, + bool isread, uint16_t cmd, + uint16_t addr, uint8_t *txbuf, + uint8_t *rxbuf, int len) +{ + return ts_data->host_if->ram_mode_rw(isread, cmd, addr, txbuf, rxbuf, + len, ts_data->host_if->if_data); +} + +static inline int sitronix_ts_ram_mode_cmd(struct sitronix_ts_data *ts_data, + uint16_t cmd) +{ + return ts_data->host_if->ram_mode_cmd(cmd, ts_data->host_if->if_data); +} + +#define EnableDbgMsg +#ifdef EnableDbgMsg +#define DbgMsg(arg...) \ + pr_debug(arg) +#else +#define DbgMsg(arg...) +#endif + +/*sitronix_ts.c*/ +int sitronix_ts_reset_device(struct sitronix_ts_data *ts_data); +// int sitronix_ts_irq_enable(struct sitronix_ts_data *ts_data, bool enable); +void sitronix_enable_irq(struct sitronix_ts_data *ts_data); +void sitronix_disable_irq(struct sitronix_ts_data *ts_data); +void sitronix_ts_reset_input_dev(void); + +/*sitronix_ts_i2c.c*/ +extern int sitronix_ts_i2c_init(void); +extern void sitronix_ts_i2c_exit(void); + +/*sitronix_ts_spi.c*/ +extern int sitronix_ts_spi_init(void); +extern void sitronix_ts_spi_exit(void); + +/*sitronix_ts_mt.c*/ +int sitronix_ts_monitor_thread_v3(void *data); +void sitronix_mt_pause_one(void); +void sitronix_mt_pause(void); +void sitronix_mt_restore(void); +void sitronix_mt_stop(void); +void sitronix_mt_start(int startDelayMS); +void sitronix_ts_mt_reset_process(void); +void sitronix_mt_suspend(void); +void sitronix_mt_resume(void); + +/*sitronix_ts_utility.c*/ +int sitronix_ts_get_device_status(struct sitronix_ts_data *ts_data); +int sitronix_ts_get_device_info(struct sitronix_ts_data *ts_data); +int sitronix_ts_set_smart_wake_up(struct sitronix_ts_data *ts_data, + bool enable); +int sitronix_ts_powerdown(struct sitronix_ts_data *ts_data, bool powerdown); +int TDU_CmdioRead(int type, int address, unsigned char *buf, int len); +int TDU_CmdioWrite(int type, int address, unsigned char *buf, int len); +int TDU_FWInfoRead(int type, unsigned char *buf, int len); +int sitronix_mode_switch_value(int modeID, bool flag, unsigned char value); +int sitronix_mode_switch(int modeID, bool flag); +extern void sitronix_mode_backup(void); +extern void sitronix_mode_restore(void); +extern void sitronix_swk_config_backup(void); +extern void sitronix_swk_config_restore(void); +extern int sitronix_get_chip_id(void); +extern int sitronix_get_ic_sfrver(void); +int sitronix_get_ic_position(unsigned char *buf); +int sitronix_write_driver_cmd(unsigned char cmd, unsigned char *buf, int len); +int sitronix_read_driver_cmd(unsigned char dc, unsigned char *buf, int len); +void sitronix_swite_driver_deep_standby(void); +int sitronix_ts_enable_raw(struct sitronix_ts_data *ts_data, int type); +int sitronix_ts_get_rawdata(struct sitronix_ts_data *ts_data, int *rbuf); +void STChecksumCalculation(unsigned short *pChecksum, unsigned char *pInData, + unsigned long Len); +int sitronix_ts_set_rawdata_area(struct sitronix_ts_data *ts_data, int aaXs, + int aaXe, int aaYs, int aaYe, int idleXs, + int idleXe, int noiseXs, int noiseXe); +int sitronix_ts_exdiff_enable(struct sitronix_ts_data *ts_data, bool exdiff_en); +int sitronix_ts_get_exdiff(struct sitronix_ts_data *ts_data, + unsigned char *diff); + +/*sitronix_ts_upgrade.c*/ +int st_check_cfg(const char *data, int *cfgSize); +int st_check_fw(const char *data, int *fwOff, int *fwSize, int *fwInfoOff, + int *cfgFlashOff, int *cfgDramOff); +int st_get_dump_size(void); +void st_set_dump(const char *data, int off, int size); +void st_get_dump(unsigned char *data, int off, int size); +void st_bakcup_flash_dump_buf(void); +int sitronix_do_upgrade(void); +int sitronix_spi_pram_rw(bool isread, u32 addr, u8 *txbuf, u8 *rxbuf, int len); +void sitronix_replace_dump_buf(unsigned char *id); + +/*sitronix_ts_test.c*/ +void sitronix_replace_test_cmd(unsigned char *id); +#endif /* __SITRONIX_TS_H__ */ diff --git a/drivers/input/touchscreen/sitronix_st7123/sitronix_ts_i2c.c b/drivers/input/touchscreen/sitronix_st7123/sitronix_ts_i2c.c new file mode 100644 index 00000000000000..61d2caaff38d9e --- /dev/null +++ b/drivers/input/touchscreen/sitronix_st7123/sitronix_ts_i2c.c @@ -0,0 +1,454 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Sitronix Touchscreen Controller Driver + * + * Copyright (C) 2018 Sitronix Technology Co., Ltd. + * CT Chen + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#include "sitronix_ts.h" +#include "sitronix_st7123.h" +#include + +#define I2C_RETRY_COUNT 1 +//#define I2C_MASTER_SEND_RECV + +static int sitronix_ts_i2c_parse_dt(struct device *dev, + struct sitronix_ts_host_interface *host_if) +{ +#ifdef CONFIG_OF + struct device_node *np = dev->of_node; + int rc; + + host_if->irq_gpio = of_get_named_gpio(np, "irq-gpio", 0); + if (host_if->irq_gpio < 0) + sterr("%s: Failed to read interrupt GPIO!(%d)\n", __func__, + host_if->irq_gpio); + else { + rc = gpio_request(host_if->irq_gpio, "st_irq_gpio"); + stmsg("%s: Interrupt GPIO = %d. (flag=%d) , request ret = %d\n", + __func__, host_if->irq_gpio, host_if->irq_gpio_flags, rc); + } + + host_if->rst_gpio = of_get_named_gpio(np, "rst-gpio", 0); + if (host_if->rst_gpio < 0) + sterr("%s: Failed to read Reset GPIO!(%d)\n", __func__, + host_if->rst_gpio); + else { + rc = gpio_request(host_if->rst_gpio, "st_rst_gpio"); + stmsg("%s: Reset GPIO = %d. (flag=%d), request ret = %d\n", + __func__, host_if->rst_gpio, host_if->rst_gpio_flags, rc); + } + +#endif + return 0; +} + +static int sitronix_ts_i2c_read(uint16_t addr, uint8_t *data, uint16_t length, + void *if_data) +{ + int ret; + uint8_t retry; + unsigned char buf[2]; + struct sitronix_ts_i2c_data *i2c_data = + (struct sitronix_ts_i2c_data *)if_data; + struct i2c_client *client = i2c_data->client; + + struct i2c_msg msg[] = { + { + .addr = client->addr, + .flags = 0, + .len = 2, + .buf = buf, + }, + { + .addr = client->addr, + .flags = I2C_M_RD, + .len = length, + .buf = data, + }, + }; + buf[0] = (addr >> 8) & 0xFF; + buf[1] = (addr) & 0xFF; + + for (retry = 1; retry <= I2C_RETRY_COUNT; retry++) { + if (i2c_transfer(client->adapter, msg, 2) == 2) { + ret = length; + break; + } + sterr("%s: I2C retry %d\n", __func__, retry); + msleep(20); + } + + if (retry > I2C_RETRY_COUNT) { + sterr("%s: I2C read over retry limit\n", __func__); + ret = -EIO; + } + + return ret; +} + +static int sitronix_ts_i2c_write(uint16_t addr, uint8_t *data, uint16_t length, + void *if_data) +{ + int ret; + unsigned char retry; + unsigned char *buf = NULL; + struct sitronix_ts_i2c_data *i2c_data = + (struct sitronix_ts_i2c_data *)if_data; + struct i2c_client *client = i2c_data->client; + + struct i2c_msg msg[] = { { + .addr = client->addr, .flags = 0, .len = length + 2, + //.buf = buf, + } }; + + buf = kzalloc((length + 2), GFP_KERNEL); + if (!buf) { + sterr("%s: Alloc memory for buf failed!\n", __func__); + return -ENOMEM; + } + msg[0].buf = buf; + buf[0] = (addr >> 8) & 0xFF; + buf[1] = (addr) & 0xFF; + memcpy(&buf[2], &data[0], length); + + for (retry = 1; retry <= I2C_RETRY_COUNT; retry++) { + if (i2c_transfer(client->adapter, msg, 1) == 1) { + ret = length; + break; + } + sterr("%s: I2C retry %d\n", __func__, retry); + usleep_range(8000, 9000); + } + + if (retry > I2C_RETRY_COUNT) { + sterr("%s: I2C write over retry limit\n", __func__); + ret = -EIO; + goto err_return; + } + +err_return: + kfree(buf); + + return ret; +} + +static int sitronix_ts_i2c_dread(uint8_t *data, uint16_t length, void *if_data) +{ + int ret; + uint8_t retry; + struct sitronix_ts_i2c_data *i2c_data = + (struct sitronix_ts_i2c_data *)if_data; + struct i2c_client *client = i2c_data->client; + + struct i2c_msg msg[] = { + { + .addr = client->addr, + .flags = I2C_M_RD, + .len = length, + .buf = data, + }, + }; + + for (retry = 1; retry <= I2C_RETRY_COUNT; retry++) { + if (i2c_transfer(client->adapter, msg, 1) == 1) { + ret = length; + break; + } + sterr("%s: I2C retry %d\n", __func__, retry); + msleep(20); + } + + if (retry > I2C_RETRY_COUNT) { + sterr("%s: I2C read over retry limit\n", __func__); + ret = -EIO; + } + + return ret; +} + +static int sitronix_ts_i2c_dwrite(uint8_t *data, uint16_t length, void *if_data) +{ + int ret; + unsigned char retry; + struct sitronix_ts_i2c_data *i2c_data = + (struct sitronix_ts_i2c_data *)if_data; + struct i2c_client *client = i2c_data->client; + + struct i2c_msg msg[] = { { + .addr = client->addr, + .flags = 0, + .len = length, + .buf = data, + } }; + + for (retry = 1; retry <= I2C_RETRY_COUNT; retry++) { + if (i2c_transfer(client->adapter, msg, 1) == 1) { + ret = length; + break; + } + sterr("%s: I2C retry %d\n", __func__, retry); + msleep(20); + } + + if (retry > I2C_RETRY_COUNT) { + sterr("%s: I2C write over retry limit\n", __func__); + ret = -EIO; + } + + return ret; +} + +static int sitronix_ts_i2c_aread(uint8_t *tx_buf, uint16_t tx_len, + uint8_t *rx_buf, uint16_t rx_len, + void *if_data) +{ + int ret; + uint8_t retry; + struct sitronix_ts_i2c_data *i2c_data = + (struct sitronix_ts_i2c_data *)if_data; + struct i2c_client *client = i2c_data->client; + + struct i2c_msg msg[] = { + { + .addr = ST_ADDR_MODE_I2C_ADDR, + .flags = 0, + .len = tx_len + 1, + .buf = tx_buf, + }, + { + .addr = ST_ADDR_MODE_I2C_ADDR, + .flags = I2C_M_RD, + .len = rx_len, + .buf = rx_buf, + }, + }; + + tx_buf[0] = 0xA0 | (tx_len - 1); + + for (retry = 1; retry <= I2C_RETRY_COUNT; retry++) { + if (i2c_transfer(client->adapter, msg, 2) == 2) { + ret = rx_len; + break; + } + sterr("%s: I2C retry %d\n", __func__, retry); + msleep(20); + } + + if (retry > I2C_RETRY_COUNT) { + sterr("%s: I2C read over retry limit\n", __func__); + ret = -EIO; + } + + return 0; +} + +static int sitronix_ts_i2c_awrite(uint8_t *tx_buf, uint16_t tx_len, + void *if_data) +{ + int ret; + unsigned char retry; + struct sitronix_ts_i2c_data *i2c_data = + (struct sitronix_ts_i2c_data *)if_data; + struct i2c_client *client = i2c_data->client; + + struct i2c_msg msg[] = { { + .addr = ST_ADDR_MODE_I2C_ADDR, + .flags = 0, + .len = tx_len + 1, + .buf = tx_buf, + } }; + + tx_buf[0] = 0x00; + + for (retry = 1; retry <= I2C_RETRY_COUNT; retry++) { + if (i2c_transfer(client->adapter, msg, 1) == 1) { + ret = tx_len; + break; + } + sterr("%s: I2C retry %d\n", __func__, retry); + msleep(20); + } + + if (retry > I2C_RETRY_COUNT) { + sterr("%s: I2C write over retry limit\n", __func__); + ret = -EIO; + } + + return ret; +} + +static void sitronix_ts_i2c_dev_release(struct device *dev) +{ +} + +static struct sitronix_ts_i2c_data g_i2c_data; + +static struct sitronix_ts_host_interface i2c_host_if = { + .bus_type = BUS_I2C, +#ifdef SITRONIX_TP_WITH_FLASH + .is_use_flash = 1, +#else + .is_use_flash = 0, +#endif + .if_data = &g_i2c_data, + .read = sitronix_ts_i2c_read, + .write = sitronix_ts_i2c_write, + .dread = sitronix_ts_i2c_dread, + .dwrite = sitronix_ts_i2c_dwrite, + .aread = sitronix_ts_i2c_aread, + .awrite = sitronix_ts_i2c_awrite, + .sread = sitronix_ts_i2c_aread, +}; + +static struct platform_device sitronix_ts_i2c_device = { + .name = SITRONIX_TS_I2C_DRIVER_NAME, + .id = 0, + .num_resources = 0, + .dev = { + .release = sitronix_ts_i2c_dev_release, + }, +}; + +static int sitronix_ts_i2c_probe(struct i2c_client *client) +{ + int ret; + + //client->addr = 0x66; //for debug + stmsg("i2c addr: 0x%x\n", client->addr); + if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { + sterr("%s: I2C function not supported by host!\n", __func__); + return -EIO; + } + + if (client->dev.of_node) + ret = sitronix_ts_i2c_parse_dt(&client->dev, &i2c_host_if); + + g_i2c_data.client = client; + + sitronix_ts_i2c_device.dev.parent = &client->dev; + sitronix_ts_i2c_device.dev.platform_data = &i2c_host_if; + + ret = platform_device_register(&sitronix_ts_i2c_device); + if (ret) { + sterr("%s: Failed to register platform device\n", __func__); + return -ENODEV; + } + + return 0; +} +#ifdef SITRONIX_INTERFACE_I2C +static void sitronix_ts_i2c_remove(struct i2c_client *client) +{ + struct sitronix_ts_host_interface *host_if; + + host_if = (struct sitronix_ts_host_interface *) + sitronix_ts_i2c_device.dev.platform_data; + + if (!host_if) + return; + + if (gpio_is_valid(host_if->irq_gpio)) + gpio_free(host_if->irq_gpio); + + if (gpio_is_valid(host_if->rst_gpio)) + gpio_free(host_if->rst_gpio); + + platform_device_unregister(&sitronix_ts_i2c_device); +} +#endif + +static const struct i2c_device_id i2c_id_table[] = { + { + SITRONIX_TS_I2C_DRIVER_NAME, + 0, + }, + {}, +}; +MODULE_DEVICE_TABLE(i2c, i2c_id_table); + +#ifdef CONFIG_OF +static const struct of_device_id i2c_match_table[] = { + { .compatible = "sitronix_ts,st7123" }, + {}, +}; +MODULE_DEVICE_TABLE(of, i2c_match_table); +#else /* CONFIG_OF */ +#define i2c_match_table NULL +#endif /* CONFIG_OF */ + +#ifdef SITRONIX_I2C_ADDRESS_DETECT +static int sitronix_ts_i2c_detect(struct i2c_client *client, + struct i2c_board_info *info) +{ + uint8_t data[8]; + struct i2c_msg msg[] = { + { + .addr = client->addr, + .flags = I2C_M_RD, + .len = sizeof(data), + .buf = data, + }, + }; + stmsg("%s:%d bus = %d, addr = 0x%02X: ", __func__, __LINE__, + client->adapter->nr, client->addr); + if (i2c_transfer(client->adapter, msg, 1) == 1) { + stmsg("Detected.\n"); + } else { + stdbg("Not detected.\n"); + return -ENODEV; + } + + return 0; +} + +const unsigned short sitronix_i2c_address_list[] = { 0x55, 0x66, 0x38, 0x70, + I2C_CLIENT_END }; +#endif /* SITRONIX_I2C_ADDRESS_DETECT */ + +static struct i2c_driver sitronix_ts_i2c_driver = { + .driver = { + .name = SITRONIX_TS_I2C_DRIVER_NAME, + .owner = THIS_MODULE, +#ifdef CONFIG_OF + .of_match_table = i2c_match_table, +#endif + }, + .probe = sitronix_ts_i2c_probe, +#ifdef SITRONIX_INTERFACE_I2C + /*.remove = __exit_p(sitronix_ts_i2c_remove),*/ + .remove = sitronix_ts_i2c_remove, +#endif + .id_table = i2c_id_table, +#ifdef SITRONIX_I2C_ADDRESS_DETECT + .address_list = sitronix_i2c_address_list, + .detect = sitronix_ts_i2c_detect, +#endif /* SITRONIX_I2C_ADDRESS_DETECT */ +}; + +int sitronix_ts_i2c_init(void) +{ + return i2c_add_driver(&sitronix_ts_i2c_driver); +} +EXPORT_SYMBOL(sitronix_ts_i2c_init); + +void sitronix_ts_i2c_exit(void) +{ + i2c_del_driver(&sitronix_ts_i2c_driver); +} +EXPORT_SYMBOL(sitronix_ts_i2c_exit); + +MODULE_AUTHOR("Sitronix Technology Co., Ltd."); +MODULE_DESCRIPTION("Sitronix Touchscreen Controller Driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/input/touchscreen/sitronix_st7123/sitronix_ts_mt.c b/drivers/input/touchscreen/sitronix_st7123/sitronix_ts_mt.c new file mode 100644 index 00000000000000..164949f4c852cf --- /dev/null +++ b/drivers/input/touchscreen/sitronix_st7123/sitronix_ts_mt.c @@ -0,0 +1,339 @@ +// SPDX-License-Identifier: GPL-2.0 +#include "sitronix_ts.h" + +static int i2cErrorCount; +static atomic_t iMonitorThreadPostpone = ATOMIC_INIT(0); +static uint8_t PreCheckData[4]; +static int StatusCheckCount; +static int DisCheckCount; +//#define SITRONIX_MT_GLOBAL_RESET +#ifdef SITRONIX_MT_GLOBAL_RESET +#define MT_GLOBAL_RESET_COUNT 3 +#endif //SITRONIX_MT_GLOBAL_RESET + +static int sitroinx_ts_check_display_off(void) +{ + uint8_t cmd[8] = { 0 }; + int ret = 0; + int off = 0; + + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0xA5; + cmd[5] = 0x3C; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x14; + cmd[5] = 0x55; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + + cmd[1] = 0x03; + cmd[2] = 0x06; + cmd[3] = 0xFC; + cmd[4] = 0x5A; + cmd[5] = 0x9E; + cmd[6] = 0x0A; + cmd[7] = 0x00; + + ret = sitronix_ts_addrmode_write(gts, cmd, 7); + if (ret < 0) { + sterr("read display CMD1 fail - 1\n"); + return -1; + } + + wbuf[1] = 0x83; + wbuf[2] = 0x07; + wbuf[3] = 0x00; + + off = sitronix_ts_addrmode_split_read(gts, wbuf, 3, rbuf, 2); + + if (off < 0) { + sterr("read display CMD1 fail - 2\n"); + ret = -1; + } + + cmd[1] = 0x03; + cmd[2] = 0x06; + cmd[3] = 0xFE; + cmd[4] = 0x00; + cmd[5] = 0xA5; + + sitronix_ts_addrmode_write(gts, cmd, 5); + + if (ret < 0) { + sterr("read display CMD1 fail - 3\n"); + return -1; + } + + stmsg("Display status = 0x%X\n", rbuf[off]); + + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x41; + cmd[5] = 0x4C; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x5A; + cmd[5] = 0xC3; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + + if (rbuf[off] & 0x04) + return 0; + else + return 1; +} + +void sitronix_ts_mt_reset_process(void) +{ +#ifdef SITRONIX_HDL_IN_MT + mutex_lock(>s->mutex); + sitronix_do_upgrade(); + mutex_unlock(>s->mutex); +#else + sitronix_ts_reset_device(gts); +#endif /* SITRONIX_HDL_IN_MT */ + + /* restore status*/ + if (gts->in_suspend) { + mutex_lock(>s->mutex); + msleep(20); + sitronix_ts_powerdown(gts, true); + mutex_unlock(>s->mutex); + } + + mutex_lock(>s->mutex); + sitronix_mode_restore(); + mutex_unlock(>s->mutex); +} +int sitronix_ts_monitor_thread_v3(void *data) +{ + int ret = 0; + uint8_t buf[12] = { 0 }; + // uint8_t drvBuf[4] = {0}; + bool disStaus; + int result = 0; +#ifdef SITRONIX_MT_CHECK_DIS + int i; + signed short disv; + bool disOK; + uint8_t disbuf[40 * 2 + 4] = { 0 }; +#endif //SITRONIX_MT_CHECK_DIS + int mt_peroid = DELAY_MONITOR_THREAD_PEROID_NORMAL; +#ifdef SITRONIX_MT_GLOBAL_RESET + uint8_t mt_reset_count = 0; +#endif //SITRONIX_MT_GLOBAL_RESET + + disStaus = true; + stmsg("%s start and delay %d ms\n", __func__, + gts->sitronix_ts_delay_monitor_thread_start); + msleep(gts->sitronix_ts_delay_monitor_thread_start); + while (!kthread_should_stop()) { + if (gts->is_reset_chip) { + sitronix_ts_mt_reset_process(); + gts->is_reset_chip = false; + } else if (gts->is_suspend_mt) { + stdbg("MT suspended\n"); + } else if (gts->is_pause_mt || gts->upgrade_doing) { + stdbg("MT paused\n"); + } else if (atomic_read(&iMonitorThreadPostpone)) { + atomic_set(&iMonitorThreadPostpone, 0); + } else { + mutex_lock(>s->mutex); + ret = sitronix_ts_reg_read(gts, FIRMWARE_VERSION, buf, + 12); +#ifdef SITRONIX_MT_CHECK_DIS + ret = sitronix_ts_reg_read( + gts, DATA_OUTPUT_BUFFER, disbuf, + 4 + (gts->ts_dev_info.y_chs * 2)); +#endif //SITRONIX_MT_CHECK_DIS + mutex_unlock(>s->mutex); + + stmsg("monitor sensing counter: %02x %02x\n", buf[0xA], + buf[0xB]); + + if (ret < 0) { + sterr("read I2C fail (%d)\n", ret); + result = 0; + goto exit_i2c_invalid; + } + + if ((buf[1] & 0x0F) == 0x6) { + result = 0; + sterr("read Status: bootcode\n"); + goto exit_i2c_invalid; + } else { + result = 1; + if (PreCheckData[0] == buf[0xA] && + PreCheckData[1] == buf[0xB]) { + mutex_lock(>s->mutex); + if (sitroinx_ts_check_display_off() == + 1) { + StatusCheckCount++; + mt_peroid = + DELAY_MONITOR_THREAD_PEROID_NORMAL; + } else { + StatusCheckCount++; + mt_peroid = + DELAY_MONITOR_THREAD_PEROID_ERROR; + } + mutex_unlock(>s->mutex); + } else { + StatusCheckCount = 0; +#ifdef SITRONIX_MT_GLOBAL_RESET + mt_reset_count = 0; +#endif //SITRONIX_MT_GLOBAL_RESET + mt_peroid = + DELAY_MONITOR_THREAD_PEROID_NORMAL; + } + PreCheckData[0] = buf[0xA]; + PreCheckData[1] = buf[0xB]; + + if (StatusCheckCount >= 3) { + sterr("IC Status doesn't update!\n"); + result = -1; + StatusCheckCount = 0; + } + } +#ifdef SITRONIX_MT_CHECK_DIS + if (disbuf[0] == 0x93) { + disOK = true; + for (i = 0; i < gts->ts_dev_info.y_chs; i++) { + disv = (signed short)((disbuf[4 + + 2 * i]) * + 0x100 + + disbuf[5 + 2 * i]); + if (disv > SITRONIX_MT_DIS_LIMIT || + disv < -SITRONIX_MT_DIS_LIMIT) { + sterr("MT dis err (%d,%d)=%d\n", + disbuf[2], i, disv); + disOK = false; + break; + } + } + + if (!disOK) { + DisCheckCount++; + mt_peroid = + DELAY_MONITOR_THREAD_PEROID_ERROR; + } else { + DisCheckCount = 0; + mt_peroid = + DELAY_MONITOR_THREAD_PEROID_NORMAL; + } + + if (DisCheckCount >= 3) { + sterr("Distance error for 3 times!\n"); + result = -1; + DisCheckCount = 0; + } + } +#endif //SITRONIX_MT_CHECK_DIS + + if (-1 == result) { + stmsg("ESD detected chip abnormal, reset device!\n"); + sitronix_ts_mt_reset_process(); + mt_peroid = DELAY_MONITOR_THREAD_PEROID_NORMAL; + i2cErrorCount = 0; + StatusCheckCount = 0; + +#ifdef SITRONIX_MT_GLOBAL_RESET + //MT reset count > 3. Call Display global reset. + mt_reset_count++; + if (mt_reset_count >= MT_GLOBAL_RESET_COUNT) { + stmsg("ESD detected chip abnormal, global reset device!\n"); + //display_global_reset(); //Call Display global reset. + mt_reset_count = 0; + } +#endif //SITRONIX_MT_GLOBAL_RESET + } +exit_i2c_invalid: + if (result == 0) { + i2cErrorCount++; + if ((i2cErrorCount >= 2)) { + stmsg("I2C abnormal or status bootcode, reset it!\n"); + sitronix_ts_mt_reset_process(); + mt_peroid = + DELAY_MONITOR_THREAD_PEROID_NORMAL; + i2cErrorCount = 0; + StatusCheckCount = 0; + +#ifdef SITRONIX_MT_GLOBAL_RESET + //I2C Error > 3, Call Display global reset. + //display_global_reset(); +#endif //SITRONIX_MT_GLOBAL_RESET + } + } else { + i2cErrorCount = 0; + } + } + msleep(mt_peroid); + } + return 0; +} + +void sitronix_mt_pause_one(void) +{ + if (gts->enable_monitor_thread == 1) + atomic_set(&iMonitorThreadPostpone, 1); +} + +void sitronix_mt_pause(void) +{ +#ifdef SITRONIX_MONITOR_THREAD + gts->is_pause_mt = 1; +#endif +} + +void sitronix_mt_restore(void) +{ +#ifdef SITRONIX_MONITOR_THREAD + gts->is_pause_mt = 0; +#endif +} + +void sitronix_mt_suspend(void) +{ + gts->is_suspend_mt = 1; +} + +void sitronix_mt_resume(void) +{ + sitronix_mt_pause_one(); + gts->is_suspend_mt = 0; +} + +void sitronix_mt_stop(void) +{ + if (gts && gts->enable_monitor_thread == 1) { + if (gts->SitronixMonitorThread) { + kthread_stop(gts->SitronixMonitorThread); + gts->SitronixMonitorThread = NULL; + } + } +} + +void sitronix_mt_start(int startDelayMS) +{ + if (gts && gts->enable_monitor_thread == 1) { + /* atomic_set(&ts_data->iMonitorThreadPostpone, 1); */ + sitronix_mt_pause_one(); + StatusCheckCount = 0; + i2cErrorCount = 0; + DisCheckCount = 0; + gts->sitronix_ts_delay_monitor_thread_start = startDelayMS; + if (!gts->SitronixMonitorThread) + gts->SitronixMonitorThread = + kthread_run(gts->sitronix_mt_fp, gts, + "Sitronix Monitor Thread"); + if (IS_ERR(gts->SitronixMonitorThread)) + gts->SitronixMonitorThread = NULL; + } +} diff --git a/drivers/input/touchscreen/sitronix_st7123/sitronix_ts_upgrade.c b/drivers/input/touchscreen/sitronix_st7123/sitronix_ts_upgrade.c new file mode 100644 index 00000000000000..1487707c050f91 --- /dev/null +++ b/drivers/input/touchscreen/sitronix_st7123/sitronix_ts_upgrade.c @@ -0,0 +1,1418 @@ +// SPDX-License-Identifier: GPL-2.0 +#include "sitronix_ts.h" +#include "sitronix_st7123.h" +#include "sitronix_ts_upgrade.h" + +#define st_u8 u8 +#define st_u16 u16 +#define st_u32 u32 +#define st_char char +#define st_msleep msleep +#define st_usleep usleep +#define st_usleep_range usleep_range +#define st_int int + +static bool st_icp_flash_wakeup(u16 *flash_write_block_size); +static int st_icp_flash_read(u8 *data, int off, int len); + + +#ifdef ST_DO_WRITE_DISPLAY_AREA +int st_check_display(const char *data) +{ + if (data[0x00] != 'D' || data[0x01] != 'I' || data[0x02] != 'S' || + data[0x03] != 'P') { + sterr("check Display fail\n"); + return -EINVAL; + } + return 0; +} +#endif /* ST_DO_WRITE_DISPLAY_AREA */ + +int st_check_cfg(const char *data, int *cfgSize) +{ + if (data[0x00] != 'C' || data[0x01] != 'F' || data[0x02] != 'T' || + data[0x03] != '1') { + sterr("check CFT1 fail , %x %x %x %x\n", data[0x00], data[0x01], + data[0x02], data[0x03]); + return -EINVAL; + } + if (data[0x08] == 0x84) + *cfgSize = data[0x0B] * 0x100 + data[0x0C] + 3; + else + *cfgSize = data[0x0A] * 0x100 + data[0x0B] + 3; + stmsg("cfgSize = 0x%X\n", *cfgSize); + + return 0; +} + +static st_u32 st_remainderCal(st_u32 poly, st_u32 dat, st_u8 polysize, st_u8 datasize) +{ + const st_u8 SHIFT_MAX = datasize - (polysize + 1); + st_u8 ind; + st_u32 MSBOFDATA = (u32)1 << (datasize - 1); + st_u32 tmp; + + poly |= (1 << polysize); + for (ind = 0; ind <= SHIFT_MAX; ind++) { + if ((dat << ind) & MSBOFDATA) { //if MSB == 1 + tmp = poly << (SHIFT_MAX - ind); + dat ^= tmp; //poly dosen't include the MSB of the divider. + } + } + return dat; // remainder is the lowest N bits +} + +static st_u32 st_crc24Cal(st_u32 poly, st_u8 *dat, st_u32 dat_len) +{ + const char POLYSIZE = 24, DATASIZE = 8; + st_u32 crc; + st_u32 ind; + + crc = dat[0]; + for (ind = 1; ind < dat_len; ind++) { + crc = (crc << DATASIZE) | dat[ind]; + crc = st_remainderCal(poly, crc, POLYSIZE, + (u8)(POLYSIZE + DATASIZE)); + } + for (ind = 0; ind < (POLYSIZE / DATASIZE); ind++) { + // CRC24, the data should be shifted left 24bits. + //shift 8bit 3 times and calculate the remainder + crc = crc << DATASIZE; // CRC24, shift left 8bit + crc = st_remainderCal(poly, crc, POLYSIZE, + (u8)(POLYSIZE + DATASIZE)); + } + return crc; +} + +static void st_calculateFwChecksum(st_u32 *pChecksum, unsigned char *pInData, + unsigned long Len) +{ + //CRC checksum + *pChecksum = st_crc24Cal(0x864CFB, pInData, Len); +} + +int st_check_fw(const char *data, int *fwOff, int *fwSize, int *fwInfoOff, + int *cfgFlashOff, int *cfgDramOff) +{ + int i = 0; + int fwCrcOff = 0; + st_u32 checksum = 0, checksumFw = 0; + *fwOff = 0; + + if (data[0x84] == 0) { + //72K firmware + *cfgFlashOff = 0x12000; + *cfgDramOff = data[0x93] * 0x100 + data[0x94]; + + *fwInfoOff = (data[0x96] << 16); + *fwInfoOff |= (data[0x97] << 8); + *fwInfoOff |= (data[0x98]); + + fwCrcOff |= (data[0x85] << 16); + fwCrcOff |= (data[0x86] << 8); + fwCrcOff |= (data[0x87]); + *fwSize = fwCrcOff + 1; + if (gts->ts_dev_info.chip_id == 0x83 && + gts->ts_dev_info.chip_ver < 0x47) { + sterr("ChipId(0x%02X): ChipVer(0x%02X) does NOT support 72K firmware!\n", + gts->ts_dev_info.chip_id, + gts->ts_dev_info.chip_ver); + return -EINVAL; + } + } else { + *fwSize = data[0x84] * 0x100 + data[0x85] + 1; + if (gts->ts_dev_info.chip_id == 0x84) { + *cfgFlashOff = 0xF000; + } else { + *cfgFlashOff = + 0x10000; //data[0x8E] * 0x10000 + data[0x8F] * 0x100 + data[0x90]; + } + *cfgDramOff = data[0x91] * 0x100 + data[0x92]; + *fwInfoOff = data[0x93] * 0x100 + data[0x94]; + fwCrcOff = data[0x84] * 0x100 + data[0x85]; + } + + if (fwCrcOff > ST_DUMP_MAX_LEN) { + sterr("fwCrcOff(0x%X) > ST_DUMP_MAX_LEN(0x%X) , error!\n", + fwCrcOff, ST_DUMP_MAX_LEN); + return -EINVAL; + } + + checksumFw = data[fwCrcOff] | // CRC 24 low byte + (data[fwCrcOff - 1] << 8) | // CRC 24 middle byte + (data[fwCrcOff - 2] << 16); // CRC 24 high byte + + st_calculateFwChecksum(&checksum, (unsigned char *)data, fwCrcOff - 2); + if (checksumFw != checksum) { + sterr("checksumFw(0x%X) != checksumHost(0x%X) with fwCrcOff = (0x%X), error!\n", + checksumFw, checksum, fwCrcOff); + return -EINVAL; + } + + i = *fwInfoOff; + if (i > ST_DUMP_MAX_LEN) { + sterr("fwInfoOff(0x%X) > ST_DUMP_MAX_LEN(0x%X) , error!\n", i, + ST_DUMP_MAX_LEN); + return -EINVAL; + } + if (data[i] == 0x54 && data[i + 1] == 0x46 && data[i + 2] == 0x49 && + data[i + 3] == 0x33) { + stmsg("TOUCH_FW_INFO offset = 0x%X\n", i + 4); + *fwInfoOff = i + 4; + + stmsg("fwOff = 0x%X\n", *fwOff); + stmsg("fwSize = 0x%X\n", *fwSize); + stmsg("fwInfoOff = 0x%X\n", *fwInfoOff); + stmsg("cfgFlashOff = 0x%X\n", *cfgFlashOff); + stmsg("cfgDramOff = 0x%X\n", *cfgDramOff); + return 0; + } + + stmsg("can't find TOUCH_FW_INFO offset\n"); + return -EINVAL; +} + +int st_get_dump_size(void) +{ + return ST_DUMP_MAX_LEN; +} + +void st_bakcup_flash_dump_buf(void) +{ + st_u16 flash_write_block_size; + + if (gts->fw_request_status == 0) { + if (!st_icp_flash_wakeup(&flash_write_block_size)) + return; + if (st_icp_flash_read(dump_buf, 0, ST_DUMP_MAX_LEN) < 0) + return; + gts->fw_request_status = 1; + sitronix_ts_reset_device(gts); + stmsg("Dump flash success.\n"); + } + // else { + // stmsg("ignore dump flash.\n"); + // } +} + +void st_set_dump(const char *data, int off, int size) +{ + memcpy(dump_buf + off, data, size); +} + +void st_get_dump(unsigned char *data, int off, int size) +{ + memcpy(data, dump_buf + off, size); +} + +static int st_compare_array(unsigned char *b1, unsigned char *b2, int len) +{ + int i = 0; + + for (i = 0; i < len; i++) { + if (b1[i] != b2[i]) + return -EINVAL; + } + return 0; +} + +static int st_irq_off(void) +{ + //disable_irq(gts->irq); + // sitronix_ts_irq_enable(gts, false); + sitronix_disable_irq(gts); + gts->upgrade_doing = true; + return 0; +} +static int st_irq_on(void) +{ + //enable_irq(gts->irq); + // sitronix_ts_irq_enable(gts, true); + sitronix_enable_irq(gts); + gts->upgrade_doing = false; + return 0; +} + +//unsigned char fw_check[ST_FLASH_PAGE_SIZE]; +unsigned char fw_check[ST_FLASH_SIZE]; + +/* ///////////////ICP */ + +static int st_icp_read(st_u8 *tx_buf, int tx_len, st_u8 *rx_buf, int rx_len) +{ + int ret = 0; + + memcpy(wbuf, tx_buf, tx_len + 1); + memset(wbuf + tx_len + 1, 0, rx_len); + ret = sitronix_ts_addrmode_read(gts, wbuf, tx_len, rbuf, rx_len); + + if (ret < 0) { + stmsg("%s error (%d)\n", __func__, ret); + return ret; + } + memcpy(rx_buf, rbuf + ret, rx_len); + /* st_msleep(100); */ + return rx_len; +} + +static int st_icp_write(st_u8 *tx_buf, int tx_len) +{ + int ret = 0; + + if (tx_buf == NULL) + return -EIO; + + memcpy(wbuf, tx_buf, tx_len + 1); + + ret = sitronix_ts_addrmode_write(gts, wbuf, tx_len); + /* ret = i2c_master_send(sitronix_ts_gpts.client, txbuf, len); */ + if (ret < 0) { + stmsg("st_icp_writeerror (%d)\n", ret); + return ret; + } + + /* st_msleep(100); */ + return tx_len; +} + +static bool st_icp_check_WEL_set(void) +{ + st_u8 tx_buf[2]; + st_u8 rx_buf[2]; + st_u8 flash_status; + int ret; + int max_time = 100; + + do { + tx_buf[1] = 0x05; /* Read Status Register-1 */ + ret = st_icp_read(tx_buf, 1, rx_buf, 1); + if (ret < 0) { + sterr("read flash status fail\n"); + return false; + } + + flash_status = rx_buf[0]; + + if ((flash_status & 0x02)) + break; + + st_usleep_range(1000, 2000); + + tx_buf[1] = 0x06; /* Write Enable */ + ret = st_icp_write(tx_buf, 1); + if (ret < 0) { + sterr("flash write Enable fail\n"); + return false; + } + + st_usleep_range(1000, 2000); + + } while (max_time--); //WEL=bit1. + + if (max_time < 0) { + sterr("WEL is not set, return false\n"); + return false; + } + + return true; +} + +static bool st_icp_check_flash_busy(void) +{ + st_u8 tx_buf[2]; + st_u8 rx_buf[2]; + st_u8 flash_status; + int ret; + int max_time = 10000; + + tx_buf[1] = 05; /* Read Status Register-1 */ + + do { + ret = st_icp_read(tx_buf, 1, rx_buf, 1); + if (ret < 0) { + sterr("read flash status fail\n"); + return false; + } + flash_status = rx_buf[0]; + } while (flash_status & 0x01 && max_time-- > 0); //WIP=bit0. + + if (max_time < 0) { + sterr("flash busy , return false\n"); + return false; + } + + return true; +} + +static bool st_icp_flash_wakeup(st_u16 *flash_write_block_size) +{ + st_u8 tx_buf[0x10]; + st_u8 rx_buf[0x10]; + int ret = 0; + + /* enter addr mode */ + tx_buf[1] = 0x53; + tx_buf[2] = 0x71; + tx_buf[3] = 0x23; + tx_buf[4] = 0xA5; + tx_buf[5] = 0x3C; + + ret = st_icp_write(tx_buf, 5); + ret = st_icp_write(tx_buf, 5); /* x2 */ + + if (ret < 0) { + sterr("enter addr mode fail\n"); + return false; + } + + /* icp unlock */ + tx_buf[1] = 0x53; + tx_buf[2] = 0x71; + tx_buf[3] = 0x23; + tx_buf[4] = 0x94; + tx_buf[5] = 0x55; + + ret = st_icp_write(tx_buf, 5); + if (ret < 0) { + sterr("icp unlock fail\n"); + return false; + } + + /* AFE unlock */ + tx_buf[1] = 0x53; + tx_buf[2] = 0x71; + tx_buf[3] = 0x23; + tx_buf[4] = 0x14; + tx_buf[5] = 0x55; + + ret = st_icp_write(tx_buf, 5); + if (ret < 0) { + sterr("icp unlock fail\n"); + return false; + } + + //MCU KEY + tx_buf[1] = 0x00; + tx_buf[2] = 0xF3; + tx_buf[3] = 0x00; + tx_buf[4] = 0x5A; + tx_buf[5] = 0xA5; + ret = st_icp_write(tx_buf, 5); + if (ret < 0) { + sterr("%s: Fail to set MCU KEY\n", __func__); + return false; + } + + //CMD_MCU_PRSTN + tx_buf[1] = 0x00; + tx_buf[2] = 0xF3; + tx_buf[3] = 0x02; + tx_buf[4] = 0x00; + tx_buf[5] = 0x01; + ret = st_icp_write(tx_buf, 5); + if (ret < 0) { + sterr("%s: Fail to set CMD_MCU_PRSTN\n", __func__); + return false; + } + + st_msleep(200); + + //MCU IFC1: RSETAFE + tx_buf[1] = 0x01; + tx_buf[2] = 0x01; + tx_buf[3] = 0xDC; + tx_buf[4] = 0x00; + tx_buf[5] = 0x00; + ret = st_icp_write(tx_buf, 5); + if (ret < 0) { + sterr("%s: Fail to set RSETAFE(L)\n", __func__); + return false; + } + st_usleep_range(10000, 11000); + + //MCU IFC1: RSETAFE + tx_buf[1] = 0x01; + tx_buf[2] = 0x01; + tx_buf[3] = 0xDC; + tx_buf[4] = 0xF3; + tx_buf[5] = 0xF3; + ret = st_icp_write(tx_buf, 5); + if (ret < 0) { + sterr("%s: Fail to set RSETAFE(H)\n", __func__); + return false; + } + st_msleep(100); + + /* CMD_MCU_PRSTN */ + tx_buf[1] = 0x00; + tx_buf[2] = 0xF3; + tx_buf[3] = 0x02; + tx_buf[4] = 0x00; + tx_buf[5] = 0x00; + + ret = st_icp_write(tx_buf, 5); + if (ret < 0) { + sterr("CMD_MCU_PRSTN fail\n"); + return false; + } + + /* spi 2 flash */ + tx_buf[1] = 0x00; + tx_buf[2] = 0xF3; + tx_buf[3] = 0x16; + tx_buf[4] = 0x00; + tx_buf[5] = 0x01; + + ret = st_icp_write(tx_buf, 5); + if (ret < 0) { + sterr("spi 2 flash fail\n"); + return false; + } + + st_msleep(100); + + /* Release PD */ + tx_buf[1] = 0xAB; /* Release Power-down */ + + ret = st_icp_write(tx_buf, 1); + if (ret < 0) { + sterr("Release PD fail\n"); + return false; + } + + st_msleep(100); + + /* read flash ID */ + tx_buf[1] = 0x9F; /* Read JEDEC ID */ + ret = st_icp_read(tx_buf, 1, rx_buf, 4); + if (ret < 0) { + sterr("read flash ID fail\n"); + return false; + } + + *flash_write_block_size = 0x100; + if ((rx_buf[0] == 0xC2) && (rx_buf[1] == 0x25) && (rx_buf[2] == 0x11)) + *flash_write_block_size = 0x20; + + if ((rx_buf[0] == 0xC2) && (rx_buf[1] == 0x25) && (rx_buf[2] == 0x31)) + *flash_write_block_size = 0x20; + + /* st_usleep_range(10000, 11000); */ + + if (st_icp_check_flash_busy() == false) + return false; + return true; +} + +static bool st_icp_flash_lock(bool is_lock) +{ + st_u8 tx_buf[0x3]; + int ret = 0; + + tx_buf[1] = 0x06; /* Write Enable */ + ret = st_icp_write(tx_buf, 1); + if (ret < 0) { + sterr("flash write Enable fail\n"); + return false; + } + + if (st_icp_check_WEL_set() == false) + return false; + + tx_buf[1] = 0x01; /* Write Status Register */ + if (!is_lock) + tx_buf[2] = 0x00; /* unlock */ + else + tx_buf[2] = 0x1C; /* lock 0x8C > 0x1C */ + ret = st_icp_write(tx_buf, 2); + if (ret < 0) { + sterr("flash write status register fail\n"); + return false; + } + + if (st_icp_check_flash_busy() == false) + return false; + return true; +} + +static int st_icp_flash_read(st_u8 *data, int off, int len) +{ + int ret; + st_u8 tx_buf[8]; + st_u32 offset; + st_u32 readLen; + st_u32 nowLen; + + offset = off; + nowLen = len; + while (nowLen > 0) { + if (offset % ST_ICP_READ_BLOCK_SIZE != 0) + readLen = ST_ICP_READ_BLOCK_SIZE - + offset % ST_ICP_READ_BLOCK_SIZE; + else + readLen = ST_ICP_READ_BLOCK_SIZE; + + if (offset + readLen > off + len) + readLen = off + len - offset; + + stmsg("offset %x , readLen %x\n", offset, readLen); + /* read */ + tx_buf[1] = 0x03; + tx_buf[2] = (st_u8)(offset >> 16); /* A23-A16 */ + tx_buf[3] = (st_u8)(offset >> 8); /* A15-A8 */ + tx_buf[4] = (st_u8)(offset); + + ret = st_icp_read(tx_buf, 4, data + (offset - off), readLen); + if (ret != readLen) { + sterr("%s fail\n", __func__); + return -EIO; + } + + nowLen -= readLen; + offset += readLen; + } + + return 0; +} + +static int st_icp_flash_erase(int offset) +{ + int ret; + st_u8 tx_buf[8]; + + tx_buf[1] = 0x06; /* Write Enable */ + ret = st_icp_write(tx_buf, 1); + if (ret < 0) { + sterr("flash write Enable fail\n"); + return -EIO; + } + + if (st_icp_check_WEL_set() == false) + return false; + + tx_buf[1] = 0x20; /* Sector Erase */ + tx_buf[2] = (st_u8)(offset >> 16); /* A23-A16 */ + tx_buf[3] = (st_u8)(offset >> 8); /* A15-A8 */ + tx_buf[4] = (st_u8)(offset); /* A7-A0 */ + + ret = st_icp_write(tx_buf, 4); + if (ret < 0) { + sterr("flash sector erase fail\n"); + return -EIO; + } + + st_msleep(50); + + if (st_icp_check_flash_busy() == false) + return -EIO; + return 0; +} + +static int st_icp_flash_write_block(st_u8 *data, int offset, + st_u16 flash_write_block_size) +{ + int ret = 0; + //st_u8 tx_buf[0x100 + 8]; + st_u8 *tx_buf; + int tx_buf_len = 0x100 + 8; + + tx_buf = kzalloc(tx_buf_len, GFP_KERNEL); + if (!tx_buf) { + sterr("%s: Alloc memory for tx_buf failed!\n", __func__); + return -ENOMEM; + } + + stmsg("write offset %X , len %X\n", offset, flash_write_block_size); + + tx_buf[1] = 0x06; /* Write Enable */ + ret = st_icp_write(tx_buf, 1); + if (ret < 0) { + sterr("flash write Enable fail\n"); + ret = -EIO; + goto err_return; + } + + if (st_icp_check_WEL_set() == false) + return false; + + tx_buf[1] = 0x02; /* Page Program */ + tx_buf[2] = (st_u8)(offset >> 16); /* A23-A16 */ + tx_buf[3] = (st_u8)(offset >> 8); /* A15-A8 */ + tx_buf[4] = (st_u8)(offset); /* A7-A0 */ + + memcpy(tx_buf + 5, data, flash_write_block_size); + + ret = st_icp_write(tx_buf, 4 + flash_write_block_size); + if (ret < 0) { + sterr("flash write block fail\n"); + ret = -EIO; + goto err_return; + } + + if (st_icp_check_flash_busy() == false) { + ret = -EIO; + goto err_return; + } + + ret = 0; + +err_return: + kfree(tx_buf); + + return ret; +} + +static int st_icp_flash_write(st_u8 *data, int offset, int write_len_total, + st_u16 flash_write_block_size) +{ + st_u16 start_page; + st_u16 page_offset; + int write_byte; + st_u16 write_len_once; + st_u8 *temp_buf; + int retry = 0; + int isSuccess = 0; + int i; + + temp_buf = kzalloc(ST_FLASH_PAGE_SIZE, GFP_KERNEL); + stmsg("Write flash offset:0x%X , length:0x%X\n", offset, + write_len_total); + + write_byte = 0; + if (write_len_total == 0) + return write_byte; + + if ((offset + write_len_total) > ST_FLASH_SIZE) + write_len_total = ST_FLASH_SIZE - offset; + + start_page = offset / ST_FLASH_PAGE_SIZE; + page_offset = offset % ST_FLASH_PAGE_SIZE; + while (write_len_total > 0) { + if ((page_offset != 0) || + (write_len_total < ST_FLASH_PAGE_SIZE)) { + if (st_icp_flash_read(temp_buf, + start_page * ST_FLASH_PAGE_SIZE, + ST_FLASH_PAGE_SIZE) < 0) + return -EIO; + } + + write_len_once = ST_FLASH_PAGE_SIZE - page_offset; + if (write_len_total < write_len_once) + write_len_once = write_len_total; + memcpy(&temp_buf[page_offset], data, write_len_once); + + retry = 0; + isSuccess = 0; + while (retry++ < 2 && isSuccess == 0) { + if (st_icp_flash_erase(start_page * + ST_FLASH_PAGE_SIZE) >= 0) { + stmsg("write page:%d\n", start_page); + isSuccess = 1; + for (i = 0; i < ST_FLASH_PAGE_SIZE; + i += flash_write_block_size) { + if (st_icp_flash_write_block( + temp_buf + i, + start_page * ST_FLASH_PAGE_SIZE + + i, + flash_write_block_size) < 0) + isSuccess = 0; + } + } + + if (isSuccess == 0) + stmsg("%s write page %d retry: %d\n", + __func__, start_page, retry); + } + if (isSuccess == 0) { + stmsg("%s write page %d error , break\n", + __func__, start_page); + return -EIO; + } + start_page++; + + write_len_total -= write_len_once; + data += write_len_once; + write_byte += write_len_once; + page_offset = 0; + } + kfree(temp_buf); + return write_byte; +} + +static int sitronix_do_upgrade_flash_icp_all(void) +{ + int rt = 0; + int fwOff = 0; + int cfgFlashOff = 0; + int cfgDramOff = 0; + int fwSize = 0; + int cfgSize = 0; + int displaySize = 0; + int fwInfoOff = 0; + int fwInfoLen = 0; + //int flashFwInfoOff = 0; + //int flashFwInfoLen = 0; + st_u16 flash_write_block_size; + /* int powerfulWrite = 0; */ + int retry; + + gts->upgrade_doing = true; + + rt = st_check_fw(dump_buf, &fwOff, &fwSize, &fwInfoOff, &cfgFlashOff, + &cfgDramOff); + if (rt < 0) { + rt = -EIO; + goto ST_ICP_HW_RESET; + } + + if (cfgFlashOff > sizeof(dump_buf)) { + sterr("check failed by cfgFlashOff = 0x%x\n", cfgFlashOff); + rt = -EIO; + goto ST_ICP_HW_RESET; + } + + rt = st_check_cfg(dump_buf + cfgFlashOff, &cfgSize); + if (rt < 0) { + rt = -EIO; + goto ST_ICP_HW_RESET; + } + + fwInfoLen = + dump_buf[fwInfoOff] * 0x100 + dump_buf[fwInfoOff + 1] + 2 + 4; + + stmsg("fwInfoLen 0x%x\n", fwInfoLen); + + st_irq_off(); + + if (!gts->flash_powerful_upgrade) { +#ifdef SITRONIX_FLASH_CHECK_FWVER + cfgDramOff = + (dump_buf[cfgFlashOff + SITRONIX_FLASH_CFG_TAB_VER_OFF] + << 8) + + dump_buf[cfgFlashOff + SITRONIX_FLASH_CFG_TAB_VER_OFF + + 1]; + + if (cfgFlashOff + cfgDramOff > sizeof(dump_buf)) { + rt = -1; + sterr("check CFG error! IdOffset = 0x%x\n", cfgDramOff); + goto ST_ICP_HW_RESET; + } + + cfgDramOff = dump_buf[cfgFlashOff + cfgDramOff]; + stmsg("CustomerVersion of dumpbuf = 0x%x , of current = 0x%x\n", + cfgDramOff, gts->ts_dev_info.fw_version); + + if (cfgDramOff <= gts->ts_dev_info.fw_version) { + rt = 0; + stmsg("Don't have new CustomerVersion , don't need to upgrade\n"); + cfgSize = 0; + fwSize = 0; + displaySize = 0; + goto ST_ICP_HW_RESET; + } +#endif + } + + if (!st_icp_flash_wakeup(&flash_write_block_size)) { + rt = -1; + goto ST_ICP_HW_RESET; + } + + if (st_icp_flash_read(fw_check, 0, fwSize) < 0) { + sterr("read flash fail @0x0 , cancel upgrade\n"); + rt = -1; + goto ST_ICP_HW_RESET; + } + + if (st_compare_array(fw_check, dump_buf, fwSize) == 0) { + stmsg("fw compare :same\n"); + fwSize = 0; + } else { + stmsg("fw compare :different\n"); + } + + st_icp_flash_read(fw_check, cfgFlashOff, cfgSize); + + if (st_compare_array(fw_check, dump_buf + cfgFlashOff, cfgSize) == 0) { + stmsg("cfg compare :same\n"); + cfgSize = 0; + } else { + stmsg("cfg compare : different\n"); + } + +#ifdef ST_DO_WRITE_DISPLAY_AREA + displaySize = ST_DISPLAY_SIZE; + rt = st_check_display(dump_buf + ST_DISPLAY_DUMP_OFF); + if (rt < 0) { + displaySize = 0; + rt = 0; + stmsg("dump buf doesn't contain display data\n"); + } else { + st_icp_flash_read(fw_check, ST_ICP_DISPLAY_FLASH_OFF, + displaySize); + + if (st_compare_array(fw_check, dump_buf + ST_DISPLAY_DUMP_OFF, + displaySize) == 0) { + stmsg("display compare :same\n"); + displaySize = 0; + } else { + stmsg("display compare : different\n"); + } + } +#endif /* ST_DO_WRITE_DISPLAY_AREA */ + + if (!st_icp_flash_wakeup(&flash_write_block_size)) { + rt = -1; + sterr("st_icp_flash_wakeup fail!\n"); + goto ST_ICP_HW_RESET; + } + + if (!st_icp_flash_lock(false)) { + rt = -1; + sterr("st_icp_flash_lock unlock fail!\n"); + goto ST_ICP_HW_RESET; + } + + if (cfgSize != 0) { + retry = 3; + do { + stmsg("upgrade cfg to flash...\n"); + st_icp_flash_write(dump_buf + cfgFlashOff, cfgFlashOff, + cfgSize, flash_write_block_size); + + st_icp_flash_read(fw_check, cfgFlashOff, cfgSize); + if (st_compare_array(fw_check, dump_buf + cfgFlashOff, + cfgSize) == 0) { + stmsg("cfg compare :same\n"); + break; + } + stmsg("cfg compare : different\n"); + } while (retry--); + } + + if (fwSize != 0) { + retry = 3; + do { + stmsg("upgrade fw to flash...\n"); + st_icp_flash_write(dump_buf + fwOff, fwOff, fwSize, + flash_write_block_size); + + st_icp_flash_read(fw_check, 0, fwSize); + if (st_compare_array(fw_check, dump_buf + fwOff, + fwSize) == 0) { + stmsg("fw compare :same\n"); + break; + } + stmsg("fw compare : different\n"); + } while (retry--); + } + + if (displaySize != 0) + st_icp_flash_write(dump_buf + ST_DISPLAY_DUMP_OFF, + ST_ICP_DISPLAY_FLASH_OFF, displaySize, + flash_write_block_size); + + if (!st_icp_flash_lock(true)) + sterr("st_icp_flash_lock lock fail!\n"); + +ST_ICP_HW_RESET: + sitronix_ts_reset_device(gts); + + st_irq_on(); + + gts->upgrade_doing = false; + + if (rt < 0) { + return rt; + } else if (cfgSize != 0 || fwSize != 0 || displaySize != 0) { + sitronix_ts_get_device_info(gts); + return 1; + } else { + return rt; + } +} + +int sitronix_spi_pram_rw(bool isread, st_u32 addr, st_u8 *txbuf, st_u8 *rxbuf, + int len) +{ + int nowlen = len; + st_u32 nowoff = 0; + st_u32 ramoff = addr; + int ret = 0; + int max_trans_len; + + if (isread) + max_trans_len = ST_PLATFORM_READ_LEN_MAX; + else + max_trans_len = ST_PLATFORM_WRITE_LEN_MAX; + + while (nowlen > 0) { + if (nowlen > max_trans_len) { + ramoff = addr + (nowoff); + + wbuf[1] = (ramoff >> 16) & 0xFF; + wbuf[2] = (ramoff >> 8) & 0xFF; + wbuf[3] = (ramoff) & 0xFF; + + if (isread) + wbuf[1] |= 0x80; + + if (isread) { + memset(wbuf + 4, 0, max_trans_len + 1); + ret = sitronix_ts_addrmode_read( + gts, wbuf, 3, rbuf, max_trans_len + 1); + + if (ret < 0) + return ret; + memcpy(rxbuf + nowoff, rbuf + ret + 1, + max_trans_len); + } else { + memcpy(wbuf + 4, txbuf + nowoff, max_trans_len); + ret = sitronix_ts_addrmode_write( + gts, wbuf, max_trans_len + 3); + if (ret < 0) + return ret; + } + + nowoff += max_trans_len; + nowlen -= max_trans_len; + } else { + ramoff = addr + (nowoff); + wbuf[1] = (ramoff >> 16) & 0xFF; + wbuf[2] = (ramoff >> 8) & 0xFF; + wbuf[3] = (ramoff) & 0xFF; + + if (isread) + wbuf[1] |= 0x80; + + if (isread) { + memset(wbuf + 4, 0, nowlen + 1); + ret = sitronix_ts_addrmode_read( + gts, wbuf, 3, rbuf, nowlen + 1); + + if (ret < 0) + return ret; + memcpy(rxbuf + nowoff, rbuf + ret + 1, + nowlen); + } else { + memcpy(wbuf + 4, txbuf + nowoff, nowlen); + ret = sitronix_ts_addrmode_write(gts, wbuf, + nowlen + 3); + if (ret < 0) + return ret; + } + nowlen = 0; + } + } + return 0; +} + +static int sitronix_spi_hdl_fw(unsigned char *buf) +{ + int ret = 0; + int retry = 0; + int isSuccess = -1; + int fwOff = 0; + int cfgFlashOff = 0; + int cfgDramhOff = 0; + int fwSize = 0; + int cfgSize = 0; + int displaySize = 0; + int fwInfoOff = 0; + int i; + uint8_t hdl_rbuf[4]; + st_u8 cmd[6]; + + //hdl_rbuf = kmalloc(ST_FW_LEN, GFP_KERNEL); + + ret = st_check_fw(buf, &fwOff, &fwSize, &fwInfoOff, &cfgFlashOff, + &cfgDramhOff); + if (ret < 0) { + strscpy(gts->upgrade_msg, "st_check_fw fail", + sizeof(gts->upgrade_msg)); + sterr("st_check_fw fail\n"); + goto sitronix_spi_hdl_fw_finish; + } + + ret = st_check_cfg(buf + cfgFlashOff, &cfgSize); + + if (ret < 0) { + strscpy(gts->upgrade_msg, "st_check_cfg fail", + sizeof(gts->upgrade_msg)); + sterr("st_check_cfg fail\n"); + goto sitronix_spi_hdl_fw_finish; + } +#ifdef ST_DO_WRITE_DISPLAY_AREA + displaySize = ST_DISPLAY_SIZE; + ret = st_check_display(buf + ST_DISPLAY_DUMP_OFF); + + if (ret < 0) { + displaySize = 0; + stmsg("dump buf doesn't contain display data\n"); + } +#endif /* ST_DO_WRITE_DISPLAY_AREA */ + + while (isSuccess == -1 && retry++ < ST_RAM_MODE_RETRY_MAX) { + sitronix_ts_reset_device(gts); + + /* addr mode */ + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0xA5; + cmd[5] = 0x3C; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + if (ret < 0) { + sterr("HDL set address mode fail\n"); + goto sitronix_spi_hdl_fw_retry; + } + + /* PRAM unlock */ + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x05; + cmd[5] = 0x55; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + if (ret < 0) { + sterr("HDL PRAM unlock fail\n"); + goto sitronix_spi_hdl_fw_retry; + } + + /* URAM unlock */ + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x55; + cmd[5] = 0x55; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + if (ret < 0) { + sterr("HDL URAM unlock fail\n"); + goto sitronix_spi_hdl_fw_retry; + } + + /* AFE unlock */ + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x14; + cmd[5] = 0x55; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + if (ret < 0) { + sterr("HDL PRAM unlock fail\n"); + goto sitronix_spi_hdl_fw_retry; + } + + /* MCU KEY */ + cmd[1] = 0x00; + cmd[2] = 0xF3; + cmd[3] = 0x00; + cmd[4] = 0x5A; + cmd[5] = 0xA5; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + if (ret < 0) { + sterr("HDL PRAM unlock fail\n"); + goto sitronix_spi_hdl_fw_retry; + } + + /* MCU PRSTN */ + cmd[1] = 0x00; + cmd[2] = 0xF3; + cmd[3] = 0x02; + cmd[4] = 0x00; + cmd[5] = 0x01; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + if (ret < 0) { + sterr("HDL MCU PRSTN fail\n"); + goto sitronix_spi_hdl_fw_retry; + } + + /* MCU PRSTN */ + cmd[1] = 0x00; + cmd[2] = 0xF3; + cmd[3] = 0x02; + cmd[4] = 0x00; + cmd[5] = 0x00; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + if (ret < 0) { + sterr("HDL MCU PRSTN fail\n"); + goto sitronix_spi_hdl_fw_retry; + } + + /* MCU PRSTN */ + cmd[1] = 0x00; + cmd[2] = 0xF3; + cmd[3] = 0x02; + cmd[4] = 0x00; + cmd[5] = 0x01; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + if (ret < 0) { + sterr("HDL MCU PRSTN fail\n"); + goto sitronix_spi_hdl_fw_retry; + } + + //sitronix_spi_pram_rw( true, ST_HDL_RAM_ADDR + 0x1000 -4 , NULL, hdl_rbuf, 4); + //sitronix_spi_pram_rw( true, ST_HDL_RAM_ADDR + 0x1000 -4 , NULL, hdl_rbuf, 4); + //sitronix_spi_pram_rw( true, ST_HDL_RAM_ADDR + 0x1000 -4 , NULL, hdl_rbuf, 4); + //ret = sitronix_spi_pram_rw( true, 0xF000 , NULL, hdl_rbuf, 0x30); + //ret = sitronix_spi_pram_rw( true, 0xF000 , NULL, hdl_rbuf, 0x30); + //ret = sitronix_spi_pram_rw( true, 0xF000 , NULL, hdl_rbuf, 0x30); + //ret = sitronix_spi_pram_rw( true, 0xF000 , NULL, hdl_rbuf, 0x30); + //ret = sitronix_spi_pram_rw( true, 0xF000 , NULL, hdl_rbuf, 0x30); + //ret = sitronix_spi_pram_rw( true, 0xF000 , NULL, hdl_rbuf, 0x30); + //ret = sitronix_spi_pram_rw( true, 0xF000 , NULL, hdl_rbuf, 0x30); + //ret = sitronix_spi_pram_rw( true, 0xF000 , NULL, hdl_rbuf, 0x30); + + //ret = sitronix_spi_pram_rw(false, ST_HDL_RAM_ADDR, buf, NULL, 0x30); + //ret = sitronix_spi_pram_rw( true, ST_HDL_RAM_ADDR , NULL, hdl_rbuf, 0x30); + //ret = sitronix_spi_pram_rw( true, ST_HDL_RAM_ADDR , NULL, hdl_rbuf, 0x30); + //ret = sitronix_spi_pram_rw( true, ST_HDL_RAM_ADDR , NULL, hdl_rbuf, 0x30); + + //ret = -1; + //if (ret == -1) + // return -1; + ret = sitronix_spi_pram_rw(false, ST_HDL_PRAM_ADDR, buf, NULL, + ST_FW_LEN); + /* stmsg("write_wbuf %x %x %x %x\n",buf[0],buf[1],buf[2],buf[3]); */ + if (ret < 0) { + sterr("HDL program PRAM fail\n"); + goto sitronix_spi_hdl_fw_retry; + } + + //Download part2 if necessary + if (gts->ts_dev_info.chip_id != 0x83 || + gts->ts_dev_info.chip_ver >= 0x47) { + if (buf[0x84] == 0) { //large firmware + ret = sitronix_spi_pram_rw( + false, ST_HDL_PRAM_ADDR_PART2, + buf + ST_FW_LEN, NULL, ST_FW_LEN_PART2); + if (ret < 0) { + sterr("HDL program PRAM PART2 fail\n"); + goto sitronix_spi_hdl_fw_retry; + } + } + } + + for (i = 0x1000; i < ST_FW_LEN; i += 0x1000) { +#ifdef SITRONIX_HDL_VALIDATE_BY_RANDOM + ret = (get_random_int() % (0x800 - 2)) * 2 + i; + sitronix_spi_pram_rw(true, ST_HDL_PRAM_ADDR + ret, NULL, + hdl_rbuf, 4); + ret = st_compare_array(buf + (ret), hdl_rbuf, 4); +#else + ret = sitronix_spi_pram_rw(true, + ST_HDL_PRAM_ADDR + i - 4, + NULL, hdl_rbuf, 4); + ret = st_compare_array(buf + (i - 4), hdl_rbuf, 4); +#endif /* SITRONIX_HDL_VALIDATE_BY_RANDOM */ + + if (ret < 0) { + sterr("valid FW (compare) fail , retry: %d\n", + retry); + isSuccess = -1; + i = ST_FW_LEN; + goto sitronix_spi_hdl_fw_retry; + } + isSuccess = 0; + } + + ret = sitronix_spi_pram_rw(false, + ST_HDL_URAM_ADDR + cfgDramhOff, + buf + cfgFlashOff, NULL, cfgSize); + ret = sitronix_spi_pram_rw( + true, ST_HDL_URAM_ADDR + cfgDramhOff + cfgSize - 4, + NULL, hdl_rbuf, 4); + + ret = st_compare_array(buf + (cfgFlashOff + cfgSize - 4), + hdl_rbuf, 4); + if (ret < 0) { + sterr("valid CFG (compare) fail , retry: %d\n", retry); + isSuccess = -1; + goto sitronix_spi_hdl_fw_retry; + } + isSuccess = 0; + + if (displaySize != 0) { + ret = sitronix_spi_pram_rw(false, + ST_HDL_DISPLAY_RAM_ADDR, + buf + ST_DISPLAY_DUMP_OFF, + NULL, ST_DISPLAY_SIZE); + if (ret < 0) { + sterr("HDL program Display Ram fail\n"); + isSuccess = -1; + goto sitronix_spi_hdl_fw_retry; + } + } + + /* MCU PRSTN + MCU_CRSTN */ + cmd[1] = 0x00; + cmd[2] = 0xF3; + cmd[3] = 0x02; + cmd[4] = 0x00; + cmd[5] = 0x03; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + if (ret < 0) { + sterr("HDL MCU PRSTN and CRSTN fail\n"); + isSuccess = -1; + goto sitronix_spi_hdl_fw_retry; + } + + if (ret < 0) + sterr("write FW (PRAM) fail with error: %d , retry: %d\n", + ret, retry); + +sitronix_spi_hdl_fw_retry: + if (isSuccess == -1) + sterr("%s fail , retry %d\n", __func__, retry); + } + +sitronix_spi_hdl_fw_finish: + //kfree(hdl_rbuf); + return isSuccess; + /* return 0; */ +} + +static int sitronix_do_upgrade_hostdownload(void) +{ + int ret = 0; + st_u8 cmd[6]; + + gts->upgrade_doing = true; + st_irq_off(); + + ret = sitronix_spi_hdl_fw(dump_buf); + if (ret < 0) { + sterr("%s fail!\n", __func__); + strscpy(gts->upgrade_msg, "sitronix_spi_hdl_fw fail", + sizeof(gts->upgrade_msg)); + } else { + stmsg("%s success\n", __func__); + } + if (ret >= 0) { + /* CMD_MCU_KEY */ + cmd[1] = 0x00; + cmd[2] = 0xF3; + cmd[3] = 0x00; + cmd[4] = 0x00; + cmd[5] = 0x00; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + if (ret < 0) + sterr("HDL HOST PRAM Lock fail\n"); + + /* HOST PROG DONE */ + cmd[1] = 0x00; + cmd[2] = 0xF0; + cmd[3] = 0x06; + cmd[4] = 0x00; + cmd[5] = 0x01; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + if (ret < 0) + sterr("HDL HOST PROG DONE fail\n"); + msleep(20); + + /* PRAM Lock */ + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x50; + cmd[5] = 0x4C; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + if (ret < 0) + sterr("HDL HOST PRAM Lock fail\n"); + + /* URAM Lock */ + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x55; + cmd[5] = 0x4C; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + if (ret < 0) + sterr("HDL HOST URAM Lock fail\n"); + + /* AFE Lock */ + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x41; + cmd[5] = 0x4C; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + if (ret < 0) + sterr("HDL HOST AFE Lock fail\n"); + + /* CMD Mode */ + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x5A; + cmd[5] = 0xC3; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + if (ret < 0) + sterr("HDL HOST CMD Mode fail\n"); + } + + msleep(20); + + st_irq_on(); + gts->upgrade_doing = false; + return ret; +} + +int sitronix_do_upgrade(void) +{ + int ret = 0; + +#ifdef ST_UPGRADE_USE_REQUESTFW_BUF + int retry = 0; + const struct firmware *fw = NULL; + + if (gts->fw_request_status == 0) { + dump_buf_size = 0; + while (retry < 3) { + //ret = request_firmware(&fw, ST_REQUESTFW_DF_PATH, >s->pdev->dev); + //stmsg("request_firmware PATH = %s\n", fw_path); + ret = request_firmware(&fw, fw_path, >s->pdev->dev); + if (ret) { + sterr("request_firmware fail - %d\n", retry); + retry++; + } else { + retry = 3; + } + } + if (ret) + return -ENOENT; + + //stmsg("request_firmware OK (%d)!\n"); + //dump_buf = (unsigned char *) fw->data; + dump_buf_size = fw->size; + if (dump_buf_size > ST_DUMP_MAX_LEN) + dump_buf_size = ST_DUMP_MAX_LEN; + memcpy(&dump_buf[0], fw->data, dump_buf_size); + gts->fw_request_status = 1; + stmsg("request_firmware %s OK (%ld)\n", fw_path, + dump_buf_size); + } +#endif + /* if (gts->host_if->bus_type == BUS_SPI && !gts->host_if->is_use_flash) */ + if (!gts->host_if->is_use_flash) { + ret = sitronix_do_upgrade_hostdownload(); +#ifdef ST_SKIP_HDL_IN_PROBE + sitronix_ts_get_device_info(gts); +#endif //ST_SKIP_HDL_IN_PROBE + } else { + ret = sitronix_do_upgrade_flash_icp_all(); + } + +#ifdef ST_UPGRADE_USE_REQUESTFW_BUF + release_firmware(fw); + dump_buf_size = 0; +#endif + return ret; +} + +void sitronix_replace_dump_buf(unsigned char *id) +{ + //set as default request firmware path + memset(fw_path, 0, sizeof(fw_path)); + strcpy(fw_path, ST_REQUESTFW_DF_PATH); +} diff --git a/drivers/input/touchscreen/sitronix_st7123/sitronix_ts_upgrade.h b/drivers/input/touchscreen/sitronix_st7123/sitronix_ts_upgrade.h new file mode 100644 index 00000000000000..ef4c0f638f0967 --- /dev/null +++ b/drivers/input/touchscreen/sitronix_st7123/sitronix_ts_upgrade.h @@ -0,0 +1,5710 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +//#define ST_DO_WRITE_DISPLAY_AREA +//#define ST_REPLACE_DUMP_BY_DISPLAY_ID + +#ifdef ST_DO_WRITE_DISPLAY_AREA +#define ST_DUMP_MAX_LEN 0x20000 +#else +#define ST_DUMP_MAX_LEN 0x13000 +#endif + +size_t dump_buf_size; +unsigned char fw_path[256]; +#ifdef ST_UPGRADE_USE_REQUESTFW_BUF +unsigned char dump_buf[ST_DUMP_MAX_LEN] = { 0 }; +#else +unsigned char dump_buf[ST_DUMP_MAX_LEN] = { + 0x02, 0x01, 0x87, 0x02, 0x01, 0x4A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x01, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0x02, 0x01, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0x02, 0x00, 0xA0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x75, + 0xC2, 0x00, 0x32, 0x00, 0x00, 0x00, 0x00, 0x02, 0x01, 0x24, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x02, 0x01, 0x37, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x02, 0x00, 0xEA, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x02, 0x01, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xF8, 0x1D, 0x54, 0x44, 0x50, 0x31, 0x00, 0x0E, 0x01, 0xFF, 0xFF, 0xFF, + 0xFF, 0x03, 0x00, 0xF8, 0x06, 0x00, 0x9A, 0xFF, 0xFF, 0xFF, 0x54, 0x46, + 0x57, 0x31, 0xF7, 0x66, 0xCA, 0x7B, 0xCA, 0x6B, 0xCA, 0x5B, 0xCA, 0x4B, + 0xCA, 0x3B, 0xCA, 0x2B, 0xCA, 0x1B, 0xCA, 0x0B, 0xC0, 0xD1, 0x75, 0xD1, + 0x18, 0xC0, 0xD0, 0xC0, 0x83, 0xC0, 0x82, 0x12, 0xA1, 0x72, 0xD0, 0x82, + 0xD0, 0x83, 0xD0, 0xD0, 0xD0, 0xD1, 0xDA, 0x0B, 0xDA, 0x1B, 0xDA, 0x2B, + 0xDA, 0x3B, 0xDA, 0x4B, 0xDA, 0x5B, 0xDA, 0x6B, 0xDA, 0x7B, 0x32, 0xC0, + 0xD0, 0x75, 0xD1, 0x10, 0xCA, 0x2B, 0xCA, 0xEB, 0x12, 0xF5, 0xAF, 0xDA, + 0xEB, 0xDA, 0x2B, 0xD0, 0xD0, 0x32, 0xCA, 0x7B, 0xCA, 0x6B, 0xCA, 0x5B, + 0xCA, 0x4B, 0xCA, 0x3B, 0xCA, 0x2B, 0xCA, 0x1B, 0xCA, 0x0B, 0xC0, 0xD1, + 0x75, 0xD1, 0x18, 0xC0, 0xD0, 0xC0, 0x83, 0xC0, 0x82, 0x12, 0x86, 0x7C, + 0xD0, 0x82, 0xD0, 0x83, 0xD0, 0xD0, 0xD0, 0xD1, 0xDA, 0x0B, 0xDA, 0x1B, + 0xDA, 0x2B, 0xDA, 0x3B, 0xDA, 0x4B, 0xDA, 0x5B, 0xDA, 0x6B, 0xDA, 0x7B, + 0x32, 0x02, 0xB2, 0x91, 0xC0, 0xD0, 0x75, 0xD1, 0x10, 0xCA, 0x2B, 0xCA, + 0xEB, 0x12, 0x70, 0x82, 0xDA, 0xEB, 0xDA, 0x2B, 0xD0, 0xD0, 0x32, 0xC0, + 0xD0, 0x75, 0xD1, 0x10, 0xCA, 0x2B, 0xCA, 0xEB, 0x12, 0xF5, 0xC4, 0xDA, + 0xEB, 0xDA, 0x2B, 0xD0, 0xD0, 0x32, 0xCA, 0x7B, 0xCA, 0x6B, 0xCA, 0x5B, + 0xCA, 0x4B, 0xCA, 0x3B, 0xCA, 0x2B, 0xCA, 0x1B, 0xCA, 0x0B, 0xC0, 0xD1, + 0x75, 0xD1, 0x18, 0xC0, 0xD0, 0xC0, 0x83, 0xC0, 0x82, 0x12, 0x9F, 0xD8, + 0xD0, 0x82, 0xD0, 0x83, 0xD0, 0xD0, 0xD0, 0xD1, 0xDA, 0x0B, 0xDA, 0x1B, + 0xDA, 0x2B, 0xDA, 0x3B, 0xDA, 0x4B, 0xDA, 0x5B, 0xDA, 0x6B, 0xDA, 0x7B, + 0x32, 0x02, 0xB2, 0xC8, 0x02, 0xB2, 0xFF, 0xE4, 0xF5, 0xBB, 0xF5, 0xA8, + 0xF5, 0xE8, 0xF5, 0xBD, 0xF5, 0xBC, 0x75, 0x84, 0x00, 0x7E, 0xF8, 0x00, + 0xBF, 0x02, 0x82, 0x48, 0xCA, 0x3B, 0x7C, 0xDB, 0x7A, 0x1F, 0x37, 0x49, + 0x7A, 0x0F, 0x37, 0x45, 0x6C, 0xCC, 0x02, 0x09, 0xA2, 0xE4, 0x02, 0x09, + 0x8F, 0x7E, 0x0F, 0x37, 0x49, 0x7E, 0x0B, 0x70, 0xBE, 0x70, 0x00, 0x48, + 0x03, 0x02, 0x09, 0x80, 0x7E, 0xB3, 0x37, 0x4E, 0x60, 0x0F, 0x7F, 0x10, + 0x1B, 0x34, 0x7E, 0x1B, 0x70, 0xBE, 0x70, 0x00, 0x58, 0x03, 0x02, 0x09, + 0x80, 0x4C, 0xCC, 0x68, 0x1B, 0x7E, 0x73, 0x0E, 0x7D, 0x0A, 0x37, 0x6E, + 0x34, 0xFF, 0xFF, 0x0B, 0x34, 0x2D, 0x31, 0x7D, 0x20, 0x7E, 0x1B, 0x70, + 0xBE, 0x70, 0x00, 0x58, 0x03, 0x02, 0x09, 0x80, 0x74, 0x01, 0x7A, 0xB3, + 0x37, 0x51, 0x4C, 0xCC, 0x78, 0x18, 0x7E, 0x73, 0x0E, 0x7D, 0x0A, 0x37, + 0x2D, 0x31, 0x7D, 0x20, 0x7E, 0x1B, 0x70, 0xBE, 0x70, 0x00, 0x58, 0x06, + 0x74, 0x02, 0x7A, 0xB3, 0x37, 0x51, 0x74, 0x01, 0x7A, 0xB3, 0x37, 0x50, + 0x7E, 0x73, 0x37, 0x50, 0x0A, 0x37, 0x7E, 0x53, 0x37, 0x4E, 0x0A, 0x25, + 0x7D, 0x52, 0x2D, 0x53, 0x7E, 0x33, 0x0E, 0x7D, 0x0A, 0x13, 0x7D, 0x01, + 0x1B, 0x04, 0xBD, 0x50, 0x18, 0x20, 0x7E, 0x2F, 0x37, 0x49, 0x2D, 0x53, + 0x7E, 0x2B, 0x70, 0xBE, 0x70, 0x00, 0x58, 0x12, 0x7E, 0xB3, 0x37, 0x50, + 0x04, 0x7A, 0xB3, 0x37, 0x50, 0x7E, 0x73, 0x37, 0x50, 0xBE, 0x70, 0x08, + 0x28, 0xC2, 0x7E, 0x73, 0x04, 0x2C, 0x7A, 0x73, 0x37, 0x52, 0x7E, 0xB3, + 0x37, 0x4E, 0x60, 0x0C, 0x7E, 0x73, 0x37, 0x50, 0x0A, 0x37, 0x2D, 0x32, + 0xBD, 0x31, 0x78, 0x08, 0x7E, 0x73, 0x04, 0x2D, 0x7A, 0x73, 0x37, 0x52, + 0x7E, 0xB3, 0x37, 0x4D, 0x60, 0x03, 0x02, 0x06, 0xF4, 0x7E, 0x0F, 0x37, + 0x45, 0x7C, 0x7C, 0x1B, 0x24, 0x7C, 0x65, 0x7E, 0xA3, 0x37, 0x50, 0x0A, + 0x2A, 0x0B, 0x25, 0x12, 0xD0, 0x9B, 0x7A, 0x37, 0x37, 0x53, 0x7E, 0xB3, + 0x37, 0x51, 0xB4, 0x02, 0x29, 0x7E, 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, + 0x4D, 0x0A, 0x3C, 0x0B, 0x34, 0x7E, 0x63, 0x37, 0x4E, 0x0A, 0x26, 0x1B, + 0x24, 0x7C, 0x65, 0x7E, 0xA3, 0x37, 0x50, 0x0A, 0x2A, 0x0B, 0x25, 0x12, + 0xD0, 0x9B, 0x2E, 0x37, 0x37, 0x53, 0x7A, 0x37, 0x37, 0x53, 0x7E, 0x0F, + 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x7E, 0xA3, 0x37, 0x51, 0x0A, 0x2A, + 0x0A, 0x3C, 0x2D, 0x32, 0x7E, 0x63, 0x37, 0x4E, 0x7E, 0x53, 0x37, 0x50, + 0x12, 0xD0, 0x9B, 0x7A, 0x37, 0x37, 0x57, 0x7E, 0x0F, 0x37, 0x45, 0x7E, + 0xB3, 0x37, 0x4D, 0x7E, 0xA3, 0x37, 0x51, 0x0A, 0x2A, 0x0A, 0x3C, 0x2D, + 0x32, 0x0B, 0x34, 0x7E, 0x63, 0x37, 0x4E, 0x7E, 0x53, 0x37, 0x50, 0x12, + 0xD0, 0x9B, 0x7A, 0x37, 0x37, 0x59, 0x7E, 0x0F, 0x37, 0x45, 0x7E, 0xB3, + 0x37, 0x4D, 0x7E, 0xA3, 0x37, 0x51, 0x0A, 0x2A, 0x0A, 0x3C, 0x2D, 0x32, + 0x7E, 0x63, 0x37, 0x4E, 0x0A, 0x26, 0x1B, 0x24, 0x7C, 0x65, 0x7E, 0xA3, + 0x37, 0x50, 0x0A, 0x2A, 0x0B, 0x25, 0x12, 0xD0, 0x9B, 0x7D, 0x23, 0x9E, + 0x27, 0x37, 0x57, 0x7A, 0x27, 0x37, 0x55, 0x7E, 0x37, 0x37, 0x53, 0x7E, + 0x17, 0x37, 0x57, 0x7E, 0x07, 0x37, 0x59, 0x7E, 0xB3, 0x37, 0x52, 0x12, + 0xD2, 0x20, 0x7A, 0x37, 0x37, 0x5B, 0x7E, 0xB3, 0x37, 0x51, 0xB4, 0x01, + 0x02, 0x80, 0x03, 0x02, 0x04, 0xB3, 0x7E, 0xB3, 0x37, 0x50, 0xB4, 0x01, + 0x03, 0x02, 0x07, 0xD4, 0x7E, 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, + 0x0A, 0x3C, 0x0B, 0x34, 0x7E, 0x63, 0x37, 0x4E, 0x0A, 0x26, 0x1B, 0x24, + 0x7C, 0x65, 0x7E, 0x50, 0x02, 0x12, 0xD0, 0x9B, 0x7D, 0x73, 0x7E, 0x0F, + 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x7C, 0x7C, 0x7E, 0x63, 0x37, 0x4E, + 0x0A, 0x26, 0x1B, 0x24, 0x7C, 0x65, 0x12, 0xDF, 0x6D, 0x2D, 0x37, 0x7A, + 0x37, 0x37, 0x5D, 0x7E, 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x0A, + 0x3C, 0x0B, 0x34, 0x7E, 0x63, 0x37, 0x50, 0x0A, 0x46, 0x7E, 0x63, 0x37, + 0x4E, 0x0A, 0x26, 0x2D, 0x24, 0x1B, 0x24, 0x7C, 0x65, 0x7E, 0x50, 0x02, + 0x12, 0xD0, 0x9B, 0x7D, 0x73, 0x7E, 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, + 0x4D, 0x7C, 0x7C, 0x7E, 0x63, 0x37, 0x50, 0x0A, 0x46, 0x7E, 0x63, 0x37, + 0x4E, 0x0A, 0x26, 0x2D, 0x24, 0x7C, 0x65, 0x12, 0xDF, 0x6D, 0x7D, 0x47, + 0x2D, 0x43, 0x7E, 0xB3, 0x37, 0x50, 0x7E, 0x70, 0x02, 0xAC, 0xB7, 0x59, + 0x45, 0x37, 0x5B, 0x49, 0x35, 0x37, 0x5B, 0x2E, 0x37, 0x37, 0x5D, 0x7A, + 0x37, 0x37, 0x6D, 0x74, 0x01, 0x80, 0x3E, 0x7E, 0x0F, 0x37, 0x45, 0x7E, + 0xB3, 0x37, 0x4D, 0x0A, 0x3C, 0x0B, 0x34, 0x7E, 0x63, 0x37, 0x4F, 0x0A, + 0x46, 0x7E, 0x63, 0x37, 0x4E, 0x0A, 0x26, 0x2D, 0x24, 0x1B, 0x24, 0x7C, + 0x65, 0x7E, 0x50, 0x03, 0x12, 0xD0, 0x9B, 0x7E, 0xB3, 0x37, 0x4F, 0x7E, + 0x50, 0x02, 0xAC, 0xB5, 0x59, 0x35, 0x37, 0x5D, 0x2E, 0x37, 0x37, 0x6D, + 0x7A, 0x37, 0x37, 0x6D, 0x7E, 0xB3, 0x37, 0x4F, 0x04, 0x7A, 0xB3, 0x37, + 0x4F, 0x7E, 0x73, 0x37, 0x50, 0x0A, 0x27, 0x1B, 0x24, 0x7E, 0x73, 0x37, + 0x4F, 0x0A, 0x37, 0xBD, 0x32, 0x48, 0xAC, 0xE4, 0x80, 0x3C, 0x7E, 0x37, + 0x37, 0x5B, 0x7E, 0xB3, 0x37, 0x4F, 0x7E, 0x50, 0x02, 0xAC, 0xB5, 0x49, + 0x25, 0x37, 0x5D, 0x7E, 0x17, 0x37, 0x6D, 0x12, 0xEE, 0x19, 0x7D, 0x23, + 0x7E, 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x7C, 0x7C, 0x7E, 0x63, + 0x37, 0x4F, 0x0A, 0xF6, 0x7E, 0x63, 0x37, 0x4E, 0x0A, 0x46, 0x2D, 0x4F, + 0x7C, 0x69, 0x12, 0xDF, 0xF7, 0x7E, 0xB3, 0x37, 0x4F, 0x04, 0x7A, 0xB3, + 0x37, 0x4F, 0x7E, 0x73, 0x37, 0x50, 0xBE, 0x73, 0x37, 0x4F, 0x38, 0xB6, + 0x02, 0x09, 0x80, 0x7E, 0xA3, 0x37, 0x50, 0xBE, 0xA0, 0x01, 0x68, 0x03, + 0x02, 0x05, 0x72, 0x7E, 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x7C, + 0x7C, 0x7E, 0x63, 0x37, 0x4E, 0x0A, 0x46, 0x1B, 0x44, 0x7C, 0x69, 0x0A, + 0x2A, 0x0B, 0x25, 0x12, 0xD0, 0x9B, 0x7A, 0x37, 0x37, 0x5D, 0x7E, 0x0F, + 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x0A, 0x3C, 0x0B, 0x35, 0x7E, 0x63, + 0x37, 0x4E, 0x0A, 0x26, 0x1B, 0x24, 0x7C, 0x65, 0x7E, 0xA3, 0x37, 0x50, + 0x0A, 0x2A, 0x0B, 0x25, 0x12, 0xD0, 0x9B, 0x7D, 0x73, 0x0E, 0x74, 0x7E, + 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x0A, 0x3C, 0x0B, 0x34, 0x7E, + 0x63, 0x37, 0x4E, 0x0A, 0x26, 0x1B, 0x24, 0x7C, 0x65, 0x7E, 0xA3, 0x37, + 0x50, 0x0A, 0x2A, 0x0B, 0x25, 0x12, 0xD0, 0x9B, 0x7D, 0x13, 0x2D, 0x17, + 0x7A, 0x17, 0x37, 0x5F, 0x2E, 0x17, 0x37, 0x5D, 0x7A, 0x17, 0x37, 0x6D, + 0x7E, 0x37, 0x37, 0x5B, 0x7E, 0x27, 0x37, 0x5D, 0x12, 0xEE, 0x19, 0x7D, + 0x23, 0x7E, 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x7C, 0x7C, 0x7E, + 0x63, 0x37, 0x4E, 0x12, 0xDF, 0xF7, 0x7E, 0x37, 0x37, 0x5B, 0x7E, 0x27, + 0x37, 0x5F, 0x7E, 0x17, 0x37, 0x6D, 0x12, 0xEE, 0x19, 0x7D, 0x23, 0x7E, + 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x0A, 0x3C, 0x0B, 0x34, 0x02, + 0x09, 0x79, 0x7E, 0xB3, 0x37, 0x50, 0xB4, 0x02, 0x02, 0x80, 0x03, 0x02, + 0x09, 0x80, 0x7E, 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x0A, 0x3C, + 0x0B, 0x35, 0x7E, 0x63, 0x37, 0x4E, 0x12, 0xDF, 0x6D, 0x7D, 0x73, 0x7E, + 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x7C, 0x7C, 0x7E, 0x63, 0x37, + 0x4E, 0x0A, 0x26, 0x1B, 0x24, 0x7C, 0x65, 0x12, 0xDF, 0x6D, 0x2D, 0x37, + 0x7A, 0x37, 0x37, 0x5D, 0x7E, 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, + 0x0A, 0x3C, 0x0B, 0x34, 0x7E, 0x63, 0x37, 0x4E, 0x0A, 0x26, 0x1B, 0x24, + 0x7C, 0x65, 0x12, 0xDF, 0x6D, 0x7D, 0x73, 0x7E, 0x0F, 0x37, 0x45, 0x7E, + 0xB3, 0x37, 0x4D, 0x0A, 0x3C, 0x0B, 0x35, 0x7E, 0x63, 0x37, 0x4E, 0x12, + 0xDF, 0x6D, 0x2D, 0x37, 0x7A, 0x37, 0x37, 0x5F, 0x7E, 0x0F, 0x37, 0x45, + 0x7E, 0xB3, 0x37, 0x4D, 0x0A, 0x3C, 0x0B, 0x35, 0x7E, 0x63, 0x37, 0x4E, + 0x0A, 0x26, 0x0B, 0x24, 0x7C, 0x65, 0x12, 0xDF, 0x6D, 0x7D, 0x73, 0x7E, + 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x7C, 0x7C, 0x7E, 0x63, 0x37, + 0x4E, 0x0A, 0x26, 0x0B, 0x25, 0x7C, 0x65, 0x12, 0xDF, 0x6D, 0x2D, 0x37, + 0x7A, 0x37, 0x37, 0x61, 0x7E, 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, + 0x0A, 0x3C, 0x0B, 0x35, 0x7E, 0x63, 0x37, 0x4E, 0x0A, 0x26, 0x0B, 0x24, + 0x7C, 0x65, 0x12, 0xDF, 0x6D, 0x7D, 0x73, 0x7E, 0x0F, 0x37, 0x45, 0x7E, + 0xB3, 0x37, 0x4D, 0x0A, 0x3C, 0x0B, 0x34, 0x7E, 0x63, 0x37, 0x4E, 0x0A, + 0x26, 0x0B, 0x25, 0x7C, 0x65, 0x12, 0xDF, 0x6D, 0x2D, 0x37, 0x7A, 0x37, + 0x37, 0x63, 0x7E, 0x17, 0x37, 0x5F, 0x2E, 0x17, 0x37, 0x5D, 0x2E, 0x17, + 0x37, 0x61, 0x2E, 0x17, 0x37, 0x63, 0x7A, 0x17, 0x37, 0x6D, 0x7E, 0x37, + 0x37, 0x5B, 0x7E, 0x27, 0x37, 0x5D, 0x12, 0xEE, 0x19, 0x7D, 0x23, 0x7E, + 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x7C, 0x7C, 0x7E, 0x63, 0x37, + 0x4E, 0x12, 0xDF, 0xF7, 0x7E, 0x37, 0x37, 0x5B, 0x7E, 0x27, 0x37, 0x5F, + 0x7E, 0x17, 0x37, 0x6D, 0x12, 0xEE, 0x19, 0x7D, 0x23, 0x7E, 0x0F, 0x37, + 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x0A, 0x3C, 0x0B, 0x34, 0x7E, 0x63, 0x37, + 0x4E, 0x12, 0xDF, 0xF7, 0x7E, 0x37, 0x37, 0x5B, 0x7E, 0x27, 0x37, 0x61, + 0x7E, 0x17, 0x37, 0x6D, 0x12, 0xEE, 0x19, 0x7D, 0x23, 0x7E, 0x0F, 0x37, + 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x7C, 0x7C, 0x7E, 0x63, 0x37, 0x4E, 0x0A, + 0x46, 0x0B, 0x44, 0x7C, 0x69, 0x12, 0xDF, 0xF7, 0x7E, 0x37, 0x37, 0x5B, + 0x7E, 0x27, 0x37, 0x63, 0x7E, 0x17, 0x37, 0x6D, 0x12, 0xEE, 0x19, 0x7D, + 0x23, 0x7E, 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x0A, 0x3C, 0x0B, + 0x34, 0x02, 0x08, 0xB0, 0x7E, 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, + 0x7C, 0x7C, 0x7E, 0x63, 0x37, 0x4E, 0x0A, 0x26, 0x1B, 0x24, 0x7C, 0x65, + 0x7E, 0xA3, 0x37, 0x50, 0x0A, 0x2A, 0x0B, 0x25, 0x12, 0xD0, 0x9B, 0x7A, + 0x37, 0x37, 0x53, 0x7E, 0xB3, 0x37, 0x51, 0xB4, 0x02, 0x29, 0x7E, 0x0F, + 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x0A, 0x3C, 0x0B, 0x34, 0x7E, 0x63, + 0x37, 0x4E, 0x0A, 0x26, 0x1B, 0x24, 0x7C, 0x65, 0x7E, 0xA3, 0x37, 0x50, + 0x0A, 0x2A, 0x0B, 0x25, 0x12, 0xD0, 0x9B, 0x2E, 0x37, 0x37, 0x53, 0x7A, + 0x37, 0x37, 0x53, 0x7E, 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x0A, + 0x3C, 0x1B, 0x34, 0x7E, 0x63, 0x37, 0x4E, 0x7E, 0x53, 0x37, 0x50, 0x12, + 0xD0, 0x9B, 0x7A, 0x37, 0x37, 0x57, 0x7E, 0x0F, 0x37, 0x45, 0x7E, 0xB3, + 0x37, 0x4D, 0x0A, 0x3C, 0x1B, 0x35, 0x7E, 0x63, 0x37, 0x4E, 0x7E, 0x53, + 0x37, 0x50, 0x12, 0xD0, 0x9B, 0x7A, 0x37, 0x37, 0x59, 0x7E, 0x0F, 0x37, + 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x0A, 0x3C, 0x1B, 0x34, 0x7E, 0x63, 0x37, + 0x4E, 0x0A, 0x26, 0x1B, 0x24, 0x7C, 0x65, 0x7E, 0xA3, 0x37, 0x50, 0x0A, + 0x2A, 0x0B, 0x25, 0x12, 0xD0, 0x9B, 0x7D, 0x23, 0x9E, 0x27, 0x37, 0x57, + 0x7A, 0x27, 0x37, 0x55, 0x7E, 0x37, 0x37, 0x53, 0x7E, 0x17, 0x37, 0x57, + 0x7E, 0x07, 0x37, 0x59, 0x7E, 0xB3, 0x37, 0x52, 0x12, 0xD2, 0x20, 0x7A, + 0x37, 0x37, 0x5B, 0x7E, 0xB3, 0x37, 0x51, 0xB4, 0x01, 0x02, 0x80, 0x03, + 0x02, 0x08, 0xBD, 0x7E, 0xF3, 0x37, 0x50, 0xBE, 0xF0, 0x01, 0x78, 0x15, + 0x7E, 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x7C, 0x7C, 0x7E, 0x63, + 0x37, 0x4E, 0x7E, 0x27, 0x37, 0x5B, 0x02, 0x09, 0x7D, 0xBE, 0xF0, 0x02, + 0x68, 0x03, 0x02, 0x09, 0x80, 0x7E, 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, + 0x4D, 0x0A, 0x3C, 0x1B, 0x34, 0x7E, 0x63, 0x37, 0x4E, 0x0A, 0x26, 0x1B, + 0x24, 0x7C, 0x65, 0x7C, 0x5F, 0x12, 0xD0, 0x9B, 0x7D, 0x73, 0x7E, 0x0F, + 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x7C, 0x7C, 0x7E, 0x63, 0x37, 0x4E, + 0x0A, 0x26, 0x1B, 0x24, 0x7C, 0x65, 0x12, 0xDF, 0x6D, 0x2D, 0x37, 0x7A, + 0x37, 0x37, 0x5D, 0x7E, 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x0A, + 0x3C, 0x1B, 0x34, 0x7E, 0x63, 0x37, 0x4E, 0x0A, 0x26, 0x0B, 0x24, 0x7C, + 0x65, 0x7E, 0x53, 0x37, 0x50, 0x12, 0xD0, 0x9B, 0x7D, 0x73, 0x7E, 0x0F, + 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x7C, 0x7C, 0x7E, 0x63, 0x37, 0x50, + 0x0A, 0x46, 0x7E, 0x63, 0x37, 0x4E, 0x0A, 0x26, 0x2D, 0x24, 0x7C, 0x65, + 0x12, 0xDF, 0x6D, 0x7D, 0x17, 0x2D, 0x13, 0x7A, 0x17, 0x37, 0x5F, 0x2E, + 0x17, 0x37, 0x5D, 0x7A, 0x17, 0x37, 0x6D, 0x7E, 0x37, 0x37, 0x5B, 0x7E, + 0x27, 0x37, 0x5D, 0x12, 0xEE, 0x19, 0x7D, 0x23, 0x7E, 0x0F, 0x37, 0x45, + 0x7E, 0xB3, 0x37, 0x4D, 0x7C, 0x7C, 0x7E, 0x63, 0x37, 0x4E, 0x12, 0xDF, + 0xF7, 0x7E, 0x37, 0x37, 0x5B, 0x7E, 0x27, 0x37, 0x5F, 0x7E, 0x17, 0x37, + 0x6D, 0x12, 0xEE, 0x19, 0x7D, 0x23, 0x7E, 0x0F, 0x37, 0x45, 0x7E, 0xB3, + 0x37, 0x4D, 0x7C, 0x7C, 0x7E, 0x63, 0x37, 0x4E, 0x0A, 0x46, 0x0B, 0x44, + 0x7C, 0x69, 0x02, 0x09, 0x7D, 0x7E, 0xA3, 0x37, 0x50, 0xBE, 0xA0, 0x01, + 0x68, 0x03, 0x02, 0x09, 0x80, 0x7E, 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, + 0x4D, 0x0A, 0x3C, 0x0B, 0x34, 0x7E, 0x63, 0x37, 0x4E, 0x0A, 0x46, 0x1B, + 0x44, 0x7C, 0x69, 0x0A, 0x2A, 0x0B, 0x25, 0x12, 0xD0, 0x9B, 0x7A, 0x37, + 0x37, 0x5D, 0x7E, 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x0A, 0x3C, + 0x1B, 0x34, 0x7E, 0x63, 0x37, 0x4E, 0x0A, 0x26, 0x1B, 0x24, 0x7C, 0x65, + 0x7E, 0xA3, 0x37, 0x50, 0x0A, 0x2A, 0x0B, 0x25, 0x12, 0xD0, 0x9B, 0x7D, + 0x73, 0x0E, 0x74, 0x7E, 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x7C, + 0x7C, 0x7E, 0x63, 0x37, 0x4E, 0x0A, 0x26, 0x1B, 0x24, 0x7C, 0x65, 0x7E, + 0xA3, 0x37, 0x50, 0x0A, 0x2A, 0x0B, 0x25, 0x12, 0xD0, 0x9B, 0x7D, 0x13, + 0x2D, 0x17, 0x7A, 0x17, 0x37, 0x5F, 0x2E, 0x17, 0x37, 0x5D, 0x7A, 0x17, + 0x37, 0x6D, 0x7E, 0x37, 0x37, 0x5B, 0x7E, 0x27, 0x37, 0x5D, 0x12, 0xEE, + 0x19, 0x7D, 0x23, 0x7E, 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x0A, + 0x3C, 0x0B, 0x34, 0x7E, 0x63, 0x37, 0x4E, 0x12, 0xDF, 0xF7, 0x7E, 0x37, + 0x37, 0x5B, 0x7E, 0x27, 0x37, 0x5F, 0x7E, 0x17, 0x37, 0x6D, 0x12, 0xEE, + 0x19, 0x7D, 0x23, 0x7E, 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4D, 0x7C, + 0x7C, 0x7E, 0x63, 0x37, 0x4E, 0x12, 0xDF, 0xF7, 0x7E, 0x1F, 0x37, 0x49, + 0x0B, 0x34, 0x7A, 0x1F, 0x37, 0x49, 0x7E, 0xB3, 0x37, 0x4E, 0x04, 0x7A, + 0xB3, 0x37, 0x4E, 0x7E, 0x73, 0x0E, 0x7D, 0xBE, 0x73, 0x37, 0x4E, 0x28, + 0x03, 0x02, 0x01, 0xB1, 0x0B, 0xC0, 0xBC, 0xDC, 0x28, 0x03, 0x02, 0x01, + 0xAD, 0xDA, 0x3B, 0x22, 0xCA, 0x3B, 0x7E, 0xB3, 0x04, 0x70, 0x54, 0x02, + 0x7A, 0xB3, 0x37, 0x46, 0x78, 0x50, 0x7E, 0x73, 0x04, 0x53, 0x0A, 0x37, + 0x7A, 0x37, 0x37, 0x70, 0x7E, 0x73, 0x04, 0x54, 0x7A, 0x37, 0x37, 0x72, + 0x7E, 0x73, 0x04, 0x74, 0x7A, 0x37, 0x37, 0x74, 0x7E, 0x73, 0x04, 0x75, + 0x7A, 0x37, 0x37, 0x76, 0x7E, 0x73, 0x04, 0x76, 0x7A, 0x37, 0x37, 0x78, + 0x7E, 0x73, 0x04, 0x77, 0x7A, 0x37, 0x37, 0x7A, 0x7E, 0x73, 0x05, 0x17, + 0x7A, 0x73, 0x37, 0x4B, 0x7E, 0x73, 0x05, 0x18, 0x7A, 0x73, 0x37, 0x4F, + 0x7E, 0x37, 0x05, 0x1C, 0x7A, 0x37, 0x37, 0x59, 0x7E, 0x37, 0x05, 0x1E, + 0x80, 0x4E, 0x7E, 0x73, 0x04, 0x78, 0x0A, 0x37, 0x7A, 0x37, 0x37, 0x70, + 0x7E, 0x73, 0x04, 0x79, 0x7A, 0x37, 0x37, 0x72, 0x7E, 0x73, 0x04, 0x7A, + 0x7A, 0x37, 0x37, 0x74, 0x7E, 0x73, 0x04, 0x7B, 0x7A, 0x37, 0x37, 0x76, + 0x7E, 0x73, 0x04, 0x7C, 0x7A, 0x37, 0x37, 0x78, 0x7E, 0x73, 0x04, 0x7D, + 0x7A, 0x37, 0x37, 0x7A, 0x7E, 0x73, 0x05, 0x18, 0x7A, 0x73, 0x37, 0x4B, + 0x7E, 0x73, 0x05, 0x17, 0x7A, 0x73, 0x37, 0x4F, 0x7E, 0x37, 0x05, 0x1E, + 0x7A, 0x37, 0x37, 0x59, 0x7E, 0x37, 0x05, 0x1C, 0x7A, 0x37, 0x37, 0x61, + 0x7E, 0x73, 0x04, 0x52, 0x7A, 0x73, 0x37, 0x67, 0x7E, 0xA3, 0x04, 0x58, + 0x7C, 0xBA, 0xC4, 0x54, 0x0F, 0x7A, 0xB3, 0x37, 0x6A, 0xB4, 0x0F, 0x06, + 0x74, 0xFF, 0x7A, 0xB3, 0x37, 0x6A, 0x7C, 0xBA, 0x54, 0x0F, 0x7A, 0xB3, + 0x37, 0x69, 0x7E, 0x73, 0x04, 0x57, 0x7A, 0x73, 0x37, 0x6B, 0x7E, 0x73, + 0x04, 0x55, 0x7C, 0xB7, 0x54, 0x80, 0x7A, 0xB3, 0x37, 0x68, 0x5E, 0x70, + 0x7F, 0x74, 0x02, 0xAC, 0xB7, 0x7A, 0x57, 0x37, 0x6E, 0x7E, 0xB3, 0x04, + 0x56, 0x7E, 0x70, 0x02, 0xAC, 0xB7, 0x7A, 0x57, 0x37, 0x6C, 0x7E, 0x37, + 0x37, 0x70, 0x3E, 0x34, 0x7A, 0x37, 0x37, 0x70, 0x7E, 0x37, 0x37, 0x72, + 0x3E, 0x34, 0x7A, 0x37, 0x37, 0x72, 0x7E, 0x37, 0x37, 0x74, 0x3E, 0x34, + 0x7A, 0x37, 0x37, 0x74, 0x7E, 0x37, 0x37, 0x76, 0x3E, 0x34, 0x7A, 0x37, + 0x37, 0x76, 0x7E, 0x37, 0x37, 0x78, 0x3E, 0x34, 0x7A, 0x37, 0x37, 0x78, + 0x7E, 0x37, 0x37, 0x7A, 0x3E, 0x34, 0x7A, 0x37, 0x37, 0x7A, 0x6C, 0xDD, + 0x02, 0x10, 0xE1, 0x0A, 0x3D, 0x09, 0x73, 0x07, 0x27, 0xBE, 0x70, 0x01, + 0x38, 0x0D, 0x6C, 0x77, 0x74, 0x0B, 0xAC, 0xBD, 0x19, 0x75, 0x09, 0x83, + 0x02, 0x10, 0xDF, 0x7E, 0x34, 0x37, 0x7C, 0x7E, 0x50, 0x0B, 0xAC, 0x5D, + 0x2E, 0x24, 0x09, 0x83, 0x74, 0x0B, 0x12, 0xF3, 0x33, 0x0A, 0x3D, 0x09, + 0xB3, 0x07, 0x31, 0x60, 0x75, 0x0A, 0x3D, 0x09, 0x63, 0x07, 0x95, 0x7E, + 0x70, 0x10, 0xAC, 0x67, 0x2E, 0x34, 0x07, 0x9F, 0x7A, 0x37, 0x37, 0x87, + 0x09, 0x53, 0x00, 0x07, 0x7A, 0x53, 0x37, 0x49, 0x09, 0x53, 0x00, 0x08, + 0x7A, 0x53, 0x37, 0x4A, 0x09, 0x53, 0x00, 0x09, 0x7A, 0x53, 0x37, 0x4D, + 0x09, 0x73, 0x00, 0x0A, 0x7A, 0x73, 0x37, 0x4E, 0x7E, 0xB3, 0x37, 0x46, + 0x60, 0x3C, 0x7E, 0x73, 0x37, 0x4D, 0x7C, 0x67, 0x6E, 0x63, 0x37, 0x49, + 0x7A, 0x63, 0x37, 0x49, 0x6E, 0x73, 0x37, 0x49, 0x7A, 0x73, 0x37, 0x4D, + 0x6E, 0x73, 0x37, 0x49, 0x7A, 0x73, 0x37, 0x49, 0x7E, 0x73, 0x37, 0x4E, + 0x7C, 0x67, 0x6E, 0x63, 0x37, 0x4A, 0x7A, 0x63, 0x37, 0x4A, 0x6E, 0x73, + 0x37, 0x4A, 0x7A, 0x73, 0x37, 0x4E, 0x6E, 0x73, 0x37, 0x4A, 0x7A, 0x73, + 0x37, 0x4A, 0x7E, 0x70, 0x04, 0xAC, 0x7D, 0x2E, 0x34, 0x00, 0x03, 0x7A, + 0x73, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x45, 0x7E, 0x70, 0x02, 0xAC, 0xB7, + 0x49, 0x35, 0x05, 0xF1, 0x7A, 0x37, 0x37, 0x55, 0x49, 0x25, 0x06, 0x41, + 0x7A, 0x27, 0x37, 0x5D, 0x7E, 0x27, 0x04, 0x22, 0x7A, 0x27, 0x37, 0x89, + 0x7E, 0x53, 0x04, 0x27, 0x7A, 0x53, 0x37, 0x8C, 0x7E, 0x24, 0x37, 0x48, + 0x7A, 0x27, 0x37, 0x8D, 0x7E, 0x27, 0x05, 0x1C, 0x7E, 0xB3, 0x05, 0x17, + 0x7E, 0x33, 0x04, 0x1C, 0x7E, 0x23, 0x04, 0x1E, 0x7E, 0x13, 0x04, 0x20, + 0x7E, 0x03, 0x04, 0x26, 0x12, 0x84, 0x66, 0x7A, 0x37, 0x37, 0x57, 0x7E, + 0x37, 0x04, 0x24, 0x7A, 0x37, 0x37, 0x89, 0x7E, 0x73, 0x04, 0x29, 0x7A, + 0x73, 0x37, 0x8C, 0x7E, 0x34, 0x37, 0x48, 0x7A, 0x37, 0x37, 0x8D, 0x7E, + 0x37, 0x37, 0x5D, 0x7E, 0x27, 0x05, 0x1E, 0x7E, 0xB3, 0x05, 0x18, 0x7E, + 0x33, 0x04, 0x1D, 0x7E, 0x23, 0x04, 0x1F, 0x7E, 0x13, 0x04, 0x21, 0x7E, + 0x03, 0x04, 0x28, 0x12, 0x84, 0x66, 0x7A, 0x37, 0x37, 0x5F, 0x7E, 0xB3, + 0x37, 0x46, 0x60, 0x1E, 0x7E, 0x37, 0x37, 0x5F, 0x7D, 0x23, 0x6E, 0x27, + 0x37, 0x57, 0x7A, 0x27, 0x37, 0x57, 0x6E, 0x37, 0x37, 0x57, 0x7A, 0x37, + 0x37, 0x5F, 0x6E, 0x37, 0x37, 0x57, 0x7A, 0x37, 0x37, 0x57, 0x0A, 0x3D, + 0x09, 0xB3, 0x07, 0x27, 0xB4, 0x05, 0x61, 0x7E, 0x73, 0x37, 0x7C, 0xBE, + 0x70, 0x03, 0x40, 0x41, 0xBE, 0x70, 0x05, 0x38, 0x3C, 0x7E, 0x73, 0x37, + 0x7D, 0xBE, 0x70, 0x24, 0x50, 0x33, 0x7E, 0x37, 0x37, 0x5F, 0x7E, 0x27, + 0x37, 0x85, 0x12, 0xF3, 0xFB, 0x7D, 0x73, 0x7E, 0x37, 0x37, 0x57, 0x7E, + 0x27, 0x37, 0x83, 0x12, 0xF3, 0xFB, 0x2D, 0x37, 0x7A, 0x37, 0x37, 0x5B, + 0x7E, 0x37, 0x37, 0x6C, 0xBE, 0x37, 0x37, 0x5B, 0x08, 0x0B, 0x74, 0x08, + 0x7A, 0xB3, 0x37, 0x7C, 0xE4, 0x7A, 0xB3, 0x37, 0x7E, 0x7E, 0xB3, 0x37, + 0x7C, 0xB4, 0x08, 0x0C, 0x7E, 0x73, 0x37, 0x7E, 0xBE, 0x70, 0x05, 0x38, + 0x03, 0x02, 0x10, 0x5F, 0xE4, 0x02, 0x10, 0x5B, 0x0A, 0x3D, 0x09, 0xB3, + 0x07, 0x31, 0x70, 0x03, 0x02, 0x10, 0xDF, 0x7E, 0xB3, 0x37, 0x7C, 0x70, + 0x3D, 0x7E, 0x34, 0x37, 0x7C, 0x7E, 0x24, 0x00, 0x0B, 0x12, 0xF2, 0xA4, + 0x74, 0x04, 0x7A, 0xB3, 0x37, 0x7C, 0x7E, 0x37, 0x37, 0x55, 0x7A, 0x37, + 0x37, 0x7F, 0x7E, 0x37, 0x37, 0x5D, 0x7A, 0x37, 0x37, 0x81, 0x7E, 0x37, + 0x37, 0x57, 0x7A, 0x37, 0x37, 0x83, 0x7E, 0x37, 0x37, 0x5F, 0x7A, 0x37, + 0x37, 0x85, 0x7E, 0xB3, 0x37, 0x67, 0x70, 0x06, 0x74, 0x07, 0x7A, 0xB3, + 0x37, 0x7C, 0x7E, 0xB3, 0x37, 0x7C, 0xBE, 0xB0, 0x07, 0x78, 0x03, 0x02, + 0x10, 0x5F, 0x7E, 0x73, 0x37, 0x4D, 0x1A, 0x27, 0x7E, 0x73, 0x37, 0x4E, + 0x1A, 0x37, 0x9D, 0x32, 0x0B, 0x34, 0x7A, 0x73, 0x37, 0x50, 0x7E, 0x37, + 0x37, 0x59, 0x9E, 0x37, 0x37, 0x57, 0x7A, 0x37, 0x37, 0x5B, 0x7E, 0x37, + 0x37, 0x61, 0x9E, 0x37, 0x37, 0x5F, 0x7A, 0x37, 0x37, 0x63, 0x7E, 0x37, + 0x37, 0x57, 0xBE, 0x37, 0x37, 0x5B, 0x58, 0x12, 0x7A, 0x37, 0x37, 0x5B, + 0x7E, 0x73, 0x37, 0x49, 0x7A, 0x73, 0x37, 0x4C, 0x7E, 0x18, 0x09, 0xF2, + 0x80, 0x18, 0x7E, 0x73, 0x37, 0x4A, 0x1A, 0x27, 0x7E, 0x73, 0x37, 0x4B, + 0x1A, 0x37, 0x9D, 0x32, 0x1B, 0x34, 0x7A, 0x73, 0x37, 0x4C, 0x7E, 0x18, + 0x0A, 0x1A, 0x7A, 0x1F, 0x37, 0x51, 0xE4, 0x7A, 0xB3, 0x37, 0x66, 0x7E, + 0x37, 0x37, 0x5F, 0x7E, 0x27, 0x37, 0x85, 0x12, 0xF3, 0xFB, 0xBE, 0x37, + 0x37, 0x6E, 0x08, 0x06, 0x74, 0x01, 0x7A, 0xB3, 0x37, 0x66, 0xE4, 0x7A, + 0xB3, 0x37, 0x65, 0x7E, 0x37, 0x37, 0x74, 0xBE, 0x37, 0x37, 0x5B, 0x08, + 0x0A, 0x7E, 0x37, 0x37, 0x76, 0xBE, 0x37, 0x37, 0x63, 0x18, 0x14, 0x7E, + 0x37, 0x37, 0x78, 0xBE, 0x37, 0x37, 0x5B, 0x08, 0x10, 0x7E, 0x37, 0x37, + 0x7A, 0xBE, 0x37, 0x37, 0x63, 0x08, 0x06, 0x74, 0x01, 0x7A, 0xB3, 0x37, + 0x65, 0x7E, 0xB3, 0x37, 0x7C, 0xB4, 0x01, 0x0E, 0x7E, 0x73, 0x37, 0x6A, + 0xBE, 0x73, 0x37, 0x4C, 0x50, 0x1A, 0x74, 0x04, 0x80, 0x12, 0x7E, 0xB3, + 0x37, 0x4C, 0x70, 0x10, 0x7E, 0x73, 0x37, 0x69, 0xBE, 0x73, 0x37, 0x50, + 0x38, 0x06, 0x74, 0x01, 0x7A, 0xB3, 0x37, 0x7C, 0x7E, 0xB3, 0x37, 0x7C, + 0xB4, 0x02, 0x20, 0x7E, 0x37, 0x37, 0x72, 0xBE, 0x37, 0x37, 0x5B, 0x48, + 0x06, 0x7E, 0xB3, 0x37, 0x66, 0x60, 0x10, 0x7E, 0xB3, 0x37, 0x65, 0x70, + 0x04, 0x74, 0x07, 0x80, 0x02, 0x74, 0x06, 0x7A, 0xB3, 0x37, 0x7C, 0x7E, + 0xB3, 0x37, 0x7C, 0xB4, 0x03, 0x2A, 0x7E, 0x37, 0x37, 0x70, 0xBE, 0x37, + 0x37, 0x5B, 0x58, 0x04, 0x74, 0x04, 0x80, 0x18, 0x7E, 0xB3, 0x37, 0x68, + 0x60, 0x16, 0x7E, 0xB3, 0x37, 0x66, 0x60, 0x10, 0x7E, 0xB3, 0x37, 0x65, + 0x70, 0x04, 0x74, 0x07, 0x80, 0x02, 0x74, 0x06, 0x7A, 0xB3, 0x37, 0x7C, + 0x7E, 0xB3, 0x37, 0x7C, 0xB4, 0x04, 0x38, 0x7E, 0x37, 0x37, 0x70, 0xBE, + 0x37, 0x37, 0x5B, 0x48, 0x04, 0x74, 0x03, 0x80, 0x26, 0x7E, 0xB3, 0x37, + 0x66, 0x70, 0x14, 0x7E, 0x37, 0x37, 0x72, 0xBE, 0x37, 0x37, 0x5B, 0x48, + 0x0A, 0x7E, 0x73, 0x37, 0x67, 0xBE, 0x73, 0x37, 0x7D, 0x50, 0x10, 0x7E, + 0xB3, 0x37, 0x65, 0x70, 0x04, 0x74, 0x07, 0x80, 0x02, 0x74, 0x06, 0x7A, + 0xB3, 0x37, 0x7C, 0x7E, 0xB3, 0x37, 0x7C, 0xBE, 0xB0, 0x07, 0x78, 0x03, + 0x02, 0x0F, 0xA7, 0xBE, 0xB0, 0x01, 0x78, 0x03, 0x02, 0x0F, 0xA7, 0x7E, + 0xB3, 0x37, 0x4C, 0x60, 0x03, 0x02, 0x0F, 0xA7, 0x7E, 0x73, 0x37, 0x4D, + 0x1A, 0x37, 0x1B, 0x35, 0x7C, 0xC7, 0x7E, 0x73, 0x37, 0x4E, 0x1A, 0x37, + 0x0B, 0x35, 0x7A, 0x73, 0x37, 0x48, 0xBE, 0xC0, 0x00, 0x58, 0x02, 0x6C, + 0xCC, 0x7E, 0x73, 0x37, 0x48, 0xBE, 0x70, 0x28, 0x48, 0x2C, 0x74, 0x27, + 0x7A, 0xB3, 0x37, 0x48, 0x80, 0x24, 0x1A, 0x1C, 0x7E, 0x1F, 0x37, 0x51, + 0x2D, 0x31, 0x7E, 0x1B, 0x60, 0x7E, 0x14, 0xF7, 0xFB, 0x7E, 0x04, 0x00, + 0xFF, 0x7E, 0x0B, 0x70, 0xBC, 0x67, 0x28, 0x08, 0x74, 0x01, 0x7A, 0xB3, + 0x37, 0x7C, 0x80, 0x0A, 0x0B, 0xC0, 0x7E, 0x73, 0x37, 0x48, 0xBC, 0x7C, + 0x58, 0xD4, 0x7E, 0xB3, 0x37, 0x7C, 0xBE, 0xB0, 0x01, 0x78, 0x03, 0x02, + 0x0F, 0xA7, 0xE4, 0x7A, 0xB3, 0x37, 0x48, 0x7E, 0x73, 0x37, 0x4D, 0x1A, + 0x37, 0x1B, 0x34, 0x7C, 0xC7, 0x80, 0x2D, 0x1A, 0x1C, 0x7E, 0x1F, 0x37, + 0x51, 0x2D, 0x31, 0x7E, 0x1B, 0xB0, 0x70, 0x10, 0x7E, 0xB3, 0x37, 0x48, + 0x04, 0x7A, 0xB3, 0x37, 0x48, 0xBE, 0xB0, 0x04, 0x68, 0x17, 0x80, 0x0E, + 0xE4, 0x7A, 0xB3, 0x37, 0x48, 0x7E, 0xB3, 0x37, 0x50, 0x04, 0x7A, 0xB3, + 0x37, 0x50, 0x1B, 0xC0, 0xBE, 0xC0, 0x00, 0x58, 0xCE, 0xE4, 0x7A, 0xB3, + 0x37, 0x48, 0x7E, 0x73, 0x37, 0x4E, 0x1A, 0x37, 0x0B, 0x34, 0x7C, 0xC7, + 0x80, 0x2D, 0x1A, 0x1C, 0x7E, 0x1F, 0x37, 0x51, 0x2D, 0x31, 0x7E, 0x1B, + 0xB0, 0x70, 0x10, 0x7E, 0xB3, 0x37, 0x48, 0x04, 0x7A, 0xB3, 0x37, 0x48, + 0xBE, 0xB0, 0x04, 0x68, 0x1A, 0x80, 0x0E, 0xE4, 0x7A, 0xB3, 0x37, 0x48, + 0x7E, 0xB3, 0x37, 0x50, 0x04, 0x7A, 0xB3, 0x37, 0x50, 0x0B, 0xC0, 0x7E, + 0x73, 0x37, 0x4F, 0xBC, 0x7C, 0x18, 0xCB, 0x7E, 0x73, 0x37, 0x6B, 0xBE, + 0x73, 0x37, 0x50, 0x38, 0x06, 0x74, 0x02, 0x7A, 0xB3, 0x37, 0x7C, 0x7E, + 0xA3, 0x37, 0x7C, 0xBE, 0xA0, 0x01, 0x68, 0x0B, 0xBE, 0xA0, 0x06, 0x38, + 0x5A, 0x7E, 0xB3, 0x37, 0x4C, 0x70, 0x54, 0x0A, 0x3A, 0x6D, 0x22, 0x2E, + 0x24, 0x00, 0xFF, 0x2E, 0x18, 0xF7, 0xF9, 0x7E, 0x1B, 0xB0, 0x7A, 0xB3, + 0x37, 0x47, 0x60, 0x3F, 0x7E, 0x73, 0x37, 0x4D, 0x1A, 0x17, 0x7E, 0x1F, + 0x37, 0x51, 0x2D, 0x31, 0x80, 0x23, 0x7E, 0xB3, 0x37, 0x4D, 0x04, 0x7A, + 0xB3, 0x37, 0x4D, 0x7E, 0x0F, 0x37, 0x51, 0x7E, 0x0B, 0x70, 0xBE, 0x73, + 0x37, 0x47, 0x50, 0x07, 0x7E, 0x73, 0x37, 0x47, 0x7A, 0x0B, 0x70, 0x7E, + 0x1F, 0x37, 0x51, 0x0B, 0x34, 0x7A, 0x1F, 0x37, 0x51, 0x7E, 0x73, 0x37, + 0x4E, 0xBE, 0x73, 0x37, 0x4D, 0x58, 0xCF, 0x7E, 0xB3, 0x37, 0x7C, 0xB4, + 0x06, 0x27, 0x7E, 0xB3, 0x09, 0xF1, 0x60, 0x21, 0x74, 0x05, 0x7A, 0xB3, + 0x37, 0x7C, 0x7E, 0xB3, 0x37, 0x7E, 0x60, 0x15, 0xE4, 0x7A, 0xB3, 0x37, + 0x7E, 0x7E, 0x37, 0x37, 0x55, 0x7A, 0x37, 0x37, 0x7F, 0x7E, 0x37, 0x37, + 0x5D, 0x7A, 0x37, 0x37, 0x81, 0x7E, 0xB3, 0x37, 0x7C, 0xBE, 0xB0, 0x06, + 0x68, 0x03, 0xB4, 0x05, 0x16, 0x7E, 0xB3, 0x37, 0x65, 0x70, 0x10, 0x7E, + 0x73, 0x37, 0x67, 0xBE, 0x73, 0x37, 0x7D, 0x50, 0x06, 0x74, 0x07, 0x7A, + 0xB3, 0x37, 0x7C, 0x7E, 0xB3, 0x37, 0x7C, 0xBE, 0xB0, 0x06, 0x40, 0x3C, + 0xB4, 0x07, 0x06, 0x74, 0x08, 0x7A, 0xB3, 0x09, 0xF1, 0x7E, 0xB3, 0x37, + 0x7E, 0x70, 0x1F, 0x7E, 0x47, 0x37, 0x7F, 0x7E, 0xB3, 0x37, 0x45, 0x7E, + 0x70, 0x02, 0xAC, 0xB7, 0x59, 0x45, 0x05, 0xF1, 0x7E, 0x47, 0x37, 0x81, + 0x7E, 0xB3, 0x37, 0x45, 0xAC, 0xB7, 0x59, 0x45, 0x06, 0x41, 0x7E, 0xB3, + 0x37, 0x7E, 0xBE, 0xB0, 0xFF, 0x68, 0x05, 0x04, 0x7A, 0xB3, 0x37, 0x7E, + 0x7E, 0xB3, 0x37, 0x7D, 0xBE, 0xB0, 0xFF, 0x68, 0x05, 0x04, 0x7A, 0xB3, + 0x37, 0x7D, 0x7E, 0x73, 0x37, 0x7C, 0xBE, 0x70, 0x06, 0x40, 0x12, 0x0A, + 0x3D, 0x09, 0xB3, 0x07, 0x81, 0xB4, 0xFF, 0x09, 0x12, 0xF0, 0x29, 0x0A, + 0x3D, 0x19, 0xB3, 0x07, 0x81, 0x7E, 0x70, 0x0B, 0xAC, 0x7D, 0x2E, 0x34, + 0x09, 0x83, 0x7E, 0x24, 0x37, 0x7C, 0x74, 0x0B, 0x12, 0xF3, 0x33, 0x0B, + 0xD0, 0xBE, 0xD0, 0x0A, 0x50, 0x03, 0x02, 0x0A, 0xEF, 0x7E, 0xB3, 0x03, + 0xB7, 0x70, 0x19, 0x7E, 0x34, 0x09, 0xF2, 0x12, 0xF2, 0x8F, 0x7E, 0x34, + 0x0A, 0x1A, 0x12, 0xF2, 0x8F, 0x7E, 0xB3, 0x09, 0xF1, 0x60, 0x05, 0x14, + 0x7A, 0xB3, 0x09, 0xF1, 0x7E, 0x34, 0x09, 0xF2, 0x12, 0xF2, 0x8F, 0x7E, + 0x34, 0x0A, 0x1A, 0x12, 0xF2, 0x8F, 0xDA, 0x3B, 0x22, 0xCA, 0x3B, 0x7C, + 0xFB, 0x7F, 0x71, 0x7F, 0x60, 0x7E, 0x73, 0x37, 0x21, 0x0A, 0x37, 0x3E, + 0x34, 0x3E, 0x34, 0x7A, 0x37, 0x38, 0x00, 0x7E, 0x73, 0x37, 0x23, 0x0A, + 0x27, 0x7E, 0x73, 0x2E, 0x57, 0x0A, 0x37, 0x9D, 0x32, 0x0E, 0x34, 0x7A, + 0x73, 0x38, 0x02, 0x7E, 0xB3, 0x37, 0x45, 0x70, 0x17, 0xE4, 0x7A, 0xB3, + 0x36, 0xFC, 0x7A, 0xB3, 0x2E, 0x5C, 0x7E, 0x08, 0x2E, 0x5D, 0x7E, 0x34, + 0x00, 0x04, 0x12, 0xF2, 0x33, 0x02, 0x18, 0x44, 0x6C, 0xEE, 0x02, 0x12, + 0x28, 0x74, 0x02, 0xAC, 0xBE, 0x7F, 0x17, 0x2D, 0x35, 0x0B, 0x1A, 0x30, + 0x7F, 0x06, 0x2D, 0x15, 0x0B, 0x0A, 0x40, 0x2D, 0x43, 0x59, 0x45, 0x37, + 0x4C, 0x6D, 0x33, 0x59, 0x35, 0x37, 0x94, 0x6C, 0xDD, 0x02, 0x12, 0x1B, + 0x7E, 0x73, 0x38, 0x02, 0xBC, 0x7D, 0x38, 0x38, 0x0A, 0x07, 0x7E, 0x73, + 0x2E, 0x57, 0x0A, 0x17, 0x9D, 0x10, 0x0A, 0x0D, 0xBD, 0x01, 0x58, 0x28, + 0x7E, 0x73, 0x37, 0x4B, 0x1A, 0x17, 0xAD, 0x10, 0x0A, 0x0E, 0x2D, 0x10, + 0x3E, 0x14, 0x7E, 0x1F, 0x37, 0x46, 0x2D, 0x31, 0x0B, 0x1A, 0x40, 0x7E, + 0x50, 0x02, 0xAC, 0x5E, 0x2E, 0x24, 0x37, 0x94, 0x0B, 0x28, 0x30, 0x2D, + 0x34, 0x1B, 0x28, 0x30, 0x4C, 0xEE, 0x78, 0x23, 0x7E, 0x73, 0x37, 0x4B, + 0x1A, 0x17, 0x0A, 0x0D, 0xAD, 0x10, 0x0A, 0x0E, 0x2D, 0x10, 0x3E, 0x14, + 0x7E, 0x1F, 0x37, 0x46, 0x2D, 0x31, 0x0B, 0x1A, 0x40, 0x74, 0x02, 0xAC, + 0xBD, 0x59, 0x45, 0x37, 0xDC, 0x80, 0x2A, 0x7E, 0x73, 0x37, 0x4B, 0x1A, + 0x17, 0x0A, 0x0D, 0xAD, 0x10, 0x0A, 0x0E, 0x2D, 0x10, 0x3E, 0x14, 0x7E, + 0x1F, 0x37, 0x46, 0x2D, 0x31, 0x0B, 0x1A, 0x40, 0x7E, 0x50, 0x02, 0xAC, + 0x5D, 0x2E, 0x24, 0x37, 0xDC, 0x0B, 0x28, 0x30, 0x2D, 0x34, 0x1B, 0x28, + 0x30, 0x0B, 0xD0, 0x7E, 0x73, 0x2E, 0x57, 0xBC, 0x7D, 0x28, 0x03, 0x02, + 0x11, 0x88, 0x0B, 0xE0, 0x7E, 0x63, 0x2E, 0x56, 0xBC, 0x6E, 0x28, 0x03, + 0x02, 0x11, 0x65, 0x7E, 0xB3, 0x2E, 0x5C, 0x70, 0x03, 0x02, 0x15, 0x74, + 0x7E, 0x08, 0x30, 0x61, 0x7A, 0x0F, 0x38, 0x1C, 0x7E, 0x08, 0x31, 0x61, + 0x7A, 0x0F, 0x38, 0x20, 0x7C, 0xBF, 0x7E, 0x73, 0x2E, 0x5A, 0x7E, 0x50, + 0x20, 0x7E, 0x08, 0x37, 0x4C, 0x12, 0xB5, 0xBF, 0x7E, 0x18, 0x33, 0xE1, + 0x7A, 0x1F, 0x38, 0x1C, 0x7E, 0x18, 0x34, 0xE1, 0x7A, 0x1F, 0x38, 0x20, + 0x7C, 0xBF, 0x7E, 0x73, 0x2E, 0x5A, 0x7E, 0x63, 0x2E, 0x56, 0x7E, 0x50, + 0x20, 0x7E, 0x08, 0x37, 0x94, 0x12, 0xB5, 0xBF, 0x7E, 0x18, 0x36, 0x41, + 0x7A, 0x1F, 0x38, 0x1C, 0x7E, 0x18, 0x36, 0xD1, 0x7A, 0x1F, 0x38, 0x20, + 0x7C, 0xBF, 0x7E, 0x73, 0x2E, 0x5A, 0x7E, 0x63, 0x2E, 0x57, 0x7E, 0x50, + 0x12, 0x7E, 0x08, 0x37, 0xDC, 0x12, 0xB5, 0xBF, 0x6C, 0xEE, 0x80, 0x42, + 0x74, 0x02, 0xAC, 0xBE, 0x49, 0x35, 0x34, 0xE1, 0x1A, 0x26, 0x1A, 0x24, + 0x7E, 0xD7, 0x38, 0x00, 0x7D, 0x1D, 0x1A, 0x12, 0x1A, 0xC2, 0x7E, 0x08, + 0x01, 0x00, 0x9F, 0x06, 0x12, 0x8C, 0xBA, 0x7F, 0x71, 0x74, 0x02, 0xAC, + 0xBE, 0x49, 0x35, 0x31, 0x61, 0x1A, 0x26, 0x1A, 0x24, 0x7F, 0x06, 0x12, + 0x8C, 0xBA, 0x2F, 0x17, 0x7C, 0x76, 0x7C, 0x65, 0x74, 0x02, 0xAC, 0xBE, + 0x59, 0x35, 0x31, 0x61, 0x0B, 0xE0, 0x7E, 0x73, 0x2E, 0x56, 0xBC, 0x7E, + 0x38, 0xB6, 0xE4, 0x7A, 0xB3, 0x38, 0x0F, 0x7A, 0xB3, 0x38, 0x10, 0x7A, + 0xB3, 0x38, 0x11, 0x7A, 0xB3, 0x38, 0x12, 0x7E, 0x18, 0x36, 0xD1, 0x7A, + 0x1F, 0x38, 0x1C, 0x7E, 0x18, 0x38, 0x16, 0x7A, 0x1F, 0x38, 0x20, 0x7E, + 0x18, 0x38, 0x17, 0x7A, 0x1F, 0x38, 0x24, 0x7E, 0x08, 0x38, 0x14, 0x7E, + 0x18, 0x38, 0x13, 0x7E, 0xB3, 0x2E, 0x57, 0x12, 0x37, 0x39, 0x7E, 0x18, + 0x31, 0x61, 0x7A, 0x1F, 0x38, 0x1C, 0x7E, 0x18, 0x38, 0x18, 0x7A, 0x1F, + 0x38, 0x20, 0x7E, 0x18, 0x38, 0x19, 0x7A, 0x1F, 0x38, 0x24, 0x7E, 0x08, + 0x38, 0x14, 0x7E, 0x18, 0x38, 0x13, 0x7E, 0xB3, 0x2E, 0x56, 0x12, 0x37, + 0x39, 0x7E, 0xB3, 0x36, 0xF5, 0x60, 0x6A, 0x7E, 0xD0, 0x01, 0x7E, 0xB3, + 0x37, 0x0F, 0x70, 0x0C, 0x74, 0x02, 0xAC, 0xBD, 0x49, 0x35, 0x37, 0x09, + 0x59, 0x35, 0x36, 0xFD, 0x7E, 0x37, 0x37, 0x09, 0xBE, 0x37, 0x38, 0x14, + 0x58, 0x3B, 0x7E, 0x50, 0x02, 0xAC, 0x5D, 0x2E, 0x24, 0x36, 0xFD, 0x0B, + 0x28, 0x30, 0x0B, 0x34, 0x1B, 0x28, 0x30, 0x0A, 0x3D, 0x09, 0x73, 0x37, + 0x12, 0x3E, 0x34, 0x3E, 0x34, 0x74, 0x02, 0xAC, 0xBD, 0x49, 0x45, 0x37, + 0x03, 0x2D, 0x43, 0x7A, 0x47, 0x38, 0x1A, 0x49, 0x45, 0x36, 0xFD, 0xBE, + 0x47, 0x38, 0x1A, 0x08, 0x08, 0x7E, 0x37, 0x38, 0x1A, 0x59, 0x35, 0x36, + 0xFD, 0x0B, 0xD0, 0xBE, 0xD0, 0x03, 0x78, 0xA2, 0x74, 0x01, 0x7A, 0xB3, + 0x37, 0x0F, 0x02, 0x14, 0x55, 0x7E, 0xB3, 0x37, 0x0F, 0xB4, 0x01, 0x02, + 0x80, 0x03, 0x02, 0x14, 0x55, 0x7E, 0xD0, 0x01, 0x74, 0x02, 0xAC, 0xBD, + 0x49, 0xF5, 0x36, 0xFD, 0x7D, 0x3F, 0x1A, 0x36, 0x1A, 0xE6, 0x7E, 0x14, + 0x00, 0x07, 0x7F, 0x17, 0x12, 0x8C, 0xCB, 0x7E, 0x08, 0x00, 0x0A, 0x12, + 0x8D, 0x27, 0x7E, 0x57, 0x38, 0x14, 0x1A, 0x4A, 0x1A, 0x48, 0xBF, 0x21, + 0x58, 0x45, 0x7E, 0x14, 0x00, 0x7F, 0x7F, 0x17, 0x12, 0x8C, 0xCB, 0x2F, + 0x12, 0x74, 0x07, 0x1E, 0x34, 0x0E, 0x24, 0x50, 0x03, 0x4E, 0x60, 0x80, + 0x14, 0x78, 0xF4, 0x74, 0x02, 0xAC, 0xBD, 0x59, 0x35, 0x36, 0xFD, 0x0A, + 0x3D, 0x09, 0x73, 0x37, 0x12, 0x3E, 0x34, 0x3E, 0x34, 0x7A, 0x37, 0x38, + 0x1A, 0x74, 0x02, 0xAC, 0xBD, 0x49, 0x45, 0x36, 0xFD, 0xBE, 0x47, 0x38, + 0x1A, 0x58, 0x08, 0x7E, 0x37, 0x38, 0x1A, 0x59, 0x35, 0x36, 0xFD, 0x74, + 0x02, 0xAC, 0xBD, 0x49, 0x35, 0x36, 0xFD, 0x59, 0x35, 0x37, 0x09, 0x0B, + 0xD0, 0xBE, 0xD0, 0x03, 0x68, 0x03, 0x02, 0x13, 0xD0, 0x7E, 0xB3, 0x37, + 0x0F, 0x70, 0x1E, 0x7E, 0xD0, 0x01, 0x0A, 0x3D, 0x09, 0x73, 0x37, 0x12, + 0x0A, 0x47, 0x3E, 0x44, 0x3E, 0x44, 0x74, 0x02, 0xAC, 0xBD, 0x59, 0x45, + 0x37, 0x09, 0x0B, 0xD0, 0xBE, 0xD0, 0x03, 0x78, 0xE5, 0x7E, 0xA3, 0x2E, + 0x5B, 0xBE, 0xA0, 0x03, 0x40, 0x36, 0x7E, 0xB3, 0x2E, 0x5C, 0xBE, 0xB0, + 0x03, 0x40, 0x2D, 0x7E, 0x37, 0x37, 0x0D, 0xBE, 0x37, 0x38, 0x14, 0x58, + 0x23, 0x74, 0x01, 0x7A, 0xB3, 0x38, 0x12, 0x7E, 0xB3, 0x37, 0x10, 0xBE, + 0xB3, 0x38, 0x13, 0x28, 0x13, 0x7E, 0xB3, 0x38, 0x18, 0xB4, 0x01, 0x0C, + 0x7E, 0xB3, 0x38, 0x17, 0x70, 0x06, 0x74, 0x01, 0x7A, 0xB3, 0x38, 0x0F, + 0xBE, 0xA0, 0x02, 0x40, 0x3A, 0x7E, 0x73, 0x2E, 0x5C, 0xBE, 0x70, 0x02, + 0x40, 0x31, 0x7E, 0x37, 0x37, 0x0B, 0xBE, 0x37, 0x38, 0x14, 0x58, 0x27, + 0x74, 0x01, 0x7A, 0xB3, 0x38, 0x12, 0x7E, 0x73, 0x37, 0x10, 0xBE, 0x73, + 0x38, 0x13, 0x28, 0x17, 0x7E, 0xB3, 0x38, 0x18, 0xB4, 0x01, 0x10, 0x7E, + 0xB3, 0x38, 0x17, 0x70, 0x0A, 0x74, 0x01, 0x7A, 0xB3, 0x38, 0x0F, 0x7A, + 0xB3, 0x38, 0x10, 0x7E, 0x37, 0x37, 0x09, 0xBE, 0x37, 0x38, 0x14, 0x58, + 0x28, 0x74, 0x01, 0x7A, 0xB3, 0x38, 0x12, 0x7E, 0xB3, 0x38, 0x17, 0x70, + 0x1C, 0x7E, 0xB3, 0x36, 0xF6, 0xB4, 0x01, 0x15, 0x7E, 0xB3, 0x36, 0xF7, + 0xB4, 0x01, 0x0E, 0x74, 0x01, 0x7A, 0xB3, 0x38, 0x0F, 0x7A, 0xB3, 0x38, + 0x10, 0x7A, 0xB3, 0x38, 0x11, 0xE4, 0x7E, 0x73, 0x38, 0x11, 0x12, 0xE6, + 0xB3, 0x74, 0x01, 0x7E, 0x73, 0x38, 0x10, 0x12, 0xE6, 0xB3, 0x74, 0x02, + 0x7E, 0x73, 0x38, 0x0F, 0x12, 0xE6, 0xB3, 0x7E, 0xB3, 0x38, 0x12, 0x60, + 0x13, 0x7E, 0xB3, 0x38, 0x17, 0x70, 0x0D, 0x7E, 0x08, 0x2E, 0x5D, 0x74, + 0xFC, 0x7E, 0x34, 0x00, 0x04, 0x12, 0xF2, 0x33, 0x7E, 0xA3, 0x37, 0x20, + 0x4C, 0xAA, 0x68, 0x10, 0x7E, 0xB3, 0x36, 0xF5, 0x60, 0x0A, 0xBE, 0xA3, + 0x2E, 0x5C, 0x50, 0x04, 0x7A, 0xA3, 0x2E, 0x5C, 0x7E, 0x34, 0xF7, 0xED, + 0x7E, 0x24, 0x00, 0xFF, 0x7E, 0x14, 0x38, 0x03, 0x74, 0x04, 0x12, 0x8D, + 0x5B, 0x7E, 0x34, 0xF7, 0xF1, 0x7E, 0x24, 0x00, 0xFF, 0x7E, 0x14, 0x38, + 0x07, 0x74, 0x04, 0x12, 0x8D, 0x5B, 0x7E, 0x34, 0xF7, 0xF5, 0x7E, 0x24, + 0x00, 0xFF, 0x7E, 0x14, 0x38, 0x0B, 0x74, 0x04, 0x12, 0x8D, 0x5B, 0x0A, + 0x3F, 0x09, 0xB3, 0x2E, 0x5D, 0xBE, 0xB0, 0x7F, 0x58, 0x08, 0x2E, 0x34, + 0x2E, 0x5D, 0x04, 0x7A, 0x39, 0xB0, 0x7E, 0x73, 0x2E, 0x5C, 0x0A, 0x37, + 0x09, 0xA3, 0x38, 0x03, 0x0A, 0x3F, 0x09, 0xB3, 0x2E, 0x5D, 0xBC, 0xBA, + 0x08, 0x03, 0x02, 0x16, 0xAA, 0xB4, 0x01, 0x30, 0x7E, 0x70, 0x80, 0xAC, + 0x7F, 0x2E, 0x34, 0x2E, 0x61, 0x7E, 0x24, 0x00, 0x80, 0x12, 0xF2, 0xA4, + 0x7E, 0x70, 0x80, 0xAC, 0x7F, 0x2E, 0x34, 0x31, 0xE1, 0x7E, 0x24, 0x00, + 0x80, 0x12, 0xF2, 0xA4, 0x7E, 0x70, 0x48, 0xAC, 0x7F, 0x2E, 0x34, 0x35, + 0x21, 0x7E, 0x24, 0x00, 0x48, 0x12, 0xF2, 0xA4, 0x6C, 0xEE, 0x80, 0x5E, + 0x74, 0x02, 0xAC, 0xBE, 0x49, 0xF5, 0x37, 0x4C, 0x7D, 0x3F, 0x1A, 0x36, + 0x1A, 0xE6, 0x7E, 0x10, 0x04, 0xAC, 0x1E, 0x7E, 0x30, 0x80, 0xAC, 0x3F, + 0x2D, 0x10, 0x2E, 0x14, 0x2E, 0x61, 0x49, 0x31, 0x00, 0x02, 0x0B, 0x18, + 0x20, 0x2F, 0x17, 0x59, 0x31, 0x00, 0x02, 0x1B, 0x18, 0x20, 0x74, 0x02, + 0xAC, 0xBE, 0x49, 0xF5, 0x37, 0x94, 0x7D, 0x3F, 0x1A, 0x36, 0x1A, 0xE6, + 0x7E, 0x10, 0x04, 0xAC, 0x1E, 0x7E, 0x30, 0x80, 0xAC, 0x3F, 0x2D, 0x10, + 0x2E, 0x14, 0x31, 0xE1, 0x49, 0x31, 0x00, 0x02, 0x0B, 0x18, 0x20, 0x2F, + 0x17, 0x59, 0x31, 0x00, 0x02, 0x1B, 0x18, 0x20, 0x0B, 0xE0, 0x7E, 0x73, + 0x2E, 0x56, 0xBC, 0x7E, 0x38, 0x9A, 0x6C, 0xEE, 0x80, 0x30, 0x74, 0x02, + 0xAC, 0xBE, 0x49, 0xF5, 0x37, 0xDC, 0x7D, 0x3F, 0x1A, 0x36, 0x1A, 0xE6, + 0x7E, 0x10, 0x04, 0xAC, 0x1E, 0x7E, 0x30, 0x48, 0xAC, 0x3F, 0x2D, 0x10, + 0x2E, 0x14, 0x35, 0x21, 0x49, 0x31, 0x00, 0x02, 0x0B, 0x18, 0x20, 0x2F, + 0x17, 0x59, 0x31, 0x00, 0x02, 0x1B, 0x18, 0x20, 0x0B, 0xE0, 0x7E, 0x73, + 0x2E, 0x57, 0xBC, 0x7E, 0x38, 0xC8, 0x6C, 0xCC, 0x80, 0x16, 0x7E, 0x73, + 0x2E, 0x5C, 0x0A, 0x37, 0x09, 0x63, 0x38, 0x07, 0x0A, 0x2C, 0x09, 0x72, + 0x2E, 0x5D, 0xBC, 0x76, 0x08, 0x0A, 0x0B, 0xC0, 0x7E, 0x73, 0x2E, 0x58, + 0xBC, 0x7C, 0x38, 0xE2, 0x7E, 0x73, 0x2E, 0x58, 0xBC, 0x7C, 0x68, 0x03, + 0x02, 0x17, 0xF8, 0x6C, 0xCC, 0x02, 0x17, 0xC4, 0x6C, 0xEE, 0x80, 0x7C, + 0x7E, 0x10, 0x04, 0xAC, 0x1E, 0x7E, 0x30, 0x80, 0xAC, 0x3C, 0x2D, 0x10, + 0x49, 0x31, 0x2E, 0x63, 0x49, 0x21, 0x2E, 0x61, 0x7E, 0x33, 0x2E, 0x5C, + 0x0A, 0x13, 0x09, 0xB1, 0x38, 0x0B, 0x60, 0x0C, 0x1E, 0x34, 0x0E, 0x24, + 0x50, 0x03, 0x4E, 0x60, 0x80, 0x14, 0x78, 0xF4, 0x7D, 0x43, 0x7E, 0x70, + 0x02, 0xAC, 0x7E, 0x74, 0x40, 0xAC, 0xBC, 0x2D, 0x53, 0x59, 0x45, 0x30, + 0x61, 0x7E, 0x10, 0x04, 0xAC, 0x1E, 0x7E, 0x30, 0x80, 0xAC, 0x3C, 0x2D, + 0x10, 0x49, 0x31, 0x31, 0xE3, 0x49, 0x21, 0x31, 0xE1, 0x7E, 0x33, 0x2E, + 0x5C, 0x0A, 0x13, 0x09, 0xB1, 0x38, 0x0B, 0x60, 0x0C, 0x1E, 0x34, 0x0E, + 0x24, 0x50, 0x03, 0x4E, 0x60, 0x80, 0x14, 0x78, 0xF4, 0x7D, 0x43, 0x7E, + 0x70, 0x02, 0xAC, 0x7E, 0x74, 0x40, 0xAC, 0xBC, 0x2D, 0x53, 0x59, 0x45, + 0x33, 0xE1, 0x0B, 0xE0, 0x7E, 0x73, 0x2E, 0x56, 0xBC, 0x7E, 0x28, 0x03, + 0x02, 0x16, 0xE0, 0x6C, 0xEE, 0x80, 0x3F, 0x7E, 0x10, 0x04, 0xAC, 0x1E, + 0x7E, 0x30, 0x48, 0xAC, 0x3C, 0x2D, 0x10, 0x49, 0x31, 0x35, 0x23, 0x49, + 0x21, 0x35, 0x21, 0x7E, 0x33, 0x2E, 0x5C, 0x0A, 0x13, 0x09, 0xB1, 0x38, + 0x0B, 0x60, 0x0C, 0x1E, 0x34, 0x0E, 0x24, 0x50, 0x03, 0x4E, 0x60, 0x80, + 0x14, 0x78, 0xF4, 0x7D, 0x43, 0x7E, 0x70, 0x02, 0xAC, 0x7E, 0x74, 0x24, + 0xAC, 0xBC, 0x2D, 0x53, 0x59, 0x45, 0x36, 0x41, 0x0B, 0xE0, 0x7E, 0x73, + 0x2E, 0x57, 0xBC, 0x7E, 0x38, 0xB9, 0x7E, 0x73, 0x2E, 0x5C, 0x0A, 0x37, + 0x09, 0x73, 0x38, 0x03, 0x0A, 0x2C, 0x19, 0x72, 0x2E, 0x5D, 0x0B, 0xC0, + 0x7E, 0x73, 0x2E, 0x58, 0xBC, 0x7C, 0x28, 0x03, 0x02, 0x16, 0xDC, 0x7E, + 0xB3, 0x2E, 0x5C, 0x04, 0x7A, 0xB3, 0x2E, 0x5C, 0x7E, 0x73, 0x2E, 0x5C, + 0xBE, 0x70, 0x03, 0x40, 0x12, 0x74, 0x03, 0x7A, 0xB3, 0x2E, 0x5C, 0x7E, + 0x08, 0x2E, 0x5D, 0xE4, 0x7E, 0x34, 0x00, 0x04, 0x12, 0xF2, 0x33, 0xE4, + 0x7A, 0xB3, 0x37, 0x0F, 0x7E, 0xB3, 0x37, 0x45, 0xB4, 0x01, 0x27, 0xE4, + 0x7A, 0xB3, 0x36, 0xFC, 0x7E, 0xB3, 0x36, 0xF7, 0x60, 0x06, 0x74, 0x01, + 0x7A, 0xB3, 0x36, 0xFC, 0x7E, 0xB3, 0x36, 0xF6, 0x60, 0x06, 0x74, 0x02, + 0x7A, 0xB3, 0x36, 0xFC, 0x7E, 0xB3, 0x36, 0xF5, 0x60, 0x22, 0x74, 0x03, + 0x80, 0x1A, 0x74, 0x04, 0x7A, 0xB3, 0x36, 0xFC, 0x7E, 0xB3, 0x36, 0xF5, + 0x70, 0x12, 0x7E, 0xB3, 0x36, 0xF6, 0x70, 0x0C, 0x7E, 0xB3, 0x36, 0xF7, + 0x70, 0x06, 0x74, 0x05, 0x7A, 0xB3, 0x36, 0xFC, 0xDA, 0x3B, 0x22, 0xCA, + 0x3B, 0x7E, 0xB3, 0x04, 0x50, 0x7E, 0x70, 0x04, 0xAC, 0xB7, 0x7A, 0x57, + 0x37, 0x65, 0x7E, 0xB3, 0x04, 0x4F, 0xAC, 0xB7, 0x7A, 0x57, 0x37, 0x67, + 0x7E, 0x73, 0x05, 0x18, 0x0A, 0x37, 0x1B, 0x34, 0x7C, 0x67, 0x6C, 0x77, + 0x9E, 0x37, 0x37, 0x67, 0x7A, 0x37, 0x37, 0x69, 0x7E, 0x73, 0x04, 0x51, + 0x0A, 0x77, 0x4D, 0x77, 0x78, 0x04, 0x7E, 0x74, 0x20, 0x00, 0x6C, 0xDD, + 0x7E, 0x70, 0x10, 0xAC, 0x7D, 0x2E, 0x34, 0x08, 0xE3, 0x7A, 0x37, 0x37, + 0x61, 0x0A, 0x3D, 0x09, 0xB3, 0x07, 0x31, 0x70, 0x03, 0x02, 0x1D, 0xE0, + 0x7E, 0x34, 0x37, 0x51, 0x7E, 0x27, 0x37, 0x61, 0x74, 0x10, 0x12, 0xF3, + 0x33, 0x0A, 0x3D, 0x09, 0xC3, 0x07, 0x95, 0x74, 0x10, 0xAC, 0xBC, 0x49, + 0x35, 0x07, 0xA1, 0x7A, 0x37, 0x37, 0x6B, 0x74, 0x03, 0xAC, 0xBC, 0x7C, + 0xCB, 0x74, 0x02, 0xAC, 0xBC, 0x49, 0x45, 0x03, 0x52, 0x7A, 0x47, 0x37, + 0x45, 0x49, 0x35, 0x03, 0x54, 0x7A, 0x37, 0x37, 0x47, 0x7E, 0x70, 0x04, + 0xAC, 0x7D, 0x2E, 0x34, 0x00, 0x03, 0x7C, 0xC7, 0x0A, 0x3D, 0x09, 0xB3, + 0x07, 0x27, 0xB4, 0x01, 0x02, 0x80, 0x03, 0x02, 0x19, 0x97, 0x7E, 0xB3, + 0x37, 0x51, 0x70, 0x19, 0x74, 0x01, 0x7A, 0xB3, 0x37, 0x51, 0x7E, 0x37, + 0x37, 0x45, 0x7A, 0x37, 0x37, 0x5B, 0x7E, 0x37, 0x37, 0x47, 0x7A, 0x37, + 0x37, 0x5D, 0x02, 0x1D, 0xC5, 0x0A, 0x3D, 0x09, 0xB3, 0x0A, 0xB5, 0xB4, + 0x10, 0x51, 0xE4, 0x7A, 0xB3, 0x37, 0x52, 0x9F, 0x11, 0x7A, 0x1F, 0x37, + 0x53, 0x7A, 0x1F, 0x37, 0x57, 0x7E, 0x37, 0x37, 0x45, 0x7A, 0x37, 0x37, + 0x5B, 0x7E, 0x37, 0x37, 0x47, 0x7A, 0x37, 0x37, 0x5D, 0x7E, 0x47, 0x37, + 0x45, 0x74, 0x02, 0xAC, 0xBD, 0x59, 0x45, 0x07, 0x4F, 0x7E, 0x47, 0x37, + 0x47, 0x74, 0x02, 0xAC, 0xBD, 0x59, 0x45, 0x07, 0x63, 0x7C, 0xBD, 0x7E, + 0x37, 0x37, 0x45, 0x7E, 0x27, 0x37, 0x47, 0x12, 0xDF, 0x28, 0x7C, 0xBD, + 0x7E, 0x37, 0x37, 0x45, 0x7E, 0x27, 0x37, 0x47, 0x12, 0xEC, 0xCC, 0x7E, + 0xB3, 0x37, 0x52, 0x04, 0x7A, 0xB3, 0x37, 0x52, 0x7E, 0x17, 0x37, 0x45, + 0x1A, 0x02, 0x1A, 0x00, 0x7E, 0x1F, 0x37, 0x53, 0x2F, 0x10, 0x7A, 0x1F, + 0x37, 0x53, 0x7E, 0x17, 0x37, 0x47, 0x1A, 0x02, 0x1A, 0x00, 0x7E, 0x1F, + 0x37, 0x57, 0x2F, 0x10, 0x7A, 0x1F, 0x37, 0x57, 0x02, 0x1D, 0xC5, 0x7E, + 0x73, 0x37, 0x51, 0xBE, 0x70, 0x01, 0x28, 0x03, 0x02, 0x1B, 0xC2, 0x7E, + 0x17, 0x37, 0x45, 0x7A, 0x17, 0x37, 0x49, 0x7E, 0xD7, 0x37, 0x47, 0x7A, + 0xD7, 0x37, 0x4B, 0x1A, 0x02, 0x1A, 0x00, 0x7E, 0x1F, 0x37, 0x53, 0x2F, + 0x10, 0x7E, 0x33, 0x37, 0x52, 0x0A, 0xF3, 0x6D, 0xEE, 0x0B, 0x7C, 0x7F, + 0x07, 0x12, 0x8D, 0x27, 0x7A, 0x37, 0x37, 0x45, 0x7D, 0x1D, 0x1A, 0x02, + 0x1A, 0x00, 0x7E, 0x1F, 0x37, 0x57, 0x2F, 0x10, 0x7F, 0x07, 0x12, 0x8D, + 0x27, 0x7A, 0x37, 0x37, 0x47, 0xE4, 0x7A, 0xB3, 0x37, 0x52, 0x7E, 0x37, + 0x08, 0xDF, 0x7A, 0x37, 0x37, 0x4D, 0x7E, 0x37, 0x08, 0xE1, 0x7A, 0x37, + 0x37, 0x4F, 0x7E, 0xB3, 0x03, 0xB7, 0x60, 0x03, 0x02, 0x1A, 0xA1, 0x7E, + 0x17, 0x37, 0x4D, 0xBE, 0x14, 0x80, 0x00, 0x78, 0x03, 0x02, 0x1A, 0xA1, + 0x7E, 0x37, 0x37, 0x45, 0x7E, 0x27, 0x37, 0x47, 0x7E, 0x07, 0x37, 0x4F, + 0x12, 0xF1, 0x4D, 0x7E, 0xA3, 0x04, 0x3D, 0x7C, 0xBA, 0x54, 0x7F, 0x0A, + 0x2B, 0xBD, 0x32, 0x38, 0x74, 0x7C, 0xBA, 0x30, 0xE7, 0x0E, 0x7E, 0x37, + 0x37, 0x4D, 0x7A, 0x37, 0x37, 0x45, 0x7E, 0x37, 0x37, 0x4F, 0x80, 0x5A, + 0x7E, 0x37, 0x37, 0x4D, 0x1A, 0x26, 0x1A, 0x24, 0x7E, 0x44, 0x00, 0x3F, + 0x7D, 0x14, 0x12, 0x8C, 0xCB, 0x7E, 0x17, 0x37, 0x45, 0x1A, 0x02, 0x1A, + 0x00, 0x2F, 0x10, 0x2E, 0x18, 0x00, 0x20, 0x74, 0x06, 0x1E, 0x34, 0x0E, + 0x24, 0x50, 0x03, 0x4E, 0x60, 0x80, 0x14, 0x78, 0xF4, 0x7A, 0x37, 0x37, + 0x45, 0x7E, 0x37, 0x37, 0x4F, 0x1A, 0x26, 0x1A, 0x24, 0x7D, 0x14, 0x12, + 0x8C, 0xCB, 0x7E, 0x17, 0x37, 0x47, 0x1A, 0x02, 0x1A, 0x00, 0x2F, 0x10, + 0x2E, 0x18, 0x00, 0x20, 0x74, 0x06, 0x1E, 0x34, 0x0E, 0x24, 0x50, 0x03, + 0x4E, 0x60, 0x80, 0x14, 0x78, 0xF4, 0x7A, 0x37, 0x37, 0x47, 0x02, 0x1B, + 0x54, 0x7E, 0xB3, 0x37, 0x51, 0xB4, 0x01, 0x02, 0x80, 0x03, 0x02, 0x1B, + 0x54, 0x7E, 0xB3, 0x04, 0x4F, 0x60, 0x42, 0x7E, 0x37, 0x37, 0x67, 0xBE, + 0x37, 0x37, 0x5D, 0x08, 0x18, 0x7E, 0x37, 0x37, 0x4B, 0x9E, 0x37, 0x37, + 0x5D, 0x7A, 0x37, 0x37, 0x63, 0x7E, 0x37, 0x37, 0x65, 0xBE, 0x37, 0x37, + 0x63, 0x48, 0x39, 0x80, 0x20, 0x7E, 0x37, 0x37, 0x69, 0xBE, 0x37, 0x37, + 0x5D, 0x58, 0x16, 0x7E, 0x37, 0x37, 0x5D, 0x9E, 0x37, 0x37, 0x4B, 0x7A, + 0x37, 0x37, 0x63, 0x7E, 0x37, 0x37, 0x65, 0xBE, 0x37, 0x37, 0x63, 0x48, + 0x17, 0x7E, 0x37, 0x37, 0x5B, 0x7E, 0x27, 0x37, 0x5D, 0x7E, 0x17, 0x37, + 0x49, 0x7E, 0x07, 0x37, 0x4B, 0x12, 0xF1, 0x4D, 0xBD, 0x37, 0x40, 0x48, + 0x74, 0x03, 0x7A, 0xB3, 0x37, 0x51, 0x7E, 0x37, 0x37, 0x49, 0x7E, 0x27, + 0x37, 0x5B, 0x12, 0xF3, 0xFB, 0x7A, 0x37, 0x37, 0x53, 0x7E, 0x37, 0x37, + 0x4B, 0x7E, 0x27, 0x37, 0x5D, 0x12, 0xF3, 0xFB, 0x7A, 0x37, 0x37, 0x57, + 0x7E, 0x37, 0x37, 0x49, 0x7A, 0x37, 0x37, 0x45, 0x7E, 0x37, 0x37, 0x4B, + 0x7A, 0x37, 0x37, 0x47, 0x7A, 0xB3, 0x37, 0x52, 0x7E, 0x37, 0x37, 0x5B, + 0x7A, 0x37, 0x37, 0x55, 0x7E, 0x37, 0x37, 0x5D, 0x7A, 0x37, 0x37, 0x59, + 0x7E, 0xB3, 0x37, 0x51, 0xBE, 0xB0, 0x03, 0x68, 0x52, 0x7E, 0x47, 0x37, + 0x45, 0x74, 0x02, 0xAC, 0xBD, 0x59, 0x45, 0x07, 0x4F, 0x7E, 0x47, 0x37, + 0x47, 0x74, 0x02, 0xAC, 0xBD, 0x59, 0x45, 0x07, 0x63, 0x7C, 0xBD, 0x7E, + 0x37, 0x37, 0x45, 0x7E, 0x27, 0x37, 0x47, 0x12, 0xDF, 0x28, 0x7C, 0xBD, + 0x7E, 0x37, 0x37, 0x45, 0x7E, 0x27, 0x37, 0x47, 0x12, 0xEC, 0xCC, 0x74, + 0x02, 0x7A, 0xB3, 0x37, 0x51, 0x6D, 0x33, 0x7A, 0x37, 0x37, 0x53, 0x7A, + 0x37, 0x37, 0x57, 0x7E, 0x37, 0x37, 0x45, 0x7A, 0x37, 0x37, 0x5B, 0x7E, + 0x37, 0x37, 0x47, 0x7A, 0x37, 0x37, 0x5D, 0x7E, 0x47, 0x37, 0x5B, 0x74, + 0x02, 0xAC, 0xBC, 0x59, 0x45, 0x05, 0xF1, 0x7E, 0x47, 0x37, 0x5D, 0x02, + 0x1C, 0x60, 0x7E, 0xB3, 0x37, 0x52, 0x70, 0x03, 0x02, 0x1C, 0x68, 0x14, + 0x7A, 0xB3, 0x37, 0x52, 0x74, 0x02, 0xAC, 0xBC, 0x49, 0x35, 0x05, 0xF1, + 0x1A, 0x26, 0x1A, 0x24, 0x7E, 0x33, 0x37, 0x52, 0x0A, 0xD3, 0x6D, 0xCC, + 0x7E, 0x08, 0x00, 0x04, 0x9F, 0x06, 0x12, 0x8C, 0xBA, 0x7F, 0x71, 0x7E, + 0x37, 0x37, 0x55, 0x1A, 0x26, 0x1A, 0x24, 0x7F, 0x06, 0x12, 0x8C, 0xBA, + 0x2F, 0x17, 0x74, 0x02, 0x1E, 0x34, 0x0E, 0x24, 0x50, 0x03, 0x4E, 0x60, + 0x80, 0x14, 0x78, 0xF4, 0x7A, 0x37, 0x37, 0x55, 0x74, 0x02, 0xAC, 0xBC, + 0x49, 0x35, 0x06, 0x41, 0x1A, 0x26, 0x1A, 0x24, 0x7E, 0x33, 0x37, 0x52, + 0x0A, 0xD3, 0x6D, 0xCC, 0x7E, 0x08, 0x00, 0x04, 0x9F, 0x06, 0x12, 0x8C, + 0xBA, 0x7F, 0x71, 0x7E, 0x37, 0x37, 0x59, 0x1A, 0x26, 0x1A, 0x24, 0x7F, + 0x06, 0x12, 0x8C, 0xBA, 0x2F, 0x17, 0x74, 0x02, 0x1E, 0x34, 0x0E, 0x24, + 0x50, 0x03, 0x4E, 0x60, 0x80, 0x14, 0x78, 0xF4, 0x7A, 0x37, 0x37, 0x59, + 0x7E, 0x47, 0x37, 0x55, 0x74, 0x02, 0xAC, 0xBC, 0x59, 0x45, 0x05, 0xF1, + 0x7E, 0x47, 0x37, 0x59, 0x74, 0x02, 0xAC, 0xBC, 0x59, 0x45, 0x06, 0x41, + 0x74, 0x02, 0xAC, 0xBC, 0x49, 0x45, 0x05, 0xF1, 0x74, 0x02, 0xAC, 0xBD, + 0x59, 0x45, 0x06, 0x91, 0x7A, 0x47, 0x37, 0x4D, 0x74, 0x02, 0xAC, 0xBC, + 0x49, 0x45, 0x06, 0x41, 0x74, 0x02, 0xAC, 0xBD, 0x59, 0x45, 0x06, 0xA5, + 0x7A, 0x47, 0x37, 0x4F, 0x7E, 0xB3, 0x37, 0x51, 0xB4, 0x02, 0x30, 0x7E, + 0x37, 0x37, 0x6B, 0x3E, 0x34, 0xBE, 0x37, 0x37, 0x5F, 0x38, 0x07, 0x7E, + 0xB3, 0x04, 0x6D, 0x20, 0xE0, 0x1D, 0x7E, 0x37, 0x37, 0x5B, 0x7E, 0x27, + 0x37, 0x5D, 0x7E, 0x17, 0x37, 0x4D, 0x7E, 0x07, 0x37, 0x4F, 0x12, 0xF1, + 0x4D, 0xBD, 0x37, 0x40, 0x06, 0x74, 0x03, 0x7A, 0xB3, 0x37, 0x51, 0x7E, + 0xB3, 0x37, 0x51, 0xB4, 0x03, 0x36, 0x7E, 0x37, 0x37, 0x45, 0x7E, 0x27, + 0x37, 0x4D, 0x7E, 0x17, 0x37, 0x5B, 0x7E, 0x07, 0x37, 0x53, 0x12, 0xD5, + 0x6E, 0x74, 0x02, 0xAC, 0xBD, 0x59, 0x35, 0x06, 0x91, 0x7E, 0x37, 0x37, + 0x47, 0x7E, 0x27, 0x37, 0x4F, 0x7E, 0x17, 0x37, 0x5D, 0x7E, 0x07, 0x37, + 0x57, 0x12, 0xD5, 0x6E, 0x74, 0x02, 0xAC, 0xBD, 0x59, 0x35, 0x06, 0xA5, + 0x7E, 0x37, 0x37, 0x45, 0x7E, 0x27, 0x37, 0x5B, 0x12, 0xF3, 0xFB, 0x7D, + 0x53, 0x1A, 0x46, 0x1A, 0x48, 0x7E, 0x37, 0x37, 0x53, 0x1A, 0x26, 0x1A, + 0x24, 0x7E, 0x14, 0x00, 0x03, 0x12, 0x8C, 0xCB, 0x2F, 0x12, 0x74, 0x02, + 0x1E, 0x34, 0x0E, 0x24, 0x50, 0x03, 0x4E, 0x60, 0x80, 0x14, 0x78, 0xF4, + 0x7A, 0x37, 0x37, 0x53, 0x7E, 0x37, 0x37, 0x47, 0x7E, 0x27, 0x37, 0x5D, + 0x12, 0xF3, 0xFB, 0x7D, 0x53, 0x1A, 0x46, 0x1A, 0x48, 0x7E, 0x37, 0x37, + 0x57, 0x1A, 0x26, 0x1A, 0x24, 0x7E, 0x14, 0x00, 0x03, 0x12, 0x8C, 0xCB, + 0x2F, 0x12, 0x74, 0x02, 0x1E, 0x34, 0x0E, 0x24, 0x50, 0x03, 0x4E, 0x60, + 0x80, 0x14, 0x78, 0xF4, 0x7A, 0x37, 0x37, 0x57, 0x7E, 0xB3, 0x37, 0x51, + 0xB4, 0x03, 0x32, 0x7E, 0x37, 0x37, 0x4D, 0x7E, 0x27, 0x37, 0x5B, 0x12, + 0xF3, 0xFB, 0xBE, 0x34, 0x00, 0x10, 0x08, 0x08, 0x7E, 0x37, 0x37, 0x4D, + 0x7A, 0x37, 0x37, 0x5B, 0x7E, 0x37, 0x37, 0x4F, 0x7E, 0x27, 0x37, 0x5D, + 0x12, 0xF3, 0xFB, 0xBE, 0x34, 0x00, 0x10, 0x08, 0x08, 0x7E, 0x37, 0x37, + 0x4F, 0x7A, 0x37, 0x37, 0x5D, 0x0A, 0x3D, 0x09, 0xB3, 0x07, 0x81, 0x70, + 0x18, 0x74, 0x02, 0xAC, 0xBD, 0x49, 0x35, 0x06, 0x91, 0x7A, 0x37, 0x08, + 0xDF, 0x74, 0x02, 0xAC, 0xBD, 0x49, 0x35, 0x06, 0xA5, 0x7A, 0x37, 0x08, + 0xE1, 0x7E, 0x37, 0x37, 0x6B, 0x2E, 0x37, 0x37, 0x5F, 0x1E, 0x34, 0x7A, + 0x37, 0x37, 0x5F, 0x7E, 0x37, 0x37, 0x61, 0x7E, 0x24, 0x37, 0x51, 0x74, + 0x10, 0x12, 0xF3, 0x33, 0x0B, 0xD0, 0xBE, 0xD0, 0x0A, 0x50, 0x03, 0x02, + 0x18, 0x84, 0xDA, 0x3B, 0x22, 0xCA, 0x3B, 0x7C, 0xFB, 0x7E, 0x34, 0xC1, + 0x5C, 0x7A, 0x37, 0x37, 0x66, 0x7E, 0x34, 0xC1, 0x20, 0x7A, 0x37, 0x37, + 0x68, 0x7E, 0x34, 0xC1, 0x2A, 0x7A, 0x37, 0x37, 0x58, 0x7E, 0x34, 0xC1, + 0x34, 0x7A, 0x37, 0x37, 0x5A, 0x7E, 0x34, 0xC1, 0x3E, 0x7A, 0x37, 0x37, + 0x5C, 0x7E, 0x34, 0xC1, 0x48, 0x7A, 0x37, 0x37, 0x5E, 0x7E, 0x34, 0xC1, + 0x52, 0x7A, 0x37, 0x37, 0x60, 0x7E, 0x34, 0xC2, 0x24, 0x7A, 0x37, 0x37, + 0x62, 0x7E, 0x34, 0xC2, 0x38, 0x7A, 0x37, 0x37, 0x64, 0x7E, 0x34, 0xC1, + 0x3E, 0x0A, 0x2B, 0x12, 0xF2, 0xA4, 0xE4, 0x7A, 0xB3, 0x37, 0x4A, 0x7E, + 0x37, 0x37, 0x66, 0x7A, 0x37, 0x37, 0x56, 0x6C, 0xEE, 0x02, 0x1E, 0xDA, + 0x7E, 0x34, 0x37, 0x46, 0x7A, 0x37, 0x37, 0x6A, 0x7E, 0x34, 0x37, 0x54, + 0x7A, 0x37, 0x37, 0x6C, 0x7E, 0x37, 0x37, 0x56, 0x7C, 0xBF, 0x7E, 0x50, + 0xFF, 0x7C, 0x4B, 0x9F, 0x00, 0x7E, 0x04, 0x37, 0x45, 0x12, 0xCC, 0xF4, + 0x7D, 0x23, 0x7A, 0x37, 0x37, 0x52, 0x7E, 0x70, 0x02, 0xAC, 0x7E, 0x2E, + 0x37, 0x37, 0x64, 0x1B, 0x38, 0x20, 0x7E, 0x73, 0x37, 0x45, 0x0A, 0x37, + 0x2E, 0x37, 0x37, 0x5C, 0x7E, 0x39, 0xB0, 0x04, 0x7A, 0x39, 0xB0, 0x7E, + 0x73, 0x37, 0x45, 0x0A, 0x37, 0x7D, 0x23, 0x2E, 0x27, 0x37, 0x5C, 0x7E, + 0x29, 0xB0, 0xB4, 0x01, 0x16, 0x2E, 0x37, 0x37, 0x68, 0x7A, 0x39, 0xE0, + 0x7E, 0x53, 0x37, 0x45, 0x0A, 0x3E, 0x2E, 0x37, 0x37, 0x60, 0x7A, 0x39, + 0x50, 0x80, 0x0B, 0x74, 0xFF, 0x0A, 0x3E, 0x2E, 0x37, 0x37, 0x60, 0x7A, + 0x39, 0xB0, 0x7E, 0x37, 0x37, 0x56, 0x0B, 0x35, 0x7A, 0x37, 0x37, 0x56, + 0x0B, 0xE0, 0xBC, 0xFE, 0x28, 0x03, 0x02, 0x1E, 0x54, 0x7E, 0x37, 0x37, + 0x66, 0x7A, 0x37, 0x37, 0x56, 0x6C, 0xDD, 0x80, 0x7D, 0x0A, 0x3D, 0x2E, + 0x37, 0x37, 0x5C, 0x7E, 0x39, 0xA0, 0x4C, 0xAA, 0x78, 0x16, 0x7E, 0x73, + 0x37, 0x4A, 0x7C, 0xB7, 0x04, 0x7A, 0xB3, 0x37, 0x4A, 0x0A, 0x37, 0x2E, + 0x37, 0x37, 0x58, 0x7A, 0x39, 0xD0, 0x80, 0x4B, 0xBE, 0xA0, 0x01, 0x78, + 0x46, 0x0A, 0x3D, 0x2E, 0x37, 0x37, 0x68, 0x7E, 0x39, 0xE0, 0x7E, 0x34, + 0x37, 0x46, 0x7A, 0x37, 0x37, 0x6A, 0x7E, 0x34, 0x37, 0x54, 0x7A, 0x37, + 0x37, 0x6C, 0x7E, 0x37, 0x37, 0x56, 0x7C, 0xBF, 0x7C, 0x5E, 0x7E, 0x40, + 0x01, 0x7E, 0x17, 0x37, 0x64, 0x7E, 0x04, 0x37, 0x45, 0x12, 0xCC, 0xF4, + 0x7A, 0x37, 0x37, 0x52, 0x7E, 0x50, 0x02, 0xAC, 0x5E, 0x2E, 0x27, 0x37, + 0x64, 0x0B, 0x28, 0x30, 0x9E, 0x37, 0x37, 0x52, 0x1B, 0x28, 0x30, 0x7E, + 0x70, 0x02, 0xAC, 0x7F, 0x2E, 0x37, 0x37, 0x56, 0x7A, 0x37, 0x37, 0x56, + 0x0B, 0xD0, 0xBC, 0xFD, 0x28, 0x03, 0x02, 0x1E, 0xED, 0xE4, 0x7A, 0xB3, + 0x37, 0x47, 0x7E, 0xB3, 0x37, 0x47, 0x04, 0x7A, 0xB3, 0x37, 0x47, 0x6C, + 0xCC, 0x7E, 0x73, 0x37, 0x4A, 0x7A, 0x73, 0x37, 0x4B, 0xE4, 0x7A, 0xB3, + 0x37, 0x4A, 0x02, 0x20, 0x6F, 0x0A, 0x3C, 0x2E, 0x37, 0x37, 0x58, 0x7E, + 0x39, 0xD0, 0x0B, 0xC0, 0x7C, 0x7D, 0xAC, 0x7F, 0x3E, 0x34, 0x2E, 0x37, + 0x37, 0x66, 0x7A, 0x37, 0x37, 0x56, 0x7E, 0x24, 0x37, 0x46, 0x7A, 0x27, + 0x37, 0x6A, 0x7E, 0x24, 0x37, 0x54, 0x7A, 0x27, 0x37, 0x6C, 0x7C, 0xBF, + 0x7E, 0x50, 0xFF, 0x7E, 0x40, 0x01, 0x7E, 0x17, 0x37, 0x64, 0x7E, 0x04, + 0x37, 0x45, 0x12, 0xCC, 0xF4, 0x7A, 0x37, 0x37, 0x52, 0x7E, 0x43, 0x37, + 0x45, 0x0A, 0x34, 0x2E, 0x37, 0x37, 0x60, 0x7E, 0x39, 0x50, 0x7A, 0x53, + 0x37, 0x4C, 0x7E, 0x47, 0x37, 0x54, 0xBE, 0x47, 0x37, 0x52, 0x08, 0x17, + 0x9E, 0x47, 0x37, 0x52, 0x7E, 0x50, 0x02, 0xAC, 0x45, 0x2E, 0x27, 0x37, + 0x64, 0x0B, 0x28, 0x30, 0x9D, 0x34, 0x1B, 0x28, 0x30, 0x80, 0x22, 0x7E, + 0xB3, 0x37, 0x4C, 0xBE, 0xB0, 0xFF, 0x68, 0x19, 0x7E, 0x73, 0x37, 0x46, + 0x7A, 0x73, 0x37, 0x45, 0x7E, 0x73, 0x37, 0x46, 0x0A, 0x37, 0x2E, 0x37, + 0x37, 0x60, 0x7E, 0x39, 0x70, 0x7A, 0x73, 0x37, 0x4C, 0x7E, 0x53, 0x37, + 0x45, 0x0A, 0x3D, 0x2E, 0x37, 0x37, 0x68, 0x7A, 0x39, 0x50, 0x7E, 0x73, + 0x37, 0x45, 0x0A, 0x37, 0x2E, 0x37, 0x37, 0x60, 0x7A, 0x39, 0xD0, 0x7E, + 0xA3, 0x37, 0x4C, 0xBE, 0xA0, 0xFF, 0x68, 0x27, 0x7E, 0x37, 0x37, 0x54, + 0xBE, 0x37, 0x37, 0x52, 0x08, 0x09, 0x7C, 0xBC, 0x14, 0x7C, 0xCB, 0x0A, + 0x3B, 0x80, 0x0D, 0x7E, 0x73, 0x37, 0x4A, 0x7C, 0xB7, 0x04, 0x7A, 0xB3, + 0x37, 0x4A, 0x0A, 0x37, 0x2E, 0x37, 0x37, 0x58, 0x7A, 0x39, 0xA0, 0x7E, + 0x73, 0x37, 0x4B, 0xBC, 0x7C, 0x28, 0x03, 0x02, 0x1F, 0x91, 0x7E, 0x73, + 0x37, 0x47, 0xBE, 0x70, 0x02, 0x50, 0x03, 0x02, 0x1F, 0x76, 0x6C, 0x77, + 0x02, 0x22, 0xF7, 0x0A, 0x27, 0x2E, 0x27, 0x37, 0x58, 0x7E, 0x29, 0x50, + 0x7A, 0x53, 0x37, 0x4D, 0xAC, 0x5F, 0x3E, 0x24, 0x2E, 0x27, 0x37, 0x66, + 0x7A, 0x27, 0x37, 0x56, 0x6C, 0xEE, 0x80, 0x40, 0x7E, 0x50, 0x02, 0xAC, + 0x5E, 0x7D, 0x12, 0x2E, 0x17, 0x37, 0x64, 0x0B, 0x18, 0x00, 0x7E, 0x17, + 0x37, 0x56, 0x0B, 0x18, 0x10, 0x9D, 0x10, 0x2E, 0x27, 0x37, 0x62, 0x1B, + 0x28, 0x10, 0x7E, 0x27, 0x37, 0x56, 0x0B, 0x25, 0x7A, 0x27, 0x37, 0x56, + 0x7E, 0x63, 0x37, 0x4D, 0x0A, 0x2E, 0x2E, 0x27, 0x37, 0x5E, 0x7A, 0x29, + 0x60, 0x0A, 0x2E, 0x2E, 0x27, 0x37, 0x5A, 0x7A, 0x29, 0xE0, 0x0B, 0xE0, + 0xBC, 0xFE, 0x38, 0xBC, 0x6C, 0x66, 0x6C, 0x55, 0x6C, 0x44, 0xBC, 0x65, + 0x68, 0x03, 0x02, 0x21, 0x97, 0x7A, 0x63, 0x37, 0x49, 0x7C, 0xA5, 0x0B, + 0x50, 0x0A, 0x1A, 0x2E, 0x17, 0x37, 0x5A, 0x7E, 0x19, 0x20, 0x7E, 0x30, + 0x02, 0xAC, 0x23, 0x2E, 0x17, 0x37, 0x62, 0x0B, 0x18, 0x10, 0x7A, 0x17, + 0x37, 0x4E, 0x7C, 0xC5, 0x80, 0x4D, 0x0A, 0x4C, 0x2E, 0x47, 0x37, 0x5A, + 0x7E, 0x49, 0xE0, 0x74, 0x02, 0xAC, 0xBE, 0x2E, 0x57, 0x37, 0x62, 0x0B, + 0x58, 0x50, 0x7A, 0x57, 0x37, 0x50, 0x7E, 0x57, 0x37, 0x4E, 0xBE, 0x57, + 0x37, 0x50, 0x48, 0x29, 0xBE, 0x57, 0x37, 0x50, 0x08, 0x0A, 0x7C, 0x56, + 0x7E, 0x57, 0x37, 0x50, 0x7A, 0x57, 0x37, 0x4E, 0x0A, 0x55, 0x2E, 0x57, + 0x37, 0x5A, 0x7E, 0x59, 0x30, 0x7A, 0x49, 0x30, 0x7C, 0xA5, 0x0B, 0x50, + 0x0A, 0x1A, 0x2E, 0x17, 0x37, 0x5A, 0x7A, 0x19, 0xE0, 0x0B, 0xC0, 0xBC, + 0xFC, 0x38, 0xAF, 0x7C, 0xC6, 0x80, 0x20, 0x0A, 0x1C, 0x2E, 0x17, 0x37, + 0x5A, 0x7E, 0x19, 0xA0, 0x0A, 0x1A, 0x2E, 0x17, 0x37, 0x60, 0x7E, 0x19, + 0xB0, 0xB4, 0xFF, 0x09, 0x7A, 0xA3, 0x37, 0x48, 0x7E, 0x40, 0x01, 0x80, + 0x06, 0x0B, 0xC0, 0xBC, 0x5C, 0x38, 0xDC, 0xA5, 0xBC, 0x00, 0x02, 0x80, + 0x03, 0x02, 0x22, 0x77, 0x0A, 0x16, 0x2E, 0x17, 0x37, 0x5A, 0x7E, 0x19, + 0x30, 0x7A, 0x33, 0x37, 0x45, 0x0B, 0x60, 0x7E, 0x23, 0x37, 0x45, 0x0A, + 0x02, 0x2E, 0x07, 0x37, 0x60, 0x7E, 0x09, 0xD0, 0x7C, 0x1D, 0xAC, 0x1F, + 0x3E, 0x04, 0x2E, 0x07, 0x37, 0x66, 0x7A, 0x07, 0x37, 0x56, 0x7E, 0x30, + 0x02, 0xAC, 0x23, 0x7D, 0x01, 0x2E, 0x07, 0x37, 0x64, 0x0B, 0x08, 0x00, + 0x2E, 0x17, 0x37, 0x56, 0x0B, 0x18, 0x10, 0x9D, 0x10, 0x9E, 0x17, 0x37, + 0x4E, 0x7A, 0x17, 0x37, 0x50, 0x7C, 0xC5, 0x02, 0x22, 0x70, 0x0A, 0x1C, + 0x2E, 0x17, 0x37, 0x5A, 0x7E, 0x19, 0xE0, 0x74, 0x02, 0xAC, 0xBE, 0x7D, + 0x45, 0x2E, 0x47, 0x37, 0x64, 0x0B, 0x48, 0x10, 0x7D, 0x05, 0x2E, 0x07, + 0x37, 0x56, 0x0B, 0x08, 0x40, 0x9D, 0x41, 0x9E, 0x47, 0x37, 0x50, 0x2E, + 0x57, 0x37, 0x62, 0x0B, 0x58, 0x50, 0xBD, 0x54, 0x08, 0x50, 0x0A, 0x5E, + 0x2E, 0x57, 0x37, 0x5E, 0x7A, 0x59, 0xD0, 0x7E, 0x57, 0x37, 0x4E, 0xBD, + 0x54, 0x78, 0x34, 0x0A, 0x5E, 0x2E, 0x57, 0x37, 0x60, 0x7E, 0x59, 0xB0, + 0xB4, 0xFF, 0x09, 0x7A, 0xE3, 0x37, 0x48, 0x7E, 0x40, 0x01, 0x80, 0x33, + 0x0A, 0x55, 0x2E, 0x57, 0x37, 0x5A, 0x7E, 0x59, 0x30, 0x0A, 0x5C, 0x2E, + 0x57, 0x37, 0x5A, 0x7A, 0x59, 0x30, 0x7C, 0xA5, 0x0B, 0x50, 0x0A, 0x5A, + 0x2E, 0x57, 0x37, 0x5A, 0x7A, 0x59, 0xE0, 0x74, 0x02, 0xAC, 0xBE, 0x2E, + 0x57, 0x37, 0x62, 0x1B, 0x58, 0x40, 0x0B, 0xC0, 0xBC, 0xFC, 0x28, 0x03, + 0x02, 0x21, 0xEE, 0x4C, 0x44, 0x78, 0x03, 0x02, 0x20, 0xF2, 0x6C, 0xCC, + 0x80, 0x31, 0x0A, 0x1C, 0x2E, 0x17, 0x37, 0x5A, 0x7E, 0x19, 0x30, 0x7A, + 0x33, 0x37, 0x45, 0x7E, 0x03, 0x37, 0x45, 0x7E, 0x10, 0x02, 0xAC, 0x01, + 0x7D, 0x10, 0x2E, 0x17, 0x37, 0x62, 0x0B, 0x18, 0x50, 0x2E, 0x07, 0x37, + 0x64, 0x0B, 0x08, 0x10, 0x2D, 0x15, 0x9E, 0x17, 0x37, 0x4E, 0x1B, 0x08, + 0x10, 0x0B, 0xC0, 0x7E, 0x33, 0x37, 0x49, 0xBC, 0x3C, 0x38, 0xC7, 0x7E, + 0x33, 0x37, 0x48, 0x0A, 0x13, 0x7D, 0x01, 0x2E, 0x07, 0x37, 0x5E, 0x7E, + 0x09, 0xD0, 0x2E, 0x17, 0x37, 0x60, 0x7A, 0x19, 0xD0, 0x7E, 0x33, 0x37, + 0x48, 0x7A, 0x33, 0x37, 0x45, 0x0A, 0x0D, 0x2E, 0x07, 0x37, 0x68, 0x7E, + 0x09, 0x30, 0x7A, 0x33, 0x37, 0x48, 0x7E, 0x33, 0x37, 0x45, 0x7A, 0x09, + 0x30, 0x7E, 0x33, 0x37, 0x4D, 0xBC, 0x3D, 0x78, 0xC6, 0x0B, 0x70, 0x7E, + 0x33, 0x37, 0x4A, 0xBC, 0x37, 0x28, 0x03, 0x02, 0x20, 0x8B, 0xDA, 0x3B, + 0x22, 0xCA, 0x3B, 0x7F, 0x30, 0xE4, 0x7E, 0xA0, 0xFF, 0x80, 0x0B, 0x7E, + 0xB3, 0x37, 0x45, 0x0A, 0x4B, 0x19, 0xA4, 0x37, 0x4C, 0x04, 0x7A, 0xB3, + 0x37, 0x45, 0x7E, 0xB3, 0x03, 0xB6, 0xBE, 0xB3, 0x37, 0x45, 0x38, 0xE7, + 0xE4, 0x7A, 0xB3, 0x37, 0x45, 0x7E, 0x73, 0x37, 0x45, 0x0A, 0x47, 0x7F, + 0x13, 0x2D, 0x34, 0x7E, 0x1B, 0x70, 0x7A, 0x73, 0x37, 0x46, 0x7E, 0x73, + 0x03, 0xB6, 0xBE, 0x73, 0x37, 0x46, 0x38, 0x03, 0x02, 0x24, 0xE3, 0x7E, + 0xB3, 0x37, 0x45, 0x7E, 0x70, 0x02, 0xAC, 0xB7, 0x49, 0x55, 0x0A, 0x88, + 0x7A, 0x57, 0x37, 0x5A, 0x7E, 0x63, 0x37, 0x46, 0x74, 0x10, 0xAC, 0xB6, + 0x49, 0x55, 0x07, 0xA1, 0x7A, 0x57, 0x37, 0x5C, 0x09, 0xB4, 0x07, 0x27, + 0xBE, 0xB0, 0x01, 0x68, 0x12, 0xBE, 0xB0, 0x02, 0x68, 0x0D, 0xBE, 0xB0, + 0x03, 0x68, 0x08, 0xB4, 0x04, 0x02, 0x80, 0x03, 0x02, 0x24, 0xEA, 0x7E, + 0x73, 0x37, 0x45, 0x0A, 0x56, 0x19, 0x75, 0x37, 0x4C, 0x7E, 0xB3, 0x05, + 0x31, 0x70, 0x03, 0x02, 0x24, 0x5B, 0x09, 0x74, 0x0A, 0x56, 0x0A, 0x37, + 0x0B, 0x34, 0x7A, 0x73, 0x37, 0x66, 0x7E, 0xB3, 0x37, 0x45, 0x7E, 0x34, + 0x37, 0x5E, 0x7E, 0x24, 0x37, 0x62, 0x12, 0xED, 0x64, 0x7E, 0x37, 0x37, + 0x5E, 0x7E, 0xB3, 0x37, 0x45, 0x7E, 0x50, 0x02, 0xAC, 0xB5, 0x49, 0x25, + 0x0A, 0x60, 0x12, 0xF2, 0xB9, 0x7A, 0x37, 0x37, 0x60, 0x7E, 0x37, 0x37, + 0x62, 0x7E, 0xB3, 0x37, 0x45, 0x7E, 0x50, 0x02, 0xAC, 0xB5, 0x49, 0x25, + 0x0A, 0x74, 0x12, 0xF2, 0xB9, 0x7A, 0x37, 0x37, 0x64, 0x7E, 0x73, 0x05, + 0x31, 0x0A, 0x37, 0xBE, 0x37, 0x37, 0x60, 0x08, 0x1B, 0x7E, 0x37, 0x37, + 0x64, 0xBE, 0x34, 0x00, 0x10, 0x58, 0x11, 0x7E, 0x73, 0x37, 0x66, 0xBE, + 0x70, 0x78, 0x28, 0x3E, 0x74, 0x78, 0x7A, 0xB3, 0x37, 0x66, 0x80, 0x36, + 0x7E, 0x37, 0x37, 0x64, 0xBE, 0x34, 0x00, 0x10, 0x18, 0x0E, 0x7E, 0x73, + 0x37, 0x66, 0xBE, 0x70, 0x78, 0x40, 0x05, 0xBE, 0x70, 0x7C, 0x40, 0x1E, + 0xE4, 0x7A, 0xB3, 0x37, 0x66, 0x7E, 0x47, 0x37, 0x5E, 0x7E, 0xB3, 0x37, + 0x45, 0x7E, 0x70, 0x02, 0xAC, 0xB7, 0x59, 0x45, 0x0A, 0x60, 0x7E, 0x37, + 0x37, 0x62, 0x59, 0x35, 0x0A, 0x74, 0x7E, 0x73, 0x37, 0x66, 0x7E, 0x63, + 0x37, 0x45, 0x0A, 0x26, 0x19, 0x72, 0x0A, 0x56, 0xBE, 0x70, 0x78, 0x50, + 0x06, 0x74, 0x01, 0x7A, 0xB3, 0x0A, 0x9F, 0x7E, 0xD7, 0x37, 0x5A, 0x7D, + 0x3D, 0x7D, 0xFD, 0x1A, 0x36, 0x1A, 0xE6, 0x7E, 0x14, 0x00, 0x07, 0x7F, + 0x17, 0x12, 0x8C, 0xCB, 0x7E, 0x17, 0x37, 0x5C, 0x1A, 0x02, 0x1A, 0x00, + 0x2F, 0x10, 0x74, 0x03, 0x1E, 0x34, 0x1E, 0x24, 0x50, 0x03, 0x4E, 0x60, + 0x80, 0x14, 0x78, 0xF4, 0x7D, 0x43, 0x7E, 0x63, 0x37, 0x45, 0x74, 0x02, + 0xAC, 0xB6, 0x59, 0x45, 0x0A, 0x88, 0x7E, 0x73, 0x05, 0x32, 0x4C, 0x77, + 0x78, 0x03, 0x02, 0x25, 0x1E, 0x0A, 0x46, 0x09, 0x64, 0x0A, 0x56, 0xBE, + 0x60, 0x78, 0x40, 0x72, 0x7D, 0x5D, 0x9E, 0x57, 0x37, 0x5C, 0x7A, 0x57, + 0x37, 0x5C, 0x0A, 0x17, 0x6D, 0x00, 0x7F, 0x17, 0x12, 0x8C, 0xBA, 0x7C, + 0x76, 0x7C, 0x65, 0x7A, 0x37, 0x37, 0x5A, 0x6D, 0x55, 0x9E, 0x57, 0x37, + 0x5A, 0xBE, 0x57, 0x37, 0x5C, 0x18, 0x0A, 0x7E, 0x57, 0x37, 0x5A, 0xBE, + 0x57, 0x37, 0x5C, 0x58, 0x41, 0x74, 0x01, 0x19, 0xB4, 0x0A, 0xAB, 0xE4, + 0x19, 0xB4, 0x0A, 0xA1, 0x80, 0x34, 0xE4, 0x7E, 0xA3, 0x37, 0x45, 0x0A, + 0x3A, 0x19, 0xB3, 0x0A, 0x56, 0x7E, 0x44, 0x7F, 0xFF, 0x7E, 0xB3, 0x37, + 0x45, 0x7E, 0x70, 0x02, 0xAC, 0xB7, 0x59, 0x45, 0x0A, 0x60, 0x7E, 0xB3, + 0x37, 0x45, 0xAC, 0xB7, 0x59, 0x45, 0x0A, 0x74, 0x7E, 0x47, 0x37, 0x5C, + 0x7E, 0xB3, 0x37, 0x45, 0xAC, 0xB7, 0x59, 0x45, 0x0A, 0x88, 0x7E, 0xB3, + 0x37, 0x45, 0x04, 0x7A, 0xB3, 0x37, 0x45, 0xB4, 0x0A, 0x02, 0x80, 0x03, + 0x02, 0x23, 0x2D, 0x7E, 0xB3, 0x05, 0x2A, 0x70, 0x03, 0x02, 0x27, 0x97, + 0xE4, 0x02, 0x27, 0x86, 0xE4, 0x7A, 0xB3, 0x37, 0x56, 0x7E, 0xB3, 0x37, + 0x45, 0x0A, 0x3B, 0x09, 0xF3, 0x37, 0x4C, 0x7E, 0x70, 0x10, 0xAC, 0xB7, + 0x09, 0x75, 0x07, 0xA6, 0x7A, 0x73, 0x37, 0x47, 0x09, 0x75, 0x07, 0xA7, + 0x7A, 0x73, 0x37, 0x48, 0x7E, 0xB3, 0x37, 0x45, 0x7E, 0x70, 0x06, 0xAC, + 0xB7, 0x49, 0x35, 0x03, 0x52, 0x7A, 0x37, 0x37, 0x5E, 0x7E, 0xB3, 0x37, + 0x45, 0x7E, 0x70, 0x06, 0xAC, 0xB7, 0x49, 0x35, 0x03, 0x54, 0x7A, 0x37, + 0x37, 0x62, 0x6C, 0xEE, 0x02, 0x27, 0x43, 0x7E, 0x73, 0x37, 0x45, 0xBC, + 0x7E, 0x78, 0x03, 0x02, 0x27, 0x41, 0x0A, 0x3E, 0x09, 0xB3, 0xC1, 0x2A, + 0xBE, 0xB0, 0x02, 0x78, 0x03, 0x02, 0x27, 0x41, 0x7E, 0x37, 0x37, 0x5E, + 0x74, 0x06, 0xAC, 0xBE, 0x49, 0x25, 0x03, 0x52, 0x12, 0xF2, 0xB9, 0x7E, + 0x53, 0x05, 0x2A, 0x0A, 0x25, 0xBD, 0x32, 0x08, 0x03, 0x02, 0x27, 0x41, + 0x7E, 0x37, 0x37, 0x62, 0x74, 0x06, 0xAC, 0xBE, 0x49, 0x25, 0x03, 0x54, + 0x12, 0xF2, 0xB9, 0xBE, 0x34, 0x00, 0x20, 0x08, 0x03, 0x02, 0x27, 0x41, + 0x74, 0x10, 0xAC, 0xBE, 0x09, 0x35, 0x07, 0xA6, 0x7A, 0x33, 0x37, 0x49, + 0x09, 0xD5, 0x07, 0xA7, 0x0A, 0x0D, 0x7E, 0x73, 0x37, 0x48, 0x0A, 0x27, + 0x2D, 0x20, 0x7E, 0x63, 0x37, 0x47, 0x0A, 0x06, 0x9D, 0x20, 0x0A, 0x13, + 0x9D, 0x21, 0x0B, 0x25, 0x7A, 0x53, 0x37, 0x4A, 0xBE, 0x63, 0x37, 0x49, + 0x50, 0x04, 0x7A, 0x63, 0x37, 0x49, 0xBC, 0x7D, 0x28, 0x02, 0x7C, 0xD7, + 0x7E, 0x73, 0x37, 0x49, 0x0A, 0x27, 0x0A, 0x3D, 0x9D, 0x32, 0x0B, 0x34, + 0x7A, 0x73, 0x37, 0x4B, 0x7E, 0x73, 0x05, 0x2B, 0x4C, 0x77, 0x68, 0x09, + 0xBE, 0x73, 0x37, 0x4B, 0x38, 0x03, 0x02, 0x27, 0x41, 0x7E, 0x73, 0x05, + 0x2C, 0x7A, 0x73, 0x37, 0x57, 0xBE, 0xF0, 0xFF, 0x68, 0x35, 0x7E, 0xA3, + 0x37, 0x4A, 0xBE, 0xA0, 0x05, 0x50, 0x18, 0x7E, 0xB3, 0x37, 0x57, 0x0B, + 0xB2, 0x7A, 0xB3, 0x37, 0x57, 0xBE, 0xA0, 0x04, 0x50, 0x1D, 0xE4, 0x0A, + 0x3F, 0x19, 0xB3, 0x0A, 0xA1, 0x80, 0x14, 0x7E, 0x73, 0x37, 0x4B, 0xBE, + 0x73, 0x37, 0x4A, 0x50, 0x0A, 0x7E, 0xB3, 0x37, 0x57, 0x0B, 0xB1, 0x7A, + 0xB3, 0x37, 0x57, 0x0A, 0x3E, 0x09, 0xC3, 0x37, 0x4C, 0xBE, 0xF0, 0xFF, + 0x78, 0x13, 0xBE, 0xC0, 0xFF, 0x68, 0x03, 0x02, 0x27, 0x14, 0xBE, 0xE3, + 0x37, 0x45, 0x38, 0x03, 0x02, 0x27, 0x14, 0x80, 0x7B, 0x0A, 0x3F, 0x09, + 0xB3, 0x07, 0x27, 0xB4, 0x01, 0x36, 0xBE, 0xC0, 0xFF, 0x78, 0x02, 0x80, + 0x0F, 0x0A, 0x3C, 0x09, 0xB3, 0x07, 0x27, 0xB4, 0x01, 0x0E, 0xBE, 0xE3, + 0x37, 0x45, 0x28, 0x08, 0x74, 0x02, 0x0A, 0x3E, 0x19, 0xB3, 0xC1, 0x2A, + 0x0A, 0x3F, 0x09, 0x73, 0x0A, 0xA1, 0xBE, 0x73, 0x37, 0x57, 0x28, 0x50, + 0x7E, 0x73, 0x37, 0x57, 0x0A, 0x2F, 0x19, 0x72, 0x0A, 0xA1, 0x80, 0x44, + 0xBE, 0xC0, 0xFF, 0x68, 0x09, 0x0A, 0x3C, 0x09, 0xB3, 0x07, 0x27, 0xB4, + 0x01, 0x14, 0x74, 0x01, 0x7A, 0xB3, 0x37, 0x56, 0x0A, 0x3F, 0x09, 0x73, + 0x0A, 0xA1, 0xBE, 0x73, 0x37, 0x57, 0x38, 0x24, 0x80, 0x1A, 0x74, 0x08, + 0xAC, 0xBC, 0x49, 0x35, 0x05, 0xA1, 0x1E, 0x34, 0x7A, 0x37, 0x37, 0x58, + 0x7E, 0x73, 0x05, 0x2D, 0x0A, 0x37, 0xBE, 0x37, 0x37, 0x58, 0x38, 0x08, + 0x74, 0x02, 0x0A, 0x3E, 0x19, 0xB3, 0xC1, 0x2A, 0x0A, 0x3E, 0x09, 0xB3, + 0xC1, 0x2A, 0xB4, 0x02, 0x24, 0xBE, 0xF0, 0xFF, 0x68, 0x1F, 0x74, 0x01, + 0x7A, 0xB3, 0x37, 0x56, 0x0A, 0x3F, 0x09, 0x73, 0x0A, 0x56, 0xBE, 0x70, + 0x78, 0x40, 0x0E, 0x0A, 0x3F, 0x2E, 0x34, 0x0A, 0xAB, 0x7E, 0x39, 0xB0, + 0x44, 0x02, 0x7A, 0x39, 0xB0, 0x0B, 0xE0, 0x7E, 0x73, 0x03, 0xB6, 0xBC, + 0x7E, 0x28, 0x03, 0x02, 0x25, 0x87, 0xBE, 0xF0, 0xFF, 0x68, 0x2E, 0x0A, + 0x3F, 0x2E, 0x34, 0x0A, 0xA1, 0x7E, 0x39, 0xB0, 0x04, 0x7A, 0x39, 0xB0, + 0x7E, 0xB3, 0x37, 0x56, 0x60, 0x14, 0x0A, 0x3F, 0x09, 0x73, 0x0A, 0xA1, + 0x0A, 0x27, 0x7E, 0x73, 0x37, 0x57, 0x2E, 0x34, 0x00, 0x10, 0xBD, 0x23, + 0x08, 0x07, 0xE4, 0x0A, 0x3F, 0x19, 0xB3, 0x0A, 0xA1, 0x7E, 0xB3, 0x37, + 0x45, 0x04, 0x7A, 0xB3, 0x37, 0x45, 0x7E, 0x73, 0x03, 0xB6, 0xBE, 0x73, + 0x37, 0x45, 0x28, 0x03, 0x02, 0x25, 0x3C, 0xDA, 0x3B, 0x22, 0xCA, 0x79, + 0xE4, 0x7A, 0xB3, 0x2C, 0x89, 0xE4, 0x7A, 0xB3, 0x2C, 0x8A, 0x7E, 0x73, + 0x2C, 0x90, 0xBE, 0x70, 0xFF, 0x68, 0x14, 0x0A, 0x37, 0x2E, 0x34, 0x2C, + 0xC4, 0x7E, 0x39, 0xB0, 0x54, 0x7F, 0x7A, 0x39, 0xB0, 0x74, 0xFF, 0x7A, + 0xB3, 0x2C, 0x90, 0x7E, 0x73, 0x2D, 0x02, 0xBE, 0x73, 0x2D, 0x83, 0x28, + 0x22, 0x7E, 0x73, 0x2D, 0x83, 0x7A, 0x73, 0x2D, 0x0D, 0x12, 0xCA, 0x4D, + 0x7A, 0xB3, 0x2D, 0x0E, 0x7E, 0xB3, 0x2D, 0x0D, 0x7E, 0x73, 0x2D, 0x0E, + 0x7E, 0x63, 0x2D, 0x13, 0x12, 0x88, 0x8E, 0xE4, 0x02, 0x2C, 0x0B, 0x7E, + 0xF3, 0x2D, 0x0B, 0x7E, 0x73, 0x2D, 0x03, 0x0A, 0x37, 0xBE, 0x37, 0x2D, + 0x14, 0x50, 0x4F, 0x7E, 0x34, 0x37, 0x30, 0x7E, 0x24, 0x37, 0x32, 0x7E, + 0x14, 0x37, 0x2F, 0x12, 0xD8, 0xDB, 0x7C, 0xAB, 0x7E, 0xB3, 0x2D, 0x03, + 0x0A, 0x3B, 0xBE, 0x37, 0x37, 0x30, 0x40, 0x06, 0x7E, 0xB3, 0x2C, 0x8B, + 0x70, 0x0C, 0x7E, 0x37, 0x37, 0x32, 0x7A, 0x37, 0x37, 0x30, 0x7E, 0xA3, + 0x37, 0x2F, 0x7E, 0xB3, 0x2D, 0x04, 0x0A, 0x2B, 0x2E, 0x27, 0x37, 0x30, + 0x7E, 0xB3, 0x2D, 0x03, 0x0A, 0x3B, 0xBE, 0x37, 0x37, 0x30, 0x38, 0x08, + 0x7E, 0x37, 0x2D, 0x14, 0xBD, 0x32, 0x28, 0x02, 0x7C, 0xFA, 0x7E, 0xB3, + 0x2C, 0x8B, 0x60, 0x03, 0x02, 0x28, 0xFE, 0x74, 0x01, 0x7A, 0xB3, 0x2C, + 0x89, 0x74, 0x01, 0x7A, 0xB3, 0x2C, 0x8A, 0xBE, 0xF3, 0x2D, 0x0B, 0x68, + 0x2E, 0x7A, 0xF3, 0x2D, 0x0D, 0x7A, 0xF3, 0x2D, 0x0E, 0x7E, 0xB3, 0x2D, + 0x0D, 0x7E, 0x73, 0x2D, 0x0E, 0x7E, 0x63, 0x2D, 0x13, 0x12, 0x88, 0x8E, + 0x12, 0xF5, 0xBB, 0x7E, 0xB3, 0x2D, 0x7C, 0x04, 0x7A, 0xB3, 0x2D, 0x7C, + 0x74, 0x01, 0x7A, 0xB3, 0x2D, 0x73, 0x74, 0x01, 0x02, 0x2C, 0x0B, 0x12, + 0xD7, 0x2F, 0x12, 0xEB, 0x22, 0x12, 0xF5, 0xB7, 0x70, 0x3C, 0x7E, 0x73, + 0x2D, 0x0B, 0x7A, 0x73, 0x2D, 0x0E, 0x7E, 0xB3, 0x2D, 0x0B, 0x0A, 0x3B, + 0x09, 0xA3, 0x2D, 0x50, 0xBE, 0xA0, 0x06, 0x40, 0x12, 0x12, 0xC6, 0x85, + 0x7A, 0xB3, 0x2D, 0x0E, 0xB4, 0xFF, 0x08, 0x7E, 0x73, 0x2D, 0x0B, 0x7A, + 0x73, 0x2D, 0x0E, 0x7E, 0xB3, 0x2D, 0x0D, 0x7E, 0x73, 0x2D, 0x0E, 0x7E, + 0x63, 0x2D, 0x13, 0x12, 0x88, 0x8E, 0xE4, 0x02, 0x2C, 0x0B, 0x74, 0x01, + 0x7A, 0xB3, 0x2C, 0x8B, 0x7E, 0x73, 0x2D, 0x0B, 0x7A, 0x73, 0x2C, 0x8E, + 0x74, 0xFF, 0x7A, 0xB3, 0x2C, 0x91, 0x74, 0xFF, 0x7E, 0xA3, 0x2D, 0x0B, + 0x0A, 0x3A, 0x19, 0xB3, 0x2C, 0xC4, 0x7E, 0xB3, 0x2C, 0x8B, 0xB4, 0x01, + 0x02, 0x80, 0x03, 0x02, 0x2A, 0xE7, 0x30, 0x32, 0x07, 0xC2, 0x32, 0xE4, + 0x7A, 0xB3, 0x2C, 0x8C, 0x7E, 0xB3, 0x2D, 0x10, 0x60, 0x0E, 0x74, 0x01, + 0x7A, 0xB3, 0x2C, 0x89, 0xE4, 0x7A, 0xB3, 0x2C, 0x8C, 0x02, 0x2A, 0xF3, + 0x7E, 0xB3, 0x2C, 0x8C, 0x60, 0x08, 0x14, 0x7A, 0xB3, 0x2C, 0x8C, 0x02, + 0x2A, 0xF3, 0xA2, 0x15, 0xE4, 0x33, 0x68, 0x03, 0x02, 0x2A, 0xF3, 0x74, + 0xFF, 0x7A, 0xB3, 0x2C, 0x91, 0x7E, 0xB3, 0x2C, 0x8E, 0x7E, 0x70, 0x02, + 0xAC, 0xB7, 0x49, 0x25, 0x2D, 0x16, 0x7E, 0x73, 0x2D, 0x03, 0x0A, 0x37, + 0xBD, 0x23, 0x28, 0x2D, 0x7E, 0x34, 0x37, 0x30, 0x7E, 0x24, 0x37, 0x32, + 0x7E, 0x14, 0x37, 0x2F, 0x12, 0xD8, 0xDB, 0x7A, 0xB3, 0x2C, 0x8E, 0xE4, + 0x7A, 0xB3, 0x2C, 0x8D, 0x7E, 0x73, 0x2D, 0x03, 0x0A, 0x37, 0xBE, 0x37, + 0x37, 0x30, 0x50, 0x09, 0x74, 0x1E, 0x7A, 0xB3, 0x2C, 0x8C, 0x02, 0x2A, + 0xF3, 0x7E, 0xB3, 0x2C, 0x8D, 0x60, 0x17, 0x7E, 0xB3, 0x2C, 0x8F, 0x7E, + 0x70, 0x02, 0xAC, 0xB7, 0x49, 0x25, 0x2D, 0x16, 0x7E, 0x73, 0x2D, 0x03, + 0x0A, 0x37, 0xBD, 0x23, 0x28, 0x52, 0x74, 0xFF, 0x12, 0xC6, 0x85, 0x7A, + 0xB3, 0x2C, 0x8F, 0x7E, 0x73, 0x2C, 0x8F, 0xBE, 0x70, 0xFF, 0x78, 0x03, + 0x02, 0x2A, 0xF3, 0x74, 0x02, 0xAC, 0xB7, 0x49, 0x15, 0x2D, 0x16, 0x7E, + 0x63, 0x2D, 0x03, 0x0A, 0x26, 0xBD, 0x12, 0x28, 0x09, 0x74, 0x1E, 0x7A, + 0xB3, 0x2C, 0x8C, 0x02, 0x2A, 0xF3, 0x0A, 0x37, 0x2E, 0x34, 0x2C, 0xC4, + 0x7E, 0x39, 0xB0, 0x04, 0x7A, 0x39, 0xB0, 0x7E, 0x73, 0x2C, 0x8F, 0x0A, + 0x37, 0x09, 0xB3, 0x2C, 0xC4, 0xBE, 0xB0, 0x10, 0x68, 0x97, 0x74, 0x01, + 0x7A, 0xB3, 0x2C, 0x8D, 0x7E, 0xB3, 0x2C, 0x8D, 0xB4, 0x01, 0x15, 0x7E, + 0x73, 0x2D, 0x0B, 0xBE, 0x73, 0x2C, 0x8E, 0x78, 0x0B, 0x12, 0xD7, 0x2F, + 0x60, 0x06, 0x74, 0x02, 0x7A, 0xB3, 0x2C, 0x8D, 0x7E, 0xB3, 0x2C, 0x8D, + 0xB4, 0x02, 0x10, 0x7E, 0x73, 0x2D, 0x0B, 0xBE, 0x73, 0x2C, 0x8F, 0x78, + 0x06, 0x74, 0x03, 0x7A, 0xB3, 0x2C, 0x8D, 0x7E, 0xB3, 0x2C, 0x8D, 0xB4, + 0x03, 0x77, 0x7E, 0x73, 0x2D, 0x0B, 0xBE, 0x73, 0x2C, 0x8E, 0x78, 0x6D, + 0x12, 0xEB, 0xA8, 0x7E, 0xB3, 0x2C, 0x88, 0x7E, 0x70, 0x02, 0xAC, 0xB7, + 0x49, 0x25, 0x2C, 0x95, 0x9E, 0x27, 0x2C, 0x92, 0xBE, 0x24, 0x00, 0x00, + 0x58, 0x06, 0x6E, 0x24, 0xFF, 0xFF, 0x0B, 0x24, 0x7E, 0x37, 0x2D, 0xE1, + 0x09, 0x73, 0x00, 0x0F, 0x0A, 0x37, 0xBD, 0x32, 0x08, 0x1C, 0x7E, 0x73, + 0x2C, 0x8F, 0x7A, 0x73, 0x2C, 0x90, 0x7E, 0x73, 0x2C, 0x8F, 0x0A, 0x37, + 0x2E, 0x34, 0x2C, 0xC4, 0x7E, 0x39, 0xB0, 0x44, 0x80, 0x7A, 0x39, 0xB0, + 0x80, 0x1B, 0x7E, 0x37, 0x2C, 0xA6, 0x0B, 0x34, 0x7A, 0x37, 0x2C, 0xA6, + 0x7E, 0x73, 0x2C, 0x8F, 0x0A, 0x37, 0x2E, 0x34, 0x2C, 0xC4, 0x7E, 0x39, + 0xB0, 0x14, 0x7A, 0x39, 0xB0, 0xE4, 0x7A, 0xB3, 0x2C, 0x8D, 0x02, 0x29, + 0x89, 0x74, 0x01, 0x7A, 0xB3, 0x2C, 0x89, 0x74, 0x01, 0x7A, 0xB3, 0x2C, + 0x8A, 0x7E, 0x73, 0x2C, 0x8E, 0x7A, 0x73, 0x2D, 0x0D, 0x7E, 0x73, 0x2C, + 0x8F, 0x7A, 0x73, 0x2D, 0x0E, 0x7E, 0xB3, 0x2C, 0x8D, 0xB4, 0x02, 0x1B, + 0x7E, 0x73, 0x2C, 0x8F, 0x0A, 0x27, 0x09, 0x62, 0x2D, 0x50, 0xBE, 0x60, + 0x03, 0x40, 0x0C, 0x7A, 0x73, 0x2D, 0x0D, 0x7E, 0x73, 0x2C, 0x8E, 0x7A, + 0x73, 0x2D, 0x0E, 0x7E, 0xB3, 0x2C, 0x8B, 0xB4, 0x03, 0x02, 0x80, 0x03, + 0x02, 0x2B, 0x83, 0xE4, 0x7A, 0xB3, 0x2C, 0x8D, 0x74, 0xFF, 0x7A, 0xB3, + 0x2C, 0x94, 0x7E, 0xE3, 0x2D, 0x0B, 0xBC, 0xEF, 0x78, 0x28, 0x7A, 0xE3, + 0x2D, 0x0D, 0x7E, 0xA3, 0x2D, 0x0B, 0x0A, 0x3A, 0x09, 0xB3, 0x2D, 0x50, + 0xBE, 0xB0, 0x04, 0x40, 0x06, 0x7E, 0xB3, 0x2D, 0x12, 0x60, 0x06, 0x7A, + 0xA3, 0x2D, 0x0E, 0x80, 0x5E, 0x12, 0xCA, 0x4D, 0x7A, 0xB3, 0x2D, 0x0E, + 0x80, 0x55, 0x7E, 0x73, 0x2D, 0x4F, 0xBE, 0x70, 0x40, 0x28, 0x32, 0x7E, + 0x73, 0x2D, 0x07, 0x4C, 0x77, 0x68, 0x08, 0x0A, 0x37, 0xBE, 0x37, 0x2D, + 0x14, 0x28, 0x22, 0x0A, 0x3F, 0x09, 0x73, 0x2D, 0x50, 0xBE, 0x70, 0x04, + 0x50, 0x0A, 0x7A, 0xE3, 0x2D, 0x0D, 0x7A, 0xF3, 0x2D, 0x0E, 0x80, 0x27, + 0x7A, 0xF3, 0x2D, 0x0D, 0x12, 0xCA, 0x4D, 0x7A, 0xB3, 0x2D, 0x0E, 0x80, + 0x1A, 0x7A, 0xF3, 0x2D, 0x0D, 0x12, 0xCA, 0x4D, 0x7A, 0xB3, 0x2D, 0x0E, + 0x7E, 0xB3, 0x2D, 0x7A, 0x04, 0x7A, 0xB3, 0x2D, 0x7A, 0x74, 0x01, 0x7A, + 0xB3, 0x2D, 0x73, 0x7E, 0xB3, 0x2D, 0x0D, 0x7E, 0x73, 0x2D, 0x0E, 0x7E, + 0x63, 0x2D, 0x13, 0x12, 0x88, 0x8E, 0xE4, 0x7A, 0xB3, 0x2D, 0x12, 0x7E, + 0xA3, 0x2D, 0x0B, 0x0A, 0x3A, 0x09, 0xB3, 0x2C, 0xC4, 0xBE, 0xB0, 0xFF, + 0x68, 0x0D, 0xBE, 0xA3, 0x2C, 0x91, 0x68, 0x07, 0x7A, 0xA3, 0x2C, 0x91, + 0x12, 0xB6, 0xFC, 0x12, 0xE4, 0xE7, 0x7E, 0x73, 0x2D, 0x05, 0x4C, 0x77, + 0x68, 0x17, 0x0A, 0x37, 0xBE, 0x37, 0x2D, 0x14, 0x50, 0x0F, 0x7E, 0xB3, + 0x2D, 0x7B, 0x04, 0x7A, 0xB3, 0x2D, 0x7B, 0x74, 0x01, 0x7A, 0xB3, 0x2D, + 0x73, 0x7E, 0x73, 0x2D, 0x0B, 0x0A, 0x37, 0x09, 0x73, 0x2D, 0x50, 0xBE, + 0x70, 0x04, 0x50, 0x0F, 0x7E, 0xB3, 0x2D, 0x79, 0x04, 0x7A, 0xB3, 0x2D, + 0x79, 0x74, 0x01, 0x7A, 0xB3, 0x2D, 0x73, 0x12, 0xA0, 0xA5, 0x60, 0x0F, + 0x7E, 0xB3, 0x2D, 0x78, 0x04, 0x7A, 0xB3, 0x2D, 0x78, 0x74, 0x01, 0x7A, + 0xB3, 0x2D, 0x73, 0x7E, 0xB3, 0x2D, 0x73, 0xDA, 0x79, 0x22, 0xCA, 0x3B, + 0x7C, 0xFB, 0xE4, 0x7A, 0xB3, 0x37, 0x53, 0xBE, 0xF0, 0x0B, 0x08, 0x03, + 0x02, 0x30, 0x0F, 0x7E, 0x64, 0xC1, 0x50, 0x9F, 0x11, 0x7A, 0x37, 0x37, + 0x49, 0x7A, 0x67, 0x37, 0x4B, 0x7E, 0xB3, 0x03, 0xC9, 0x54, 0x0F, 0x7A, + 0xB3, 0x37, 0x55, 0xB4, 0x0F, 0x04, 0x74, 0x02, 0x80, 0x06, 0x7E, 0xB3, + 0x37, 0x55, 0x24, 0x03, 0x7A, 0xB3, 0x37, 0x55, 0xE4, 0x80, 0x65, 0x09, + 0xB6, 0x00, 0x09, 0x70, 0x56, 0x09, 0x76, 0x00, 0x04, 0x0A, 0x27, 0x09, + 0x76, 0x00, 0x05, 0x0A, 0x37, 0x9D, 0x32, 0x7E, 0x53, 0x37, 0x55, 0xBD, + 0x32, 0x58, 0x12, 0x09, 0x76, 0x00, 0x06, 0x0A, 0x17, 0x09, 0x76, 0x00, + 0x07, 0x0A, 0x37, 0x9D, 0x31, 0xBD, 0x32, 0x48, 0x2E, 0x09, 0x66, 0x00, + 0x08, 0xBE, 0x63, 0x04, 0x31, 0x40, 0x10, 0x7E, 0x73, 0x04, 0x12, 0x1E, + 0x70, 0x0A, 0x17, 0x49, 0x26, 0x00, 0x02, 0xBD, 0x21, 0x58, 0x14, 0x7E, + 0x27, 0x37, 0x49, 0x4D, 0x22, 0x68, 0x08, 0x09, 0x72, 0x00, 0x08, 0xBC, + 0x76, 0x50, 0x04, 0x7A, 0x67, 0x37, 0x49, 0x2E, 0x64, 0x00, 0x10, 0x7E, + 0xB3, 0x37, 0x51, 0x04, 0x7A, 0xB3, 0x37, 0x51, 0xBE, 0xF3, 0x37, 0x51, + 0x18, 0x91, 0x7E, 0x37, 0x37, 0x49, 0x4D, 0x33, 0x78, 0x03, 0x02, 0x30, + 0x0F, 0xE4, 0x7A, 0xB3, 0x37, 0x54, 0x80, 0x61, 0x7E, 0x27, 0x37, 0x4B, + 0x09, 0xB2, 0x00, 0x09, 0x70, 0x4A, 0xBE, 0x37, 0x37, 0x4B, 0x68, 0x44, + 0x09, 0x23, 0x00, 0x05, 0x09, 0x32, 0x00, 0x04, 0xBC, 0x32, 0x38, 0x16, + 0x09, 0x23, 0x00, 0x04, 0x09, 0x32, 0x00, 0x05, 0xBC, 0x32, 0x40, 0x0A, + 0x7E, 0xB3, 0x37, 0x54, 0x44, 0x01, 0x7A, 0xB3, 0x37, 0x54, 0x09, 0x23, + 0x00, 0x07, 0x09, 0x32, 0x00, 0x06, 0xBC, 0x32, 0x38, 0x16, 0x09, 0x23, + 0x00, 0x06, 0x09, 0x32, 0x00, 0x07, 0xBC, 0x32, 0x40, 0x0A, 0x7E, 0xB3, + 0x37, 0x54, 0x44, 0x02, 0x7A, 0xB3, 0x37, 0x54, 0x2E, 0x24, 0x00, 0x10, + 0x7A, 0x27, 0x37, 0x4B, 0x7E, 0xB3, 0x37, 0x51, 0x04, 0x7A, 0xB3, 0x37, + 0x51, 0xBE, 0xF3, 0x37, 0x51, 0x18, 0x95, 0x09, 0x33, 0x00, 0x04, 0x7A, + 0x33, 0x37, 0x4D, 0x09, 0x23, 0x00, 0x05, 0x0A, 0x22, 0x1A, 0x13, 0x9D, + 0x21, 0x0B, 0x24, 0x7A, 0x53, 0x37, 0x4E, 0x09, 0x33, 0x00, 0x06, 0x7A, + 0x33, 0x37, 0x4F, 0x09, 0x23, 0x00, 0x07, 0x0A, 0x22, 0x1A, 0x13, 0x9D, + 0x21, 0x0B, 0x24, 0x7A, 0x53, 0x37, 0x50, 0x7E, 0xB3, 0x37, 0x55, 0x04, + 0x7A, 0xB3, 0x37, 0x55, 0x7D, 0x26, 0x74, 0x04, 0x12, 0xEB, 0xFE, 0x7E, + 0x43, 0x05, 0x1A, 0x0A, 0x14, 0x7E, 0x53, 0x37, 0x4F, 0x1A, 0x05, 0xAD, + 0x10, 0x3E, 0x14, 0x7E, 0x53, 0x37, 0x4D, 0x1A, 0x35, 0x3E, 0x34, 0x2D, + 0x31, 0x2E, 0x37, 0x03, 0x10, 0x7A, 0x37, 0x37, 0x45, 0x74, 0x01, 0x7A, + 0xB3, 0x37, 0x53, 0x7E, 0x53, 0x37, 0x55, 0xBE, 0x53, 0x37, 0x50, 0x28, + 0x03, 0x02, 0x2E, 0xC5, 0x7E, 0xB3, 0x37, 0x54, 0x30, 0xE1, 0x03, 0x02, + 0x2E, 0xC5, 0x7E, 0x37, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x50, 0x7E, 0x53, + 0x37, 0x4E, 0x7E, 0x30, 0x01, 0x12, 0x78, 0xB6, 0x7D, 0x23, 0x7A, 0x37, + 0x37, 0x47, 0x7E, 0x29, 0x70, 0x0B, 0x24, 0x7A, 0x27, 0x37, 0x47, 0x7A, + 0x73, 0x37, 0x53, 0x7E, 0x73, 0x37, 0x53, 0xBE, 0x70, 0x01, 0x18, 0x03, + 0x02, 0x2E, 0xC5, 0x1A, 0x6F, 0x3E, 0x64, 0x3E, 0x64, 0x3E, 0x64, 0x3E, + 0x64, 0x2E, 0x64, 0xC1, 0x50, 0x7E, 0x37, 0x37, 0x49, 0x09, 0x73, 0x00, + 0x08, 0x0A, 0x37, 0x7E, 0xA3, 0x37, 0x53, 0x1A, 0x2A, 0x12, 0x8C, 0x88, + 0x7A, 0x73, 0x37, 0x52, 0x7A, 0xA3, 0x37, 0x51, 0x7E, 0x37, 0x37, 0x47, + 0x7E, 0x39, 0xE0, 0x0B, 0x34, 0x7A, 0x37, 0x37, 0x47, 0x7E, 0x37, 0x37, + 0x49, 0x09, 0x73, 0x00, 0x06, 0x2C, 0xE7, 0x19, 0xE6, 0x00, 0x06, 0x19, + 0xE6, 0x00, 0x07, 0x7E, 0x73, 0x37, 0x52, 0x19, 0x76, 0x00, 0x08, 0xE4, + 0x19, 0xB6, 0x00, 0x09, 0x7E, 0x37, 0x37, 0x47, 0x7E, 0x39, 0xE0, 0x0B, + 0x34, 0x7A, 0x37, 0x37, 0x47, 0x7E, 0x37, 0x37, 0x49, 0x09, 0x73, 0x00, + 0x04, 0x2C, 0xE7, 0x19, 0xE6, 0x00, 0x04, 0x19, 0xE6, 0x00, 0x05, 0x09, + 0x66, 0x00, 0x06, 0x7E, 0x73, 0x05, 0x1A, 0xAC, 0x67, 0x09, 0x56, 0x00, + 0x04, 0x0A, 0x25, 0x2D, 0x32, 0x3E, 0x34, 0x2E, 0x37, 0x03, 0x10, 0x0B, + 0x38, 0x30, 0x59, 0x36, 0x00, 0x02, 0x1B, 0x68, 0x30, 0x7E, 0x37, 0x37, + 0x49, 0x09, 0x73, 0x00, 0x0C, 0x19, 0x76, 0x00, 0x0C, 0x7E, 0x37, 0x37, + 0x49, 0x09, 0x73, 0x00, 0x0D, 0x19, 0x76, 0x00, 0x0D, 0x7E, 0x37, 0x37, + 0x49, 0x09, 0x73, 0x00, 0x0E, 0x19, 0x76, 0x00, 0x0E, 0x7E, 0x37, 0x37, + 0x49, 0x09, 0x73, 0x00, 0x0F, 0x19, 0x76, 0x00, 0x0F, 0x74, 0x01, 0x19, + 0xB6, 0x00, 0x0B, 0x2E, 0x64, 0x00, 0x10, 0x7E, 0xB3, 0x37, 0x51, 0x14, + 0x7A, 0xB3, 0x37, 0x51, 0x68, 0x03, 0x02, 0x2E, 0x10, 0x7E, 0x73, 0x37, + 0x55, 0xBE, 0x73, 0x37, 0x4E, 0x28, 0x03, 0x02, 0x2F, 0xEE, 0x7E, 0xB3, + 0x37, 0x54, 0x30, 0xE0, 0x03, 0x02, 0x2F, 0xEE, 0x7E, 0x37, 0x37, 0x45, + 0x7E, 0xB3, 0x37, 0x4E, 0x7E, 0x53, 0x37, 0x50, 0x7E, 0x40, 0x01, 0x7E, + 0x33, 0x05, 0x1A, 0x12, 0x78, 0xB6, 0x7D, 0x23, 0x7A, 0x37, 0x37, 0x47, + 0x7E, 0x29, 0x70, 0x0B, 0x24, 0x7A, 0x27, 0x37, 0x47, 0x7E, 0x63, 0x37, + 0x53, 0xBC, 0x67, 0x48, 0x03, 0x02, 0x2F, 0xEE, 0x7A, 0x73, 0x37, 0x53, + 0x1A, 0x6F, 0x3E, 0x64, 0x3E, 0x64, 0x3E, 0x64, 0x3E, 0x64, 0x2E, 0x64, + 0xC1, 0x50, 0x7E, 0x37, 0x37, 0x49, 0x09, 0x73, 0x00, 0x08, 0x0A, 0x37, + 0x7E, 0xA3, 0x37, 0x53, 0x1A, 0x2A, 0x12, 0x8C, 0x88, 0x7A, 0x73, 0x37, + 0x52, 0x7A, 0xA3, 0x37, 0x51, 0x7E, 0x37, 0x37, 0x47, 0x7E, 0x39, 0xE0, + 0x0B, 0x34, 0x7A, 0x37, 0x37, 0x47, 0x7E, 0x37, 0x37, 0x49, 0x09, 0x73, + 0x00, 0x04, 0x2C, 0xE7, 0x19, 0xE6, 0x00, 0x04, 0x19, 0xE6, 0x00, 0x05, + 0x7E, 0x73, 0x37, 0x52, 0x19, 0x76, 0x00, 0x08, 0xE4, 0x19, 0xB6, 0x00, + 0x09, 0x7E, 0x37, 0x37, 0x47, 0x7E, 0x39, 0xE0, 0x0B, 0x34, 0x7A, 0x37, + 0x37, 0x47, 0x7E, 0x37, 0x37, 0x49, 0x09, 0x73, 0x00, 0x06, 0x2C, 0xE7, + 0x19, 0xE6, 0x00, 0x06, 0x19, 0xE6, 0x00, 0x07, 0x09, 0x66, 0x00, 0x06, + 0x7E, 0x73, 0x05, 0x1A, 0xAC, 0x67, 0x09, 0x56, 0x00, 0x04, 0x0A, 0x25, + 0x2D, 0x32, 0x3E, 0x34, 0x2E, 0x37, 0x03, 0x10, 0x0B, 0x38, 0x30, 0x59, + 0x36, 0x00, 0x02, 0x1B, 0x68, 0x30, 0x7E, 0x37, 0x37, 0x49, 0x09, 0x73, + 0x00, 0x0C, 0x19, 0x76, 0x00, 0x0C, 0x7E, 0x37, 0x37, 0x49, 0x09, 0x73, + 0x00, 0x0D, 0x19, 0x76, 0x00, 0x0D, 0x7E, 0x37, 0x37, 0x49, 0x09, 0x73, + 0x00, 0x0E, 0x19, 0x76, 0x00, 0x0E, 0x7E, 0x37, 0x37, 0x49, 0x09, 0x73, + 0x00, 0x0F, 0x19, 0x76, 0x00, 0x0F, 0x74, 0x01, 0x19, 0xB6, 0x00, 0x0B, + 0x2E, 0x64, 0x00, 0x10, 0x7E, 0xB3, 0x37, 0x51, 0x14, 0x7A, 0xB3, 0x37, + 0x51, 0x68, 0x03, 0x02, 0x2F, 0x39, 0x7E, 0x73, 0x37, 0x53, 0xBE, 0x70, + 0x01, 0x08, 0x18, 0x74, 0x01, 0x7E, 0x37, 0x37, 0x49, 0x19, 0xB3, 0x00, + 0x09, 0x7E, 0x37, 0x37, 0x49, 0x19, 0xB3, 0x00, 0x0B, 0x7E, 0x73, 0x37, + 0x53, 0x2C, 0xF7, 0x7C, 0xBF, 0xDA, 0x3B, 0x22, 0xCA, 0x3B, 0x7D, 0x62, + 0x7A, 0x37, 0x37, 0x4F, 0x7C, 0xFB, 0x0A, 0x33, 0x7A, 0x37, 0x37, 0x5F, + 0x1A, 0x0F, 0x09, 0x50, 0x07, 0x45, 0x0A, 0x25, 0x9D, 0x32, 0x7A, 0x37, + 0x37, 0x5F, 0x19, 0x70, 0x0A, 0x42, 0x1A, 0x0F, 0x19, 0x30, 0x07, 0x45, + 0x1A, 0x2F, 0x19, 0x22, 0x07, 0x95, 0x1A, 0x3F, 0x09, 0x73, 0x07, 0x95, + 0x12, 0xD3, 0xFA, 0xE4, 0x7A, 0xB3, 0x37, 0x52, 0x1A, 0x3F, 0x09, 0xB3, + 0x07, 0x27, 0xB4, 0x01, 0x66, 0x74, 0x01, 0x7A, 0xB3, 0x37, 0x52, 0x6C, + 0xEE, 0x3E, 0x34, 0x3E, 0x34, 0x3E, 0x34, 0x49, 0x33, 0x05, 0xF1, 0x7A, + 0x37, 0x37, 0x5B, 0x1A, 0x3F, 0x3E, 0x34, 0x3E, 0x34, 0x3E, 0x34, 0x49, + 0x33, 0x06, 0x41, 0x7A, 0x37, 0x37, 0x5D, 0x7E, 0x37, 0x37, 0x4F, 0x7D, + 0x26, 0x7E, 0x17, 0x37, 0x5B, 0x7E, 0x07, 0x37, 0x5D, 0x12, 0xF1, 0x4D, + 0x7A, 0x37, 0x37, 0x53, 0x7E, 0xB3, 0x04, 0x3D, 0x54, 0x7F, 0x0A, 0x3B, + 0xBE, 0x37, 0x37, 0x53, 0x48, 0x03, 0x7E, 0xE0, 0x01, 0x4C, 0xEE, 0x68, + 0x16, 0x7C, 0xBF, 0x7E, 0x37, 0x37, 0x4F, 0x7D, 0x26, 0x12, 0xDF, 0x28, + 0x7C, 0xBF, 0x7E, 0x37, 0x37, 0x4F, 0x7D, 0x26, 0x12, 0xEC, 0xCC, 0x1A, + 0x3F, 0x09, 0xB3, 0x07, 0x27, 0xB4, 0x04, 0x6C, 0x3E, 0x34, 0x49, 0x33, + 0x06, 0x91, 0x7A, 0x37, 0x37, 0x5B, 0x1A, 0x3F, 0x3E, 0x34, 0x49, 0x33, + 0x06, 0xA5, 0x7A, 0x37, 0x37, 0x5D, 0x7C, 0xBF, 0x7E, 0x37, 0x37, 0x5B, + 0x7E, 0x27, 0x37, 0x5D, 0x12, 0xDF, 0x28, 0x7C, 0xBF, 0x7E, 0x37, 0x37, + 0x5B, 0x7E, 0x27, 0x37, 0x5D, 0x12, 0xEC, 0xCC, 0x7E, 0x37, 0x37, 0x5B, + 0x1A, 0x2F, 0x3E, 0x24, 0x59, 0x32, 0x07, 0x4F, 0x7E, 0x37, 0x37, 0x5D, + 0x1A, 0x2F, 0x3E, 0x24, 0x59, 0x32, 0x07, 0x63, 0x7E, 0x37, 0x37, 0x5B, + 0x1A, 0x2F, 0x3E, 0x24, 0x3E, 0x24, 0x3E, 0x24, 0x3E, 0x24, 0x59, 0x32, + 0x08, 0xE7, 0x7E, 0x37, 0x37, 0x5D, 0x1A, 0x2F, 0x3E, 0x24, 0x3E, 0x24, + 0x3E, 0x24, 0x3E, 0x24, 0x59, 0x32, 0x08, 0xEB, 0x7C, 0xBF, 0x7E, 0x34, + 0x37, 0x5B, 0x7E, 0x24, 0x37, 0x5D, 0x12, 0xED, 0x64, 0x7E, 0x37, 0x37, + 0x4F, 0x7D, 0x26, 0x7E, 0x17, 0x37, 0x5B, 0x7E, 0x07, 0x37, 0x5D, 0x12, + 0xF1, 0x4D, 0x7A, 0x37, 0x37, 0x53, 0x0E, 0x34, 0x0E, 0x34, 0x7A, 0x37, + 0x37, 0x53, 0x7E, 0xE3, 0x04, 0x18, 0x7E, 0x70, 0x10, 0x7E, 0x27, 0x37, + 0x53, 0xBE, 0x24, 0x00, 0x10, 0x58, 0x02, 0x7C, 0x75, 0x0A, 0x07, 0x7E, + 0x14, 0x00, 0x10, 0x9D, 0x10, 0x7E, 0x63, 0x04, 0x17, 0x0A, 0x06, 0xAD, + 0x10, 0xAC, 0x7E, 0x2D, 0x31, 0x0E, 0x34, 0x0E, 0x34, 0x0E, 0x34, 0x0E, + 0x34, 0x7C, 0xE7, 0xBE, 0xE0, 0x01, 0x50, 0x03, 0x7E, 0xE0, 0x01, 0x1A, + 0x3F, 0x09, 0xB3, 0x0A, 0xAB, 0x60, 0x03, 0x7E, 0xE0, 0x0A, 0xE4, 0x7A, + 0xB3, 0x37, 0x51, 0x7C, 0xBF, 0x7E, 0x37, 0x37, 0x4F, 0x7D, 0x26, 0x0A, + 0x1E, 0x12, 0x9D, 0x65, 0x7C, 0xBF, 0x7E, 0x34, 0x37, 0x5B, 0x7E, 0x24, + 0x37, 0x5D, 0x12, 0xEA, 0x9A, 0x7E, 0x37, 0x37, 0x4F, 0x7D, 0x26, 0x7E, + 0x17, 0x37, 0x5B, 0x7E, 0x07, 0x37, 0x5D, 0x12, 0xF1, 0x4D, 0x7A, 0x37, + 0x37, 0x55, 0x7E, 0xB3, 0x04, 0x44, 0x0A, 0x3B, 0xBE, 0x37, 0x37, 0x55, + 0x18, 0x14, 0x60, 0x12, 0x7E, 0xB3, 0x37, 0x51, 0x04, 0x7A, 0xB3, 0x37, + 0x51, 0x7E, 0x73, 0x37, 0x51, 0xBE, 0x70, 0x06, 0x48, 0xB1, 0x7E, 0xE3, + 0x04, 0x19, 0x7E, 0x73, 0x03, 0xCB, 0x0A, 0x27, 0x7A, 0x27, 0x37, 0x5F, + 0x7E, 0x73, 0x04, 0x46, 0x1A, 0x37, 0xAD, 0x32, 0x7D, 0x23, 0x0E, 0x24, + 0x0E, 0x24, 0x0E, 0x24, 0x7E, 0x37, 0x37, 0x53, 0x9D, 0x32, 0x7A, 0x37, + 0x37, 0x53, 0x7E, 0xB3, 0x37, 0x52, 0x60, 0x23, 0x7E, 0x37, 0x37, 0x5B, + 0x1A, 0x2F, 0x3E, 0x24, 0x59, 0x32, 0x07, 0x4F, 0x7E, 0x37, 0x37, 0x5D, + 0x1A, 0x2F, 0x3E, 0x24, 0x59, 0x32, 0x07, 0x63, 0x74, 0x02, 0x1A, 0x3F, + 0x19, 0xB3, 0x07, 0x77, 0x02, 0x33, 0xB6, 0x4C, 0xEE, 0x78, 0x03, 0x02, + 0x33, 0xB6, 0x1A, 0x3F, 0x09, 0x53, 0x07, 0x77, 0xBE, 0x50, 0x01, 0x28, + 0x5A, 0x7E, 0xA3, 0x04, 0x45, 0x7C, 0xBA, 0x54, 0x0F, 0x0A, 0x1B, 0x7E, + 0x27, 0x37, 0x5F, 0x9D, 0x21, 0x7A, 0x27, 0x37, 0x5F, 0x7C, 0xBA, 0xC4, + 0x54, 0x0F, 0x7C, 0xAB, 0x7E, 0x07, 0x37, 0x5F, 0xBE, 0x04, 0x00, 0x00, + 0x08, 0x35, 0x4C, 0xAA, 0x68, 0x31, 0x7E, 0xB3, 0x03, 0xB7, 0xBE, 0xB0, + 0x01, 0x38, 0x28, 0x0A, 0x2E, 0x7A, 0x27, 0x37, 0x55, 0x0A, 0x1A, 0xAD, + 0x10, 0x7D, 0x21, 0x2E, 0x27, 0x37, 0x55, 0x7A, 0x27, 0x37, 0x55, 0xBE, + 0x24, 0x00, 0xFF, 0x08, 0x08, 0x7E, 0x24, 0x00, 0xFF, 0x7A, 0x27, 0x37, + 0x55, 0x7E, 0x27, 0x37, 0x55, 0x7C, 0xE5, 0x7E, 0x53, 0x04, 0x00, 0x2C, + 0xE5, 0x3E, 0x34, 0x49, 0x33, 0x07, 0x4F, 0x7A, 0x37, 0x37, 0x57, 0x1A, + 0x3F, 0x3E, 0x34, 0x49, 0x33, 0x07, 0x63, 0x7A, 0x37, 0x37, 0x59, 0x7E, + 0x37, 0x37, 0x57, 0x7E, 0x27, 0x37, 0x59, 0x12, 0xDD, 0x33, 0x0A, 0x3B, + 0x4D, 0x33, 0x68, 0x0D, 0x7E, 0x73, 0x03, 0xCA, 0xBE, 0x70, 0x14, 0x28, + 0x04, 0x1E, 0xE0, 0x1E, 0xE0, 0x7E, 0x37, 0x37, 0x5B, 0x7E, 0x27, 0x37, + 0x5D, 0x7E, 0x17, 0x37, 0x57, 0x7E, 0x07, 0x37, 0x59, 0x12, 0xF1, 0x4D, + 0x7D, 0x23, 0x1A, 0x4F, 0x09, 0x74, 0x07, 0x77, 0x7C, 0xBE, 0xAC, 0xB7, + 0xBD, 0x52, 0x48, 0x03, 0x02, 0x33, 0xA6, 0x7E, 0x60, 0x02, 0x7C, 0xBE, + 0xAC, 0xB6, 0xBD, 0x52, 0x58, 0x12, 0xA5, 0xBF, 0x01, 0x0E, 0x7E, 0x37, + 0x37, 0x5B, 0x7A, 0x37, 0x37, 0x57, 0x7E, 0x37, 0x37, 0x5D, 0x80, 0x52, + 0x7E, 0x37, 0x37, 0x57, 0x1A, 0x26, 0x1A, 0x24, 0x7E, 0x14, 0x00, 0x03, + 0x12, 0x8C, 0xCB, 0x7E, 0x17, 0x37, 0x5B, 0x1A, 0x02, 0x1A, 0x00, 0x2F, + 0x10, 0x74, 0x02, 0x1E, 0x34, 0x0E, 0x24, 0x50, 0x03, 0x4E, 0x60, 0x80, + 0x14, 0x78, 0xF4, 0x7A, 0x37, 0x37, 0x57, 0x7E, 0x37, 0x37, 0x59, 0x1A, + 0x26, 0x1A, 0x24, 0x7E, 0x14, 0x00, 0x03, 0x12, 0x8C, 0xCB, 0x7E, 0x17, + 0x37, 0x5D, 0x1A, 0x02, 0x1A, 0x00, 0x2F, 0x10, 0x74, 0x02, 0x1E, 0x34, + 0x0E, 0x24, 0x50, 0x03, 0x4E, 0x60, 0x80, 0x14, 0x78, 0xF4, 0x7A, 0x37, + 0x37, 0x59, 0x7E, 0x37, 0x37, 0x57, 0x1A, 0x2F, 0x3E, 0x24, 0x59, 0x32, + 0x07, 0x4F, 0x7E, 0x37, 0x37, 0x59, 0x1A, 0x2F, 0x3E, 0x24, 0x59, 0x32, + 0x07, 0x63, 0x74, 0x01, 0x1A, 0x3F, 0x19, 0xB3, 0x07, 0x77, 0x7E, 0x37, + 0x37, 0x57, 0x7A, 0x37, 0x37, 0x5B, 0x7E, 0x37, 0x37, 0x59, 0x7A, 0x37, + 0x37, 0x5D, 0x7C, 0xBF, 0x7E, 0x37, 0x37, 0x5B, 0x7E, 0x27, 0x37, 0x5D, + 0x7E, 0x14, 0x37, 0x57, 0x7E, 0x04, 0x37, 0x59, 0x12, 0xC6, 0x02, 0x7C, + 0xBF, 0x7E, 0x37, 0x37, 0x5B, 0x7E, 0x27, 0x37, 0x5D, 0x12, 0xE7, 0x59, + 0xDA, 0x3B, 0x22, 0xCA, 0x3B, 0x7C, 0xFB, 0x7E, 0xB3, 0x03, 0xBB, 0x70, + 0x05, 0xE4, 0x7A, 0xB3, 0x03, 0xF9, 0x7E, 0x73, 0x03, 0xB7, 0xBE, 0x70, + 0x03, 0x50, 0x08, 0x7E, 0xB3, 0x04, 0x73, 0x54, 0x7C, 0x78, 0x06, 0x74, + 0x01, 0x7A, 0xB3, 0x03, 0xF9, 0x7E, 0xB3, 0x04, 0x31, 0xB4, 0xFF, 0x0F, + 0x7E, 0xB3, 0x03, 0xF9, 0x60, 0x09, 0x74, 0x03, 0x7A, 0xB3, 0x03, 0xF9, + 0x02, 0x37, 0x36, 0x7E, 0xB3, 0x03, 0xFA, 0x70, 0x03, 0x02, 0x37, 0x36, + 0x6C, 0xEE, 0xE4, 0x1A, 0x3E, 0x19, 0xB3, 0x37, 0x50, 0x0B, 0xE0, 0xBE, + 0xE0, 0x0A, 0x48, 0xF2, 0x7E, 0x64, 0xC1, 0x50, 0x6C, 0xEE, 0x02, 0x35, + 0xDD, 0x09, 0xB6, 0x00, 0x09, 0x60, 0x0B, 0x09, 0xB6, 0x00, 0x0B, 0x54, + 0x03, 0x78, 0x03, 0x02, 0x35, 0xD7, 0xE4, 0x7A, 0xB3, 0x37, 0x5A, 0x7E, + 0x34, 0x00, 0xFF, 0x7A, 0x37, 0x37, 0x4A, 0x7A, 0xB3, 0x37, 0x49, 0x7E, + 0x73, 0x37, 0x49, 0x1A, 0x37, 0x7E, 0x14, 0x00, 0x0E, 0xAD, 0x13, 0x7D, + 0x21, 0x2E, 0x24, 0x08, 0x53, 0x7A, 0x27, 0x37, 0x47, 0x7E, 0x29, 0xB0, + 0x70, 0x03, 0x02, 0x35, 0x74, 0x7E, 0x27, 0x37, 0x47, 0x09, 0xB2, 0x00, + 0x01, 0xB4, 0x01, 0x22, 0x09, 0xB6, 0x00, 0x09, 0x60, 0x03, 0x02, 0x35, + 0x74, 0x09, 0x56, 0x00, 0x08, 0xBE, 0x53, 0x04, 0x31, 0x40, 0x03, 0x02, + 0x35, 0x74, 0x09, 0xB3, 0x07, 0x27, 0xB4, 0x02, 0x02, 0x80, 0x03, 0x02, + 0x35, 0x74, 0x7E, 0x37, 0x37, 0x47, 0x09, 0x73, 0x00, 0x03, 0x7A, 0x73, + 0x37, 0x5B, 0x7E, 0x37, 0x37, 0x47, 0x09, 0x73, 0x00, 0x04, 0x7A, 0x73, + 0x37, 0x5C, 0x7E, 0x37, 0x37, 0x47, 0x09, 0x73, 0x00, 0x05, 0x7A, 0x73, + 0x37, 0x5D, 0x7E, 0x37, 0x37, 0x47, 0x09, 0x73, 0x00, 0x06, 0x7A, 0x73, + 0x37, 0x5E, 0xE4, 0x7A, 0xB3, 0x37, 0x4F, 0x7E, 0x37, 0x37, 0x47, 0x09, + 0xB3, 0x00, 0x02, 0x30, 0xE1, 0x06, 0x74, 0x01, 0x7A, 0xB3, 0x37, 0x4F, + 0x09, 0xB6, 0x00, 0x08, 0xB4, 0x01, 0x09, 0x7E, 0xB3, 0x37, 0x4F, 0x04, + 0x7A, 0xB3, 0x37, 0x4F, 0x7D, 0x36, 0x7E, 0xB3, 0x37, 0x5B, 0x7E, 0x53, + 0x37, 0x5C, 0x7E, 0x43, 0x37, 0x5D, 0x7E, 0x33, 0x37, 0x5E, 0x7E, 0x23, + 0x37, 0x4F, 0x12, 0xD8, 0x86, 0x60, 0x5D, 0x7E, 0xA3, 0x37, 0x49, 0x1A, + 0x3A, 0x09, 0xB3, 0x07, 0x45, 0x0A, 0x3B, 0x09, 0xB6, 0x00, 0x08, 0x0A, + 0x2B, 0x9D, 0x32, 0x7A, 0x37, 0x37, 0x4C, 0xBE, 0x34, 0x00, 0x00, 0x58, + 0x0A, 0x6D, 0x33, 0x9E, 0x37, 0x37, 0x4C, 0x7A, 0x37, 0x37, 0x4C, 0x7E, + 0x37, 0x37, 0x47, 0x09, 0xB3, 0x00, 0x01, 0xB4, 0x01, 0x0A, 0x7E, 0x27, + 0x37, 0x4C, 0xBE, 0x24, 0x00, 0x0A, 0x18, 0x20, 0x7E, 0x47, 0x37, 0x4C, + 0xBE, 0x47, 0x37, 0x4A, 0x58, 0x16, 0x7A, 0x47, 0x37, 0x4A, 0x0A, 0x2B, + 0x3E, 0x24, 0x3E, 0x24, 0x3E, 0x24, 0x3E, 0x24, 0x1A, 0x3A, 0x2D, 0x32, + 0x7A, 0x73, 0x37, 0x5A, 0x7E, 0xB3, 0x37, 0x49, 0x04, 0x7A, 0xB3, 0x37, + 0x49, 0x7E, 0x73, 0x37, 0x49, 0xBE, 0x70, 0x0A, 0x58, 0x03, 0x02, 0x34, + 0x5B, 0x7E, 0xB3, 0x37, 0x5A, 0x60, 0x48, 0x54, 0x30, 0x7A, 0xB3, 0x37, + 0x4E, 0x7D, 0x26, 0x2E, 0x24, 0x00, 0x0B, 0x7E, 0x29, 0x70, 0x4E, 0x73, + 0x37, 0x4E, 0x7A, 0x29, 0x70, 0x7E, 0xB3, 0x37, 0x4E, 0x30, 0xE5, 0x2B, + 0x09, 0xB6, 0x00, 0x09, 0x60, 0x0A, 0x7E, 0xB3, 0x37, 0x5A, 0x24, 0x80, + 0x7A, 0xB3, 0x37, 0x5A, 0x7E, 0x73, 0x37, 0x5A, 0x19, 0x76, 0x00, 0x09, + 0x7E, 0xB3, 0x37, 0x5A, 0x54, 0x0F, 0x0A, 0x3B, 0x2E, 0x34, 0x37, 0x50, + 0x7E, 0x39, 0xB0, 0x04, 0x7A, 0x39, 0xB0, 0x2E, 0x64, 0x00, 0x10, 0x0B, + 0xE0, 0xBC, 0xFE, 0x08, 0x03, 0x02, 0x34, 0x39, 0x6C, 0xEE, 0x1A, 0x3E, + 0x09, 0xB3, 0x37, 0x50, 0x60, 0x79, 0x7E, 0x64, 0xC1, 0x50, 0x9F, 0x11, + 0x7A, 0x37, 0x37, 0x45, 0xE4, 0x80, 0x62, 0x09, 0xB6, 0x00, 0x09, 0x7A, + 0xB3, 0x37, 0x5A, 0x54, 0x30, 0x7A, 0xB3, 0x37, 0x4E, 0x68, 0x49, 0x7E, + 0xB3, 0x37, 0x5A, 0x54, 0x0F, 0xBC, 0xBE, 0x78, 0x3F, 0xE4, 0x19, 0xB6, + 0x00, 0x09, 0x7E, 0xB3, 0x37, 0x5A, 0x30, 0xE7, 0x10, 0x1A, 0x3E, 0x09, + 0x73, 0x37, 0x50, 0xBE, 0x70, 0x01, 0x28, 0x05, 0xE4, 0x19, 0xB6, 0x00, + 0x08, 0x7E, 0x37, 0x37, 0x45, 0x4D, 0x33, 0x78, 0x06, 0x7A, 0x67, 0x37, + 0x45, 0x80, 0x15, 0x7D, 0x26, 0x12, 0xAD, 0xF1, 0x7E, 0x37, 0x37, 0x45, + 0x2E, 0x34, 0x00, 0x0B, 0x7E, 0x39, 0xB0, 0x44, 0x80, 0x7A, 0x39, 0xB0, + 0x2E, 0x64, 0x00, 0x10, 0x7E, 0xB3, 0x37, 0x49, 0x04, 0x7A, 0xB3, 0x37, + 0x49, 0xBE, 0xF3, 0x37, 0x49, 0x18, 0x94, 0x0B, 0xE0, 0xBE, 0xE0, 0x0A, + 0x58, 0x03, 0x02, 0x35, 0xE6, 0x7E, 0xB3, 0x04, 0x73, 0x54, 0x03, 0x7A, + 0xB3, 0x37, 0x4F, 0x78, 0x03, 0x02, 0x37, 0x36, 0x7E, 0x73, 0x04, 0x72, + 0x3E, 0x70, 0x0A, 0x37, 0x7A, 0x37, 0x37, 0x5F, 0x7E, 0x64, 0xC1, 0x50, + 0x6C, 0xEE, 0x02, 0x37, 0x2F, 0x09, 0xB6, 0x00, 0x0B, 0x54, 0x30, 0x7A, + 0xB3, 0x37, 0x4E, 0x09, 0xB6, 0x00, 0x09, 0x60, 0x03, 0x02, 0x37, 0x29, + 0x7E, 0xB3, 0x37, 0x4E, 0x30, 0xE5, 0x7A, 0x7E, 0x34, 0xC1, 0x50, 0x7A, + 0x37, 0x37, 0x45, 0xE4, 0x80, 0x65, 0x7E, 0x17, 0x37, 0x45, 0x09, 0xB1, + 0x00, 0x09, 0x70, 0x4A, 0x09, 0xB1, 0x00, 0x0B, 0x54, 0x30, 0x78, 0x42, + 0x09, 0x71, 0x00, 0x08, 0xBE, 0x73, 0x04, 0x31, 0x50, 0x38, 0x7E, 0xB3, + 0x37, 0x4E, 0xBE, 0xB0, 0x30, 0x68, 0x0A, 0x49, 0x01, 0x00, 0x02, 0xBE, + 0x07, 0x37, 0x5F, 0x58, 0x25, 0x7D, 0x36, 0x09, 0xB1, 0x00, 0x04, 0x09, + 0x51, 0x00, 0x05, 0x09, 0x41, 0x00, 0x06, 0x09, 0x31, 0x00, 0x07, 0x7E, + 0x23, 0x37, 0x4F, 0x12, 0xD8, 0x86, 0x60, 0x0A, 0x74, 0x01, 0x7E, 0x37, + 0x37, 0x45, 0x19, 0xB3, 0x00, 0x09, 0x7E, 0x37, 0x37, 0x45, 0x2E, 0x34, + 0x00, 0x10, 0x7A, 0x37, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x49, 0x04, 0x7A, + 0xB3, 0x37, 0x49, 0xBE, 0xF3, 0x37, 0x49, 0x18, 0x91, 0x2E, 0x64, 0x00, + 0x10, 0x0B, 0xE0, 0xBC, 0xFE, 0x08, 0x03, 0x02, 0x36, 0x95, 0xDA, 0x3B, + 0x22, 0xCA, 0x3B, 0x7C, 0xFB, 0x7F, 0x61, 0x7F, 0x50, 0x9F, 0x77, 0x6D, + 0x33, 0x7A, 0x37, 0x38, 0xEF, 0x7E, 0x73, 0x37, 0x22, 0x7A, 0x73, 0x38, + 0xF5, 0x0A, 0x3F, 0x1B, 0x34, 0x7A, 0x73, 0x38, 0xF6, 0x7E, 0x73, 0x2E, + 0x57, 0xBC, 0x7F, 0x78, 0x08, 0x74, 0x01, 0x7A, 0xB3, 0x38, 0xF4, 0x80, + 0x08, 0x7E, 0x73, 0x37, 0x11, 0x7A, 0x73, 0x38, 0xF4, 0x6C, 0xEE, 0x02, + 0x38, 0x83, 0x7A, 0xE3, 0x38, 0x29, 0x6D, 0x00, 0x6D, 0x44, 0x7E, 0x73, + 0x38, 0xF4, 0x0A, 0x97, 0x0A, 0x3F, 0x9D, 0x39, 0x7E, 0x23, 0x38, 0x29, + 0x0A, 0x52, 0xBD, 0x53, 0x18, 0x35, 0xE4, 0x80, 0x22, 0x7E, 0x33, 0x38, + 0x29, 0x7E, 0x70, 0x02, 0x7C, 0xB3, 0xAC, 0xB7, 0x7E, 0x1F, 0x38, 0x1C, + 0x2D, 0x35, 0x0B, 0x1A, 0x50, 0x2D, 0x45, 0x7C, 0xB3, 0x04, 0x7A, 0xB3, + 0x38, 0x29, 0x7E, 0xB3, 0x38, 0x28, 0x04, 0x7A, 0xB3, 0x38, 0x28, 0x7E, + 0x73, 0x38, 0xF4, 0xBE, 0x73, 0x38, 0x28, 0x38, 0xD0, 0x80, 0x4F, 0x7A, + 0x23, 0x38, 0x28, 0xE4, 0x7A, 0xB3, 0x38, 0x2A, 0x80, 0x2F, 0x7E, 0x33, + 0x38, 0x29, 0x7E, 0x70, 0x02, 0x7C, 0xB3, 0xAC, 0xB7, 0x7E, 0x1F, 0x38, + 0x1C, 0x2D, 0x35, 0x0B, 0x1A, 0x50, 0x2D, 0x45, 0x7C, 0xB3, 0x04, 0x7A, + 0xB3, 0x38, 0x29, 0x7E, 0xB3, 0x38, 0x2A, 0x04, 0x7A, 0xB3, 0x38, 0x2A, + 0x7E, 0xB3, 0x38, 0x28, 0x04, 0x7A, 0xB3, 0x38, 0x28, 0xBE, 0xF3, 0x38, + 0x28, 0x38, 0xCB, 0x7E, 0x73, 0x38, 0x2A, 0x0A, 0x27, 0x7D, 0x34, 0x12, + 0x8C, 0x88, 0xAD, 0x39, 0x7D, 0x43, 0xBE, 0x44, 0x00, 0x00, 0x58, 0x02, + 0x7D, 0x40, 0x74, 0x02, 0x7C, 0x3E, 0xAC, 0x3B, 0x59, 0x41, 0x38, 0x2D, + 0x4C, 0xEE, 0x78, 0x0E, 0x49, 0x31, 0x38, 0x2D, 0x1A, 0x26, 0x1A, 0x24, + 0x74, 0x04, 0xAC, 0xBE, 0x80, 0x16, 0x49, 0x11, 0x38, 0x2D, 0x1A, 0x02, + 0x1A, 0x00, 0x74, 0x04, 0xAC, 0xBE, 0x49, 0x35, 0x38, 0x6B, 0x49, 0x25, + 0x38, 0x69, 0x2F, 0x10, 0x59, 0x35, 0x38, 0x6F, 0x59, 0x25, 0x38, 0x6D, + 0x74, 0x02, 0xAC, 0xBE, 0x49, 0x85, 0x38, 0x2D, 0x7D, 0x18, 0x1A, 0x02, + 0x1A, 0x00, 0x0A, 0x3E, 0x6D, 0x22, 0x0B, 0x1C, 0x12, 0x8C, 0xBA, 0x2F, + 0x71, 0x7E, 0x73, 0x2E, 0x56, 0xBC, 0x7F, 0x78, 0x08, 0x74, 0x02, 0xAC, + 0xBE, 0x59, 0x85, 0x31, 0xA1, 0x0B, 0xE0, 0xBC, 0xFE, 0x28, 0x03, 0x02, + 0x37, 0x76, 0x7E, 0x93, 0x38, 0xF5, 0x0A, 0x09, 0x7E, 0xB3, 0x38, 0xF6, + 0x0A, 0x1B, 0x9D, 0x10, 0x3E, 0x14, 0x3E, 0x14, 0x49, 0x31, 0x38, 0x6F, + 0x49, 0x21, 0x38, 0x6D, 0x7E, 0x30, 0x04, 0xAC, 0xB3, 0x49, 0x95, 0x38, + 0x6F, 0x49, 0x85, 0x38, 0x6D, 0x7F, 0x04, 0x9F, 0x01, 0x7E, 0x70, 0x04, + 0x7C, 0xB9, 0xAC, 0xB7, 0x49, 0x35, 0x38, 0x6B, 0x49, 0x25, 0x38, 0x69, + 0x2F, 0x10, 0x7A, 0x1F, 0x38, 0xF7, 0xBE, 0x48, 0x00, 0x00, 0x68, 0x16, + 0x7E, 0x14, 0x00, 0x64, 0x7F, 0x17, 0x12, 0x8C, 0xCB, 0x7F, 0x04, 0x12, + 0x8D, 0x27, 0x9E, 0x34, 0x00, 0x64, 0x7A, 0x37, 0x38, 0xEF, 0x7F, 0x14, + 0x1E, 0x34, 0x0E, 0x24, 0x50, 0x03, 0x4E, 0x60, 0x80, 0x7F, 0x71, 0x7E, + 0x73, 0x38, 0xF6, 0x0A, 0x37, 0x7A, 0x37, 0x38, 0xED, 0x7E, 0x73, 0x38, + 0xF6, 0x7E, 0xD0, 0x64, 0xAC, 0xD7, 0x6C, 0xEE, 0x80, 0x76, 0x7E, 0x70, + 0x04, 0x7C, 0xBE, 0xAC, 0xB7, 0x49, 0x95, 0x38, 0x6F, 0x49, 0x85, 0x38, + 0x6D, 0xBF, 0x47, 0x48, 0x61, 0x4C, 0xEE, 0x78, 0x04, 0x6D, 0x66, 0x80, + 0x46, 0x49, 0x15, 0x38, 0x6B, 0x49, 0x05, 0x38, 0x69, 0xBF, 0x04, 0x68, + 0x35, 0x7F, 0x17, 0x9F, 0x10, 0x7E, 0x64, 0x00, 0x64, 0x7D, 0x16, 0x12, + 0x8C, 0xCB, 0x49, 0x95, 0x38, 0x6B, 0x49, 0x85, 0x38, 0x69, 0x49, 0x15, + 0x38, 0x6F, 0x49, 0x05, 0x38, 0x6D, 0x9F, 0x04, 0x12, 0x8D, 0x27, 0x7D, + 0x53, 0x0A, 0x3E, 0x6D, 0x22, 0x1B, 0x1C, 0x7D, 0x16, 0x12, 0x8C, 0xCB, + 0x7D, 0x63, 0x2D, 0x65, 0x80, 0x05, 0x7E, 0xD0, 0x64, 0xAC, 0xDE, 0x7D, + 0x36, 0x2E, 0x34, 0x00, 0x32, 0x7E, 0x24, 0x00, 0x64, 0x12, 0x8C, 0x88, + 0x7A, 0x37, 0x38, 0xED, 0x80, 0x0A, 0x0B, 0xE0, 0x7E, 0x73, 0x38, 0xF6, + 0xBC, 0x7E, 0x38, 0x82, 0x7E, 0x47, 0x38, 0xEF, 0xBD, 0x46, 0x48, 0x0B, + 0xE4, 0x7A, 0xB3, 0x38, 0xF2, 0x7E, 0x37, 0x38, 0xED, 0x80, 0x0C, 0x7E, + 0x37, 0x38, 0xED, 0x7A, 0x73, 0x38, 0xF2, 0x7E, 0x73, 0x38, 0xF6, 0x7A, + 0x73, 0x38, 0xF3, 0x7E, 0x34, 0xFF, 0xFF, 0x7A, 0x37, 0x38, 0x2B, 0x7E, + 0xE3, 0x38, 0xF2, 0x80, 0x18, 0x74, 0x02, 0xAC, 0xBE, 0x49, 0x25, 0x38, + 0x2D, 0xBE, 0x27, 0x38, 0x2B, 0x08, 0x08, 0x7A, 0x27, 0x38, 0x2B, 0x7A, + 0xE3, 0x38, 0xF1, 0x0B, 0xE0, 0x7E, 0x73, 0x38, 0xF3, 0xBC, 0x7E, 0x50, + 0xE0, 0xBD, 0x46, 0x48, 0x11, 0x7E, 0x70, 0x64, 0xAC, 0x7F, 0x0E, 0x34, + 0xBE, 0x37, 0x38, 0xEF, 0x08, 0x04, 0x74, 0x01, 0x80, 0x01, 0xE4, 0x7E, + 0x1F, 0x38, 0x20, 0x7A, 0x1B, 0xB0, 0x7E, 0xB3, 0x38, 0xF6, 0x7E, 0x70, + 0x04, 0xAC, 0xB7, 0x49, 0x35, 0x38, 0x6F, 0x49, 0x25, 0x38, 0x6D, 0x7F, + 0x01, 0x1E, 0x14, 0x0E, 0x04, 0x50, 0x03, 0x4E, 0x20, 0x80, 0x7E, 0x1F, + 0x38, 0xF7, 0xBF, 0x10, 0x08, 0x1C, 0x7E, 0x73, 0x38, 0xF5, 0xBE, 0x73, + 0x38, 0xF1, 0x38, 0x0E, 0x0A, 0x37, 0x0A, 0x2F, 0x9D, 0x23, 0x7E, 0x73, + 0x38, 0xF1, 0xBD, 0x32, 0x48, 0x04, 0x74, 0x01, 0x80, 0x01, 0xE4, 0x7E, + 0x1F, 0x38, 0x24, 0x7A, 0x1B, 0xB0, 0x7E, 0x37, 0x38, 0x2B, 0x1B, 0x5A, + 0x30, 0x7E, 0x73, 0x38, 0xF1, 0x7A, 0x6B, 0x70, 0xDA, 0x3B, 0x22, 0xCA, + 0x3B, 0x7D, 0x60, 0x7A, 0x17, 0x37, 0x32, 0x7A, 0x27, 0x37, 0x30, 0x7D, + 0x73, 0x7E, 0x24, 0x00, 0x0A, 0x12, 0xF2, 0xA4, 0xE4, 0x7A, 0xB3, 0x37, + 0x35, 0x7A, 0xB3, 0x37, 0x34, 0x7E, 0x73, 0x37, 0x34, 0x1A, 0x47, 0x7E, + 0x34, 0x00, 0x0B, 0xAD, 0x34, 0x7D, 0x53, 0x2E, 0x54, 0x09, 0x83, 0x7A, + 0x57, 0x37, 0x47, 0x09, 0xA4, 0x07, 0x27, 0xBE, 0xA0, 0x02, 0x50, 0x03, + 0x02, 0x3D, 0x40, 0x09, 0xB4, 0x07, 0x81, 0x7A, 0xB3, 0x37, 0x43, 0xBE, + 0xB0, 0x00, 0x58, 0x10, 0xBE, 0xA0, 0x05, 0x68, 0x03, 0x02, 0x3D, 0x40, + 0xE4, 0x19, 0xB4, 0x07, 0x27, 0x02, 0x3D, 0x40, 0x09, 0xB4, 0x08, 0x49, + 0x20, 0xE7, 0x06, 0x7E, 0xB3, 0x03, 0xE2, 0x60, 0x08, 0xE4, 0x7A, 0xB3, + 0x37, 0x42, 0x02, 0x3D, 0x18, 0x7E, 0xB3, 0x37, 0x43, 0x1A, 0x3B, 0x2D, + 0x37, 0x7A, 0x37, 0x37, 0x44, 0xBE, 0xA0, 0x05, 0x78, 0x66, 0x7E, 0x37, + 0x37, 0x47, 0x7E, 0x39, 0xB0, 0xB4, 0x08, 0x48, 0x74, 0x01, 0x7E, 0x37, + 0x37, 0x44, 0x7A, 0x39, 0xB0, 0x7E, 0x37, 0x37, 0x47, 0x09, 0xB3, 0x00, + 0x02, 0xB4, 0x01, 0x12, 0x49, 0x33, 0x00, 0x03, 0x7A, 0x37, 0x37, 0x3D, + 0x7E, 0x37, 0x37, 0x47, 0x49, 0x33, 0x00, 0x05, 0x80, 0x1C, 0x7E, 0x73, + 0x37, 0x34, 0x1A, 0x37, 0x3E, 0x34, 0x49, 0x33, 0x06, 0x91, 0x7A, 0x37, + 0x37, 0x3D, 0x7E, 0x73, 0x37, 0x34, 0x1A, 0x37, 0x3E, 0x34, 0x49, 0x33, + 0x06, 0xA5, 0x7A, 0x37, 0x37, 0x3F, 0x80, 0x7E, 0xE4, 0x7E, 0x37, 0x37, + 0x44, 0x7A, 0x39, 0xB0, 0x7E, 0xA3, 0x37, 0x34, 0x1A, 0x3A, 0x19, 0xB3, + 0x07, 0x27, 0x80, 0x6A, 0x74, 0x01, 0x7E, 0x37, 0x37, 0x44, 0x7A, 0x39, + 0xB0, 0x7E, 0x73, 0x37, 0x34, 0x1A, 0x47, 0x09, 0xA4, 0x07, 0x27, 0xBE, + 0xA0, 0x03, 0x78, 0x44, 0x7E, 0xB3, 0x04, 0x70, 0x30, 0xE5, 0x02, 0x80, + 0x40, 0x7E, 0xB3, 0x04, 0x2B, 0x0A, 0x3B, 0x1B, 0x34, 0x7A, 0x73, 0x37, + 0x3C, 0x7E, 0xB3, 0x05, 0x30, 0x2E, 0xB3, 0x37, 0x3C, 0x7A, 0xB3, 0x37, + 0x3C, 0xBE, 0xB0, 0x02, 0x28, 0x06, 0x74, 0x02, 0x7A, 0xB3, 0x37, 0x3C, + 0x09, 0xB4, 0x07, 0x1D, 0xBE, 0xB3, 0x37, 0x3C, 0x50, 0x04, 0x74, 0x03, + 0x80, 0x11, 0x74, 0x04, 0x19, 0xB4, 0x07, 0x27, 0x74, 0x02, 0x80, 0x07, + 0xBE, 0xA0, 0x04, 0x78, 0x09, 0x74, 0x03, 0x7E, 0x37, 0x37, 0x44, 0x7A, + 0x39, 0xB0, 0x7E, 0x73, 0x37, 0x34, 0x1A, 0x27, 0x09, 0x72, 0x07, 0x27, + 0xBE, 0x70, 0x04, 0x50, 0x16, 0xBE, 0x70, 0x02, 0x40, 0x11, 0x7E, 0xB3, + 0x37, 0x34, 0x7E, 0x34, 0x37, 0x3D, 0x7E, 0x24, 0x37, 0x3F, 0x12, 0xED, + 0x64, 0x80, 0x2F, 0x7E, 0x73, 0x37, 0x34, 0x1A, 0x37, 0x09, 0xB3, 0x07, + 0x27, 0xBE, 0xB0, 0x05, 0x68, 0x20, 0x7E, 0x73, 0x37, 0x34, 0x1A, 0x37, + 0x3E, 0x34, 0x49, 0x33, 0x06, 0x91, 0x7A, 0x37, 0x37, 0x3D, 0x7E, 0x73, + 0x37, 0x34, 0x1A, 0x37, 0x3E, 0x34, 0x49, 0x33, 0x06, 0xA5, 0x7A, 0x37, + 0x37, 0x3F, 0x7E, 0x33, 0x04, 0x1C, 0x7A, 0x33, 0x37, 0x36, 0x7E, 0x23, + 0x04, 0x1D, 0x7A, 0x23, 0x37, 0x37, 0x7E, 0x23, 0x04, 0x1E, 0x7A, 0x23, + 0x37, 0x38, 0x7E, 0x73, 0x04, 0x1F, 0x7A, 0x73, 0x37, 0x39, 0x7E, 0x13, + 0x04, 0x20, 0x7A, 0x13, 0x37, 0x3A, 0x7E, 0x03, 0x04, 0x21, 0x7A, 0x03, + 0x37, 0x3B, 0x7E, 0xB3, 0x05, 0x17, 0x7A, 0xB3, 0x37, 0x46, 0x7E, 0x37, + 0x04, 0x22, 0x7A, 0x37, 0x37, 0x89, 0x7E, 0x03, 0x04, 0x27, 0x7A, 0x03, + 0x37, 0x8C, 0x7E, 0x34, 0x37, 0x41, 0x7A, 0x37, 0x37, 0x8D, 0x7E, 0x37, + 0x37, 0x3D, 0x7E, 0x27, 0x05, 0x1C, 0x7E, 0x03, 0x04, 0x26, 0x12, 0x84, + 0x66, 0x7D, 0x23, 0x7E, 0x73, 0x37, 0x43, 0x1A, 0x37, 0x3E, 0x34, 0x2E, + 0x37, 0x37, 0x30, 0x1B, 0x38, 0x20, 0x7E, 0xB3, 0x37, 0x41, 0xB4, 0x01, + 0x12, 0xE4, 0x7E, 0xA3, 0x37, 0x34, 0x1A, 0x3A, 0x19, 0xB3, 0x07, 0x27, + 0x7E, 0x37, 0x37, 0x44, 0x7A, 0x39, 0xB0, 0x7E, 0xB3, 0x05, 0x18, 0x7A, + 0xB3, 0x37, 0x46, 0x7E, 0x37, 0x04, 0x24, 0x7A, 0x37, 0x37, 0x89, 0x7E, + 0xA3, 0x04, 0x29, 0x7A, 0xA3, 0x37, 0x8C, 0x7E, 0x34, 0x37, 0x41, 0x7A, + 0x37, 0x37, 0x8D, 0x7E, 0x37, 0x37, 0x3F, 0x7E, 0x27, 0x05, 0x1E, 0x7E, + 0x33, 0x37, 0x37, 0x7E, 0x23, 0x37, 0x39, 0x7E, 0x13, 0x37, 0x3B, 0x7E, + 0x03, 0x04, 0x28, 0x12, 0x84, 0x66, 0x7D, 0x23, 0x7E, 0x73, 0x37, 0x43, + 0x1A, 0x37, 0x3E, 0x34, 0x2E, 0x37, 0x37, 0x32, 0x1B, 0x38, 0x20, 0x7E, + 0xB3, 0x37, 0x41, 0xB4, 0x01, 0x12, 0xE4, 0x7E, 0xA3, 0x37, 0x34, 0x1A, + 0x3A, 0x19, 0xB3, 0x07, 0x27, 0x7E, 0x37, 0x37, 0x44, 0x7A, 0x39, 0xB0, + 0x7E, 0x73, 0x37, 0x34, 0x1A, 0x37, 0x09, 0x53, 0x07, 0x45, 0x7E, 0x43, + 0x37, 0x43, 0x1A, 0x34, 0x2D, 0x36, 0x7A, 0x39, 0x50, 0x7E, 0x37, 0x37, + 0x47, 0x7E, 0x39, 0x70, 0xBE, 0x70, 0x06, 0x50, 0x08, 0xE4, 0x7E, 0x37, + 0x37, 0x44, 0x7A, 0x39, 0xB0, 0x7E, 0x37, 0x37, 0x44, 0x7E, 0x39, 0x70, + 0x7A, 0x73, 0x37, 0x42, 0x7E, 0xB3, 0x37, 0x42, 0x60, 0x0B, 0x7E, 0xB3, + 0x37, 0x35, 0x04, 0x7A, 0xB3, 0x37, 0x35, 0x80, 0x17, 0xE4, 0x7E, 0xA3, + 0x37, 0x43, 0x1A, 0x3A, 0x19, 0xB3, 0x07, 0x8B, 0x74, 0xFE, 0x7E, 0xA3, + 0x37, 0x34, 0x1A, 0x3A, 0x19, 0xB3, 0x07, 0x81, 0x7E, 0xB3, 0x37, 0x34, + 0x04, 0x7A, 0xB3, 0x37, 0x34, 0x7E, 0x73, 0x37, 0x34, 0xBE, 0x70, 0x0A, + 0x58, 0x03, 0x02, 0x3A, 0x6D, 0x7E, 0x73, 0x37, 0x35, 0x1A, 0x37, 0xDA, + 0x3B, 0x22, 0xCA, 0xD8, 0xCA, 0x79, 0x7D, 0x73, 0x7E, 0xB3, 0x2D, 0x82, + 0x54, 0x0F, 0x7A, 0xB3, 0x2D, 0x70, 0x7E, 0x73, 0x2D, 0x70, 0xBE, 0x70, + 0x03, 0x38, 0x03, 0x02, 0x3E, 0x30, 0x6C, 0xDD, 0x7E, 0x37, 0x2D, 0xE1, + 0x09, 0xB3, 0x00, 0x06, 0x60, 0x13, 0x7E, 0x37, 0x2D, 0xE1, 0x09, 0x73, + 0x00, 0x06, 0x0A, 0x37, 0xBE, 0x37, 0x2D, 0x14, 0x38, 0x03, 0x7E, 0xD0, + 0x01, 0x7E, 0x37, 0x2D, 0xE1, 0x09, 0xB3, 0x00, 0x07, 0x60, 0x13, 0x7E, + 0x37, 0x2D, 0xE1, 0x09, 0x73, 0x00, 0x07, 0x0A, 0x37, 0xBE, 0x37, 0x2D, + 0x14, 0x38, 0x03, 0x7E, 0xD0, 0x02, 0xBE, 0xD3, 0x2D, 0x6E, 0x40, 0x0B, + 0x7A, 0xD3, 0x2D, 0x6E, 0xE4, 0x7A, 0xB3, 0x2D, 0x6F, 0x80, 0x3E, 0x7E, + 0xB3, 0x2D, 0x6F, 0x04, 0x7A, 0xB3, 0x2D, 0x6F, 0x7E, 0xB3, 0x2D, 0x6E, + 0xB4, 0x01, 0x13, 0x7E, 0x73, 0x2D, 0x6F, 0xBE, 0x70, 0x20, 0x40, 0x0A, + 0xE4, 0x7A, 0xB3, 0x2D, 0x6F, 0xE4, 0x7A, 0xB3, 0x2D, 0x6E, 0x7E, 0xB3, + 0x2D, 0x6E, 0xB4, 0x02, 0x14, 0x7E, 0x73, 0x2D, 0x6F, 0xBE, 0x70, 0x04, + 0x40, 0x0B, 0xE4, 0x7A, 0xB3, 0x2D, 0x6F, 0x74, 0x01, 0x7A, 0xB3, 0x2D, + 0x6E, 0xE4, 0x7A, 0xB3, 0x2D, 0x70, 0x7E, 0xB3, 0x2D, 0x6D, 0x60, 0x06, + 0x74, 0x01, 0x7A, 0xB3, 0x2D, 0x70, 0x7E, 0xB3, 0x2D, 0x6E, 0xB4, 0x01, + 0x06, 0x74, 0x02, 0x7A, 0xB3, 0x2D, 0x70, 0x7E, 0xB3, 0x2D, 0x6E, 0xB4, + 0x02, 0x06, 0x74, 0x03, 0x7A, 0xB3, 0x2D, 0x70, 0x7E, 0xB3, 0x2D, 0x82, + 0xC4, 0x54, 0x0F, 0x7C, 0xDB, 0xBE, 0xD0, 0x03, 0x50, 0x07, 0x7A, 0xD3, + 0x2D, 0x7E, 0x02, 0x3F, 0x04, 0x6C, 0xDD, 0x7E, 0xB3, 0x2D, 0x80, 0x60, + 0x03, 0x7E, 0xD0, 0x01, 0x7E, 0x37, 0x2D, 0xE1, 0x09, 0xB3, 0x00, 0x2F, + 0x60, 0x13, 0x7E, 0x37, 0x2D, 0xE1, 0x09, 0x73, 0x00, 0x2F, 0x0A, 0x37, + 0xBE, 0x37, 0x2D, 0x14, 0x38, 0x03, 0x7E, 0xD0, 0x01, 0x7E, 0x37, 0x2D, + 0xE1, 0x09, 0xB3, 0x00, 0x30, 0x60, 0x13, 0x7E, 0x37, 0x2D, 0xE1, 0x09, + 0x73, 0x00, 0x30, 0x0A, 0x37, 0xBE, 0x37, 0x2D, 0x14, 0x38, 0x03, 0x7E, + 0xD0, 0x02, 0xBE, 0xD3, 0x2D, 0x7E, 0x40, 0x0B, 0x7A, 0xD3, 0x2D, 0x7E, + 0xE4, 0x7A, 0xB3, 0x2D, 0x7F, 0x80, 0x3E, 0x7E, 0xB3, 0x2D, 0x7F, 0x04, + 0x7A, 0xB3, 0x2D, 0x7F, 0x7E, 0xB3, 0x2D, 0x7E, 0xB4, 0x01, 0x13, 0x7E, + 0x73, 0x2D, 0x7F, 0xBE, 0x70, 0x20, 0x40, 0x0A, 0xE4, 0x7A, 0xB3, 0x2D, + 0x7F, 0xE4, 0x7A, 0xB3, 0x2D, 0x7E, 0x7E, 0xB3, 0x2D, 0x7E, 0xB4, 0x02, + 0x14, 0x7E, 0x73, 0x2D, 0x7F, 0xBE, 0x70, 0x02, 0x40, 0x0B, 0xE4, 0x7A, + 0xB3, 0x2D, 0x7F, 0x74, 0x01, 0x7A, 0xB3, 0x2D, 0x7E, 0xE4, 0x7A, 0xB3, + 0x2D, 0x81, 0x7E, 0xB3, 0x2D, 0x80, 0x60, 0x06, 0x74, 0x01, 0x7A, 0xB3, + 0x2D, 0x81, 0x7E, 0xB3, 0x2D, 0x7E, 0xB4, 0x01, 0x06, 0x74, 0x02, 0x7A, + 0xB3, 0x2D, 0x81, 0x7E, 0xB3, 0x2D, 0x7E, 0xB4, 0x02, 0x06, 0x74, 0x03, + 0x7A, 0xB3, 0x2D, 0x81, 0x4D, 0x77, 0x78, 0x03, 0x02, 0x40, 0x61, 0x09, + 0x77, 0x00, 0x11, 0x7A, 0x73, 0x2D, 0x84, 0x09, 0xB7, 0x00, 0x12, 0x60, + 0x0A, 0x7E, 0x37, 0x2D, 0x87, 0x0B, 0x34, 0x7A, 0x37, 0x2D, 0x87, 0x09, + 0xB7, 0x00, 0x10, 0x60, 0x0A, 0x7E, 0x37, 0x2D, 0x85, 0x0B, 0x34, 0x7A, + 0x37, 0x2D, 0x85, 0x7D, 0x37, 0x7E, 0x24, 0x00, 0x16, 0x12, 0xF2, 0x4B, + 0x7E, 0xB3, 0x2D, 0x70, 0x70, 0x03, 0x02, 0x40, 0x11, 0xBE, 0xB0, 0x03, + 0x68, 0x04, 0x6C, 0x77, 0x80, 0x03, 0x7E, 0x70, 0x01, 0x0A, 0x27, 0x2E, + 0x27, 0x2D, 0xE1, 0x2E, 0x24, 0x00, 0x14, 0x7E, 0x29, 0x60, 0x19, 0x67, + 0x00, 0x02, 0x0A, 0x27, 0x2E, 0x27, 0x2D, 0xE1, 0x2E, 0x24, 0x00, 0x16, + 0x7E, 0x29, 0x60, 0x19, 0x67, 0x00, 0x05, 0x0A, 0x27, 0x2E, 0x27, 0x2D, + 0xE1, 0x2E, 0x24, 0x00, 0x18, 0x7E, 0x29, 0x60, 0x19, 0x67, 0x00, 0x06, + 0x0A, 0x27, 0x2E, 0x27, 0x2D, 0xE1, 0x2E, 0x24, 0x00, 0x1A, 0x7E, 0x29, + 0x60, 0x19, 0x67, 0x00, 0x07, 0x0A, 0x27, 0x2E, 0x27, 0x2D, 0xE1, 0x2E, + 0x24, 0x00, 0x1C, 0x7E, 0x29, 0x60, 0x19, 0x67, 0x00, 0x08, 0x0A, 0x37, + 0x2E, 0x37, 0x2D, 0xE1, 0x2E, 0x34, 0x00, 0x1E, 0x7E, 0x39, 0x70, 0x19, + 0x77, 0x00, 0x09, 0x7E, 0x37, 0x2D, 0xE1, 0x2E, 0x34, 0x00, 0x20, 0x7E, + 0x39, 0x70, 0x19, 0x77, 0x00, 0x0A, 0x7E, 0x37, 0x2D, 0xE1, 0x2E, 0x34, + 0x00, 0x21, 0x7E, 0x39, 0x70, 0x19, 0x77, 0x00, 0x0B, 0x7E, 0x37, 0x2D, + 0xE1, 0x2E, 0x34, 0x00, 0x22, 0x7E, 0x39, 0x70, 0x19, 0x77, 0x00, 0x0C, + 0x7E, 0x37, 0x2D, 0xE1, 0x2E, 0x34, 0x00, 0x23, 0x7E, 0x39, 0x70, 0x19, + 0x77, 0x00, 0x0D, 0x7E, 0x37, 0x2D, 0xE1, 0x2E, 0x34, 0x00, 0x24, 0x7E, + 0x39, 0x70, 0x19, 0x77, 0x00, 0x0E, 0x7E, 0x37, 0x2D, 0xE1, 0x2E, 0x34, + 0x00, 0x25, 0x7E, 0x39, 0x70, 0x19, 0x77, 0x00, 0x0F, 0x7E, 0xB3, 0x2C, + 0x8B, 0xB4, 0x01, 0x15, 0x7E, 0x73, 0x2D, 0x0B, 0x0A, 0x37, 0x09, 0xB3, + 0x2C, 0xC4, 0xBE, 0xB0, 0xFF, 0x68, 0x06, 0x74, 0x01, 0x19, 0xB7, 0x00, + 0x13, 0x7E, 0x73, 0x2D, 0x0B, 0x7A, 0x79, 0x70, 0x7E, 0x37, 0x2D, 0xE1, + 0x7E, 0x39, 0xB0, 0x30, 0xE1, 0x13, 0x7E, 0x73, 0x2D, 0x0B, 0x0A, 0x37, + 0x09, 0xB3, 0x2C, 0xC4, 0xB4, 0xFF, 0x06, 0x74, 0x01, 0x19, 0xB7, 0x00, + 0x01, 0x09, 0x77, 0x00, 0x15, 0x7A, 0x73, 0x2D, 0x7D, 0x7E, 0x73, 0x2D, + 0x7E, 0x19, 0x77, 0x00, 0x14, 0x7E, 0xB3, 0x2D, 0x70, 0xDA, 0x79, 0xDA, + 0xD8, 0x22, 0xCA, 0x3B, 0x7C, 0xFB, 0x7D, 0x63, 0xE4, 0x7A, 0xB3, 0x37, + 0x54, 0x7E, 0x73, 0x05, 0x1B, 0x7A, 0x73, 0x37, 0x4E, 0x7A, 0xB3, 0x37, + 0x4F, 0x7E, 0x73, 0x37, 0x4F, 0x1A, 0x27, 0x3E, 0x24, 0x49, 0x32, 0xC2, + 0x40, 0x59, 0x32, 0x03, 0xED, 0x7E, 0xB3, 0x37, 0x4F, 0x04, 0x7A, 0xB3, + 0x37, 0x4F, 0x7E, 0x73, 0x37, 0x4F, 0xBE, 0x70, 0x06, 0x48, 0xDE, 0x7C, + 0xEF, 0xBE, 0xE0, 0x00, 0x58, 0x03, 0x02, 0x41, 0x50, 0x7E, 0x73, 0x37, + 0x4E, 0xBC, 0x7E, 0x18, 0x03, 0x02, 0x41, 0x50, 0x7C, 0xBE, 0x7E, 0x08, + 0x37, 0x48, 0x9F, 0x11, 0x12, 0xE9, 0x55, 0x1A, 0x3E, 0x3E, 0x34, 0x49, + 0x33, 0xC0, 0x44, 0x7A, 0x37, 0x37, 0x52, 0x0A, 0x36, 0x7A, 0x73, 0x37, + 0x50, 0x1A, 0x37, 0x3E, 0x34, 0x2E, 0x37, 0x37, 0x48, 0x7A, 0x37, 0x37, + 0x48, 0x7E, 0x73, 0x37, 0x50, 0x1A, 0x37, 0x3E, 0x34, 0x2D, 0x63, 0x7E, + 0x37, 0x37, 0x52, 0x0A, 0x47, 0x7E, 0x73, 0x05, 0x1A, 0x0A, 0x57, 0x9D, + 0x54, 0x7C, 0xAB, 0x7A, 0xB3, 0x37, 0x51, 0x7C, 0xBE, 0x54, 0x03, 0x1A, + 0x2B, 0x7E, 0x34, 0x00, 0x44, 0xAD, 0x32, 0x2E, 0x34, 0xC1, 0x30, 0x7A, + 0x37, 0x37, 0x4A, 0x1A, 0x2A, 0x7E, 0x37, 0x37, 0x4A, 0x1B, 0x38, 0x20, + 0x7E, 0x37, 0x37, 0x4A, 0x0B, 0x35, 0x7A, 0x37, 0x37, 0x4A, 0x1A, 0x2E, + 0x7E, 0x37, 0x37, 0x4A, 0x1B, 0x38, 0x20, 0x7E, 0x37, 0x37, 0x4A, 0x0B, + 0x35, 0x7A, 0x37, 0x37, 0x4A, 0x74, 0x01, 0x7A, 0xB3, 0x37, 0x54, 0x7D, + 0x36, 0x7E, 0x27, 0x37, 0x48, 0x7E, 0x17, 0x37, 0x4A, 0x7E, 0xB3, 0x37, + 0x51, 0x12, 0xC2, 0x64, 0x1A, 0x3F, 0x1B, 0x35, 0x7C, 0xE7, 0xBE, 0xE0, + 0x00, 0x48, 0x54, 0x7E, 0x73, 0x37, 0x4E, 0xBC, 0x7E, 0x08, 0x4C, 0x7C, + 0xBE, 0x54, 0x03, 0x1A, 0x2B, 0x7E, 0x34, 0x00, 0x44, 0xAD, 0x32, 0x2E, + 0x34, 0xC1, 0x30, 0x7A, 0x37, 0x37, 0x4A, 0x1A, 0x2E, 0x3E, 0x24, 0x49, + 0x22, 0xC0, 0x44, 0x7A, 0x27, 0x37, 0x52, 0x0A, 0x24, 0x7C, 0x45, 0x7A, + 0x53, 0x37, 0x50, 0x0B, 0x38, 0x10, 0x7A, 0x33, 0x37, 0x51, 0x0B, 0x36, + 0x7A, 0x37, 0x37, 0x4A, 0x7E, 0xB3, 0x37, 0x54, 0x44, 0x02, 0x7A, 0xB3, + 0x37, 0x54, 0x7E, 0x37, 0x37, 0x4A, 0x7C, 0xBE, 0x7E, 0x53, 0x37, 0x51, + 0x12, 0xDC, 0x4E, 0x1A, 0x3F, 0x9E, 0x34, 0x00, 0x03, 0x7C, 0xE7, 0xBE, + 0xE0, 0x00, 0x58, 0x03, 0x02, 0x42, 0x87, 0x7E, 0x73, 0x37, 0x4E, 0xBC, + 0x7E, 0x18, 0x03, 0x02, 0x42, 0x87, 0x7C, 0xBE, 0x54, 0x03, 0x1A, 0x2B, + 0x7E, 0x34, 0x00, 0x44, 0xAD, 0x32, 0x2E, 0x34, 0xC1, 0x30, 0x7A, 0x37, + 0x37, 0x4A, 0x0B, 0x38, 0x20, 0x7A, 0x53, 0x37, 0x51, 0x0B, 0x36, 0x7A, + 0x37, 0x37, 0x4A, 0x7C, 0xBE, 0x9F, 0x00, 0x7E, 0x18, 0x37, 0x4C, 0x12, + 0xE9, 0x55, 0x1A, 0x3E, 0x3E, 0x34, 0x49, 0x33, 0xC0, 0x44, 0x7A, 0x37, + 0x37, 0x52, 0x0A, 0x36, 0x7A, 0x73, 0x37, 0x50, 0xE4, 0x80, 0x18, 0x6D, + 0x22, 0x7E, 0x37, 0x37, 0x4C, 0x1B, 0x38, 0x20, 0x7E, 0x37, 0x37, 0x4C, + 0x0B, 0x35, 0x7A, 0x37, 0x37, 0x4C, 0x7E, 0xB3, 0x37, 0x4F, 0x04, 0x7A, + 0xB3, 0x37, 0x4F, 0x7E, 0x53, 0x37, 0x50, 0xBE, 0x53, 0x37, 0x4F, 0x18, + 0xDA, 0x7E, 0x37, 0x37, 0x52, 0x0A, 0x37, 0x1A, 0x25, 0x9D, 0x32, 0x7A, + 0x73, 0x37, 0x50, 0xE4, 0x80, 0x1E, 0x6D, 0x22, 0x7E, 0x73, 0x37, 0x4F, + 0x1A, 0x17, 0x7E, 0x73, 0x37, 0x51, 0x1A, 0x37, 0x2D, 0x31, 0x3E, 0x34, + 0x2E, 0x37, 0x37, 0x4C, 0x1B, 0x38, 0x20, 0x7E, 0xB3, 0x37, 0x4F, 0x04, + 0x7A, 0xB3, 0x37, 0x4F, 0x7E, 0x73, 0x37, 0x50, 0xBE, 0x73, 0x37, 0x4F, + 0x18, 0xD4, 0x7E, 0xB3, 0x37, 0x54, 0x44, 0x04, 0x7A, 0xB3, 0x37, 0x54, + 0x7E, 0x37, 0x37, 0x4A, 0x7E, 0x27, 0x37, 0x4C, 0x7E, 0xB3, 0x37, 0x51, + 0x12, 0xF1, 0x84, 0x1A, 0x7F, 0x1B, 0x74, 0x7C, 0xEF, 0xBE, 0xE0, 0x00, + 0x48, 0x4F, 0x7E, 0x73, 0x37, 0x4E, 0xBC, 0x7E, 0x08, 0x47, 0x7C, 0xBE, + 0x12, 0xCC, 0x13, 0x7D, 0x23, 0x7C, 0xBE, 0x54, 0x03, 0x1A, 0x0B, 0x7E, + 0x14, 0x00, 0x44, 0xAD, 0x10, 0x7D, 0x31, 0x2E, 0x34, 0xC1, 0x30, 0x7A, + 0x37, 0x37, 0x4A, 0x1A, 0x1E, 0x3E, 0x14, 0x49, 0x11, 0xC0, 0x44, 0x7A, + 0x17, 0x37, 0x52, 0x0A, 0x12, 0x7C, 0x23, 0x7A, 0x33, 0x37, 0x50, 0x0B, + 0x38, 0x00, 0x7A, 0x13, 0x37, 0x51, 0x0B, 0x36, 0x7A, 0x37, 0x37, 0x4A, + 0x7C, 0xBE, 0x7E, 0x33, 0x37, 0x51, 0x12, 0x8E, 0x73, 0x7E, 0xB3, 0x37, + 0x54, 0x1A, 0x3B, 0x5E, 0x37, 0xFF, 0x00, 0x78, 0xF4, 0x30, 0xE0, 0x52, + 0x7E, 0x37, 0xFF, 0x16, 0x1A, 0x26, 0x1A, 0x24, 0x7A, 0x1F, 0xC2, 0x40, + 0x7E, 0x1F, 0xC2, 0x40, 0x5E, 0x34, 0x00, 0x20, 0x68, 0x0C, 0x7E, 0x1F, + 0xC2, 0x40, 0x4E, 0x34, 0xFF, 0xC0, 0x7A, 0x1F, 0xC2, 0x40, 0x7E, 0x1F, + 0xC2, 0x40, 0x7D, 0x03, 0x7E, 0x37, 0xFF, 0x14, 0x7D, 0x20, 0x7A, 0x1F, + 0xC2, 0x40, 0x7E, 0x37, 0xFF, 0x18, 0x7A, 0x37, 0xC2, 0x44, 0x7E, 0x37, + 0xFF, 0x1A, 0x7A, 0x37, 0xC2, 0x46, 0x7E, 0x37, 0xFF, 0x1C, 0x7A, 0x37, + 0xC2, 0x48, 0x7E, 0x37, 0xFF, 0x1E, 0x7A, 0x37, 0xC2, 0x4A, 0x7E, 0xB3, + 0x37, 0x54, 0x30, 0xE1, 0x08, 0x7E, 0x37, 0xFF, 0x58, 0x7A, 0x37, 0x03, + 0xE3, 0x7E, 0xB3, 0x37, 0x54, 0x30, 0xE2, 0x08, 0x7E, 0x37, 0xFF, 0x6C, + 0x7A, 0x37, 0x03, 0xEB, 0xDA, 0x3B, 0x22, 0xCA, 0x3B, 0x7C, 0xF4, 0x7C, + 0xE5, 0x7C, 0xAB, 0x7D, 0x63, 0x6C, 0x66, 0x6C, 0x22, 0x6C, 0x77, 0x74, + 0x01, 0x7A, 0xB3, 0x37, 0x2F, 0x7D, 0x26, 0x0B, 0x26, 0x7A, 0x27, 0x37, + 0x30, 0x6D, 0x22, 0x7A, 0x27, 0x37, 0x32, 0x30, 0x00, 0x05, 0x7E, 0x70, + 0x02, 0x80, 0x06, 0x6C, 0x77, 0x7E, 0x73, 0x18, 0xF8, 0x7A, 0x69, 0xA0, + 0x0A, 0x2E, 0x3E, 0x24, 0x2E, 0x24, 0x00, 0x03, 0x7C, 0xB5, 0x19, 0xB6, + 0x00, 0x01, 0x19, 0xF6, 0x00, 0x02, 0x19, 0x36, 0x00, 0x03, 0xBE, 0xA0, + 0x10, 0x68, 0x0B, 0x20, 0x00, 0x08, 0x7E, 0x69, 0xB0, 0x24, 0x80, 0x7A, + 0x69, 0xB0, 0x2E, 0xA0, 0xF6, 0x78, 0x03, 0x02, 0x45, 0x43, 0x2E, 0xA0, + 0xF8, 0x68, 0x79, 0x1B, 0xA0, 0x68, 0x57, 0x1B, 0xA1, 0x78, 0x03, 0x02, + 0x45, 0x0F, 0x1B, 0xA0, 0x78, 0x03, 0x02, 0x45, 0x6E, 0x2E, 0xA0, 0x06, + 0x68, 0x03, 0x02, 0x45, 0xCD, 0x6C, 0x66, 0x80, 0x12, 0x7E, 0x50, 0x02, + 0xAC, 0x56, 0x49, 0x02, 0x2C, 0x65, 0x2E, 0x27, 0x37, 0x30, 0x1B, 0x28, + 0x00, 0x0B, 0x60, 0xBC, 0xE6, 0x38, 0xEA, 0x30, 0x25, 0x12, 0x7E, 0x27, + 0x37, 0x30, 0x0B, 0x25, 0x0B, 0x28, 0x30, 0x4E, 0x60, 0x80, 0x1B, 0x28, + 0x30, 0x02, 0x45, 0xCD, 0x7E, 0x27, 0x37, 0x30, 0x0B, 0x25, 0x0B, 0x28, + 0x30, 0x5E, 0x60, 0x7F, 0x1B, 0x28, 0x30, 0x02, 0x45, 0xCD, 0xA5, 0xBF, + 0x02, 0x0E, 0x74, 0x02, 0x7C, 0x7F, 0x12, 0xB8, 0xCC, 0x7A, 0x37, 0x37, + 0x32, 0x02, 0x45, 0xCD, 0x7C, 0xBF, 0x12, 0xED, 0xD1, 0x7A, 0x37, 0x37, + 0x32, 0x02, 0x45, 0xCD, 0xE5, 0x59, 0x60, 0x05, 0xE5, 0x59, 0xB4, 0x02, + 0x1E, 0xA5, 0xBF, 0x02, 0x0E, 0x74, 0x04, 0x7C, 0x7F, 0x12, 0xB8, 0xCC, + 0x7A, 0x37, 0x37, 0x32, 0x02, 0x45, 0xCD, 0x7C, 0xBF, 0x12, 0xED, 0xF5, + 0x7A, 0x37, 0x37, 0x32, 0x02, 0x45, 0xCD, 0xA5, 0xBF, 0x02, 0x12, 0x7E, + 0x71, 0x5F, 0xAC, 0x7F, 0x3E, 0x34, 0x2E, 0x34, 0x18, 0xFE, 0x7A, 0x37, + 0x37, 0x32, 0x02, 0x45, 0xCD, 0xA5, 0xBF, 0x01, 0x20, 0x7E, 0x31, 0x5F, + 0xAC, 0x3F, 0x3E, 0x14, 0x7E, 0x73, 0x12, 0xE8, 0x0A, 0x27, 0x7E, 0x34, + 0x01, 0x80, 0xAD, 0x32, 0x2D, 0x31, 0x2E, 0x34, 0x12, 0xF1, 0x7A, 0x37, + 0x37, 0x32, 0x02, 0x45, 0xCD, 0x7E, 0x53, 0x2B, 0xAF, 0xBE, 0x50, 0x00, + 0x28, 0x4F, 0x7E, 0x27, 0x28, 0x1F, 0x7E, 0x07, 0x37, 0x30, 0x1B, 0x08, + 0x20, 0x7E, 0x07, 0x28, 0x19, 0x7E, 0x27, 0x37, 0x30, 0x59, 0x02, 0x00, + 0x02, 0x7E, 0x63, 0x2B, 0xB0, 0x0A, 0x06, 0x7E, 0x27, 0x37, 0x30, 0x59, + 0x02, 0x00, 0x04, 0x7E, 0x63, 0x2C, 0x84, 0x0A, 0x06, 0x7E, 0x27, 0x37, + 0x30, 0x59, 0x02, 0x00, 0x06, 0x7E, 0x60, 0x04, 0x80, 0x10, 0x6D, 0x00, + 0x7E, 0x50, 0x02, 0xAC, 0x56, 0x2E, 0x27, 0x37, 0x30, 0x1B, 0x28, 0x00, + 0x0B, 0x60, 0xBC, 0xE6, 0x38, 0xEC, 0x02, 0x45, 0xCD, 0x7E, 0x71, 0x5F, + 0xAC, 0x7F, 0x3E, 0x34, 0x2E, 0x34, 0x0E, 0x80, 0x7A, 0x37, 0x37, 0x32, + 0x02, 0x45, 0xCD, 0xA5, 0xBF, 0x02, 0x0E, 0x74, 0x08, 0x7C, 0x7F, 0x12, + 0xB8, 0xCC, 0x7A, 0x37, 0x37, 0x32, 0x02, 0x45, 0xCD, 0x7E, 0xB3, 0x12, + 0xEB, 0x60, 0x0E, 0x7E, 0x37, 0x37, 0x30, 0x7C, 0xBF, 0x7C, 0x5E, 0x12, + 0x7D, 0x9D, 0x02, 0x45, 0xCD, 0x74, 0x08, 0x7C, 0x7F, 0x12, 0xB8, 0xCC, + 0x7A, 0x37, 0x37, 0x32, 0x02, 0x45, 0xCD, 0xA5, 0xBF, 0x02, 0x02, 0x80, + 0x03, 0x02, 0x45, 0xCD, 0x74, 0x02, 0x7C, 0x73, 0x12, 0xB8, 0xCC, 0x7A, + 0x37, 0x37, 0x32, 0x7E, 0x71, 0x5F, 0x74, 0x02, 0xAC, 0x7B, 0x2E, 0x37, + 0x37, 0x32, 0x7A, 0x37, 0x37, 0x32, 0xE5, 0x60, 0x7A, 0xB3, 0x37, 0x2F, + 0x80, 0x5F, 0xA5, 0xBF, 0x02, 0x0D, 0x74, 0x20, 0x7C, 0x7F, 0x12, 0xB8, + 0xCC, 0x7A, 0x37, 0x37, 0x32, 0x80, 0x25, 0x4C, 0xFF, 0x68, 0x0B, 0xBE, + 0xF0, 0x01, 0x68, 0x06, 0x7E, 0xB3, 0x12, 0xEB, 0x70, 0x09, 0x12, 0xF1, + 0xB9, 0x7A, 0x37, 0x37, 0x32, 0x80, 0x0D, 0x7E, 0x37, 0x37, 0x30, 0x0A, + 0x5F, 0x1B, 0x55, 0x7C, 0x5E, 0x12, 0x7D, 0x9D, 0xBE, 0xF1, 0x40, 0x50, + 0x07, 0x74, 0x16, 0x7A, 0x69, 0xB0, 0x80, 0x12, 0x74, 0x17, 0x7A, 0x69, + 0xB0, 0x7D, 0x36, 0x0B, 0x35, 0x7E, 0x39, 0xB0, 0x9E, 0xB1, 0x40, 0x7A, + 0x39, 0xB0, 0x20, 0x00, 0x08, 0x7E, 0x69, 0xB0, 0x24, 0x80, 0x7A, 0x69, + 0xB0, 0xE4, 0x6D, 0x33, 0x7D, 0x26, 0x7D, 0x06, 0x7E, 0x17, 0x37, 0x30, + 0x9D, 0x10, 0x7C, 0xA3, 0x0A, 0x1A, 0x12, 0xAC, 0x00, 0x7C, 0x2B, 0x7E, + 0x27, 0x37, 0x32, 0x4D, 0x22, 0x68, 0x13, 0x7C, 0xB2, 0x7E, 0x37, 0x37, + 0x30, 0x7C, 0x3E, 0x7E, 0x23, 0x37, 0x2F, 0x12, 0xAC, 0x1E, 0x7C, 0x2B, + 0x80, 0x12, 0xE4, 0x6D, 0x33, 0x7D, 0x26, 0x09, 0xA6, 0x00, 0x01, 0x0A, + 0x1A, 0x0B, 0x14, 0x12, 0xAC, 0x00, 0x7C, 0x2B, 0x09, 0x36, 0x00, 0x01, + 0x0A, 0x33, 0x2D, 0x36, 0x19, 0x23, 0x00, 0x01, 0xDA, 0x3B, 0x22, 0xCA, + 0x3B, 0x7D, 0x73, 0x6D, 0xFF, 0x6D, 0x44, 0x6C, 0xDD, 0x7E, 0x73, 0x03, + 0xC0, 0xBE, 0x70, 0x20, 0x38, 0x03, 0x02, 0x46, 0xF7, 0x7E, 0xE7, 0x03, + 0x00, 0x7E, 0xD4, 0x03, 0x02, 0x7D, 0xC7, 0x6C, 0xCC, 0x02, 0x46, 0xD7, + 0x0B, 0xE8, 0x20, 0x0B, 0xC8, 0x30, 0x9D, 0x32, 0x7A, 0x37, 0x37, 0x45, + 0x1A, 0x26, 0x1A, 0x24, 0x7E, 0x33, 0x04, 0x34, 0x0A, 0x13, 0x6D, 0x00, + 0x12, 0x8C, 0xBA, 0x74, 0x06, 0x1E, 0x34, 0x0E, 0x24, 0x50, 0x03, 0x4E, + 0x60, 0x80, 0x14, 0x78, 0xF4, 0x7A, 0x37, 0x37, 0x45, 0x0B, 0xD8, 0xB0, + 0x7E, 0xB3, 0x05, 0x28, 0x60, 0x29, 0x7D, 0x3B, 0x1A, 0x26, 0x1A, 0x24, + 0x7E, 0x14, 0x00, 0x07, 0x12, 0x8C, 0xCB, 0x7E, 0x17, 0x37, 0x45, 0x1A, + 0x02, 0x1A, 0x00, 0x2F, 0x10, 0x74, 0x03, 0x1E, 0x34, 0x0E, 0x24, 0x50, + 0x03, 0x4E, 0x60, 0x80, 0x14, 0x78, 0xF4, 0x7D, 0xB3, 0x80, 0x1B, 0x7E, + 0x17, 0x37, 0x45, 0x1A, 0x02, 0x1A, 0x00, 0x7D, 0x3B, 0x1A, 0x26, 0x1A, + 0x24, 0x2F, 0x10, 0x1E, 0x34, 0x0E, 0x24, 0x50, 0x03, 0x4E, 0x60, 0x80, + 0x7D, 0xB3, 0x1B, 0xD8, 0xB0, 0xBD, 0xFB, 0x58, 0x04, 0x7D, 0xFB, 0x7C, + 0xDC, 0xBD, 0x4B, 0x08, 0x02, 0x7D, 0x4B, 0x0B, 0xD5, 0x0B, 0xE5, 0x0B, + 0xC5, 0x0B, 0xC0, 0x7E, 0x73, 0x05, 0x19, 0xBC, 0x7C, 0x28, 0x03, 0x02, + 0x46, 0x44, 0x7E, 0x73, 0x03, 0xBE, 0xBE, 0x70, 0xFF, 0x68, 0x12, 0x7C, + 0xD7, 0x74, 0x02, 0xAC, 0xBD, 0x49, 0xF5, 0x03, 0x02, 0x80, 0x06, 0x74, + 0xC8, 0x7A, 0xB3, 0x03, 0xBD, 0x7E, 0x73, 0x04, 0x36, 0x0A, 0x37, 0x7E, + 0x53, 0x04, 0x33, 0x0A, 0x25, 0x7E, 0xA3, 0x03, 0xCE, 0xBD, 0x2F, 0x58, + 0x12, 0x74, 0x0A, 0x7A, 0xB3, 0x03, 0xCF, 0x4C, 0xAA, 0x68, 0x1E, 0x74, + 0xFF, 0x7A, 0xB3, 0x03, 0xBE, 0x80, 0x16, 0x7E, 0xB3, 0x04, 0x48, 0x0A, + 0xEB, 0xBD, 0xEF, 0x58, 0x0C, 0x60, 0x0A, 0x7E, 0xB3, 0x04, 0x10, 0x20, + 0xE0, 0x03, 0x7E, 0xA0, 0x0C, 0x7E, 0xB3, 0x03, 0xCF, 0x70, 0x08, 0x7E, + 0xE7, 0x03, 0xB2, 0x4D, 0xEE, 0x68, 0x12, 0x6C, 0xAA, 0x7E, 0xB3, 0x04, + 0x48, 0x0A, 0xEB, 0xBD, 0xEF, 0x58, 0x06, 0x74, 0x0A, 0x7A, 0xB3, 0x03, + 0xCF, 0x7E, 0xB3, 0x03, 0xC8, 0x60, 0x02, 0x6C, 0xAA, 0xBE, 0xA0, 0x00, + 0x28, 0x0C, 0x1B, 0xA0, 0x2E, 0x34, 0x00, 0x03, 0x7E, 0xB3, 0x04, 0x48, + 0x0A, 0x2B, 0x7A, 0xA3, 0x03, 0xCE, 0xBD, 0x2F, 0x58, 0x60, 0xE4, 0x7A, + 0xB3, 0x04, 0x09, 0x7A, 0xB3, 0x03, 0xBD, 0x7E, 0x53, 0x03, 0xBE, 0xBC, + 0x5D, 0x68, 0x12, 0x7A, 0xD3, 0x03, 0xBE, 0x74, 0x01, 0x7A, 0xB3, 0x03, + 0xBF, 0x6D, 0x22, 0x7A, 0x27, 0x03, 0xB0, 0x80, 0x1C, 0x7E, 0x27, 0x03, + 0xB0, 0xBE, 0x24, 0x0F, 0xF0, 0x58, 0x06, 0x0B, 0x24, 0x7A, 0x27, 0x03, + 0xB0, 0xBE, 0x37, 0x03, 0xB0, 0x58, 0x06, 0x74, 0x02, 0x7A, 0xB3, 0x03, + 0xBF, 0x7E, 0x53, 0x04, 0x35, 0x0A, 0x25, 0x3E, 0x24, 0x3E, 0x24, 0x3E, + 0x24, 0x3E, 0x24, 0x7A, 0x27, 0x37, 0x45, 0xBE, 0x27, 0x03, 0xB0, 0x48, + 0x03, 0x02, 0x48, 0x5A, 0x12, 0xF4, 0xF6, 0x02, 0x48, 0x5A, 0x6D, 0x11, + 0x9D, 0x14, 0x7E, 0x53, 0x04, 0x33, 0x0A, 0x25, 0xBD, 0x12, 0x08, 0x0C, + 0x7E, 0xB3, 0x04, 0x09, 0xBE, 0xB0, 0x07, 0x50, 0x08, 0x04, 0x80, 0x01, + 0xE4, 0x7A, 0xB3, 0x04, 0x09, 0x7E, 0xB3, 0x03, 0xBD, 0xBE, 0xB0, 0xC8, + 0x50, 0x05, 0x04, 0x7A, 0xB3, 0x03, 0xBD, 0x7E, 0xA3, 0x03, 0xBF, 0xBE, + 0xA0, 0x01, 0x78, 0x02, 0x80, 0x28, 0xBE, 0xA0, 0x02, 0x78, 0x0E, 0x74, + 0x03, 0x7A, 0xB3, 0x03, 0xBF, 0x6D, 0x33, 0x7A, 0x37, 0x03, 0xB0, 0x80, + 0x20, 0xBE, 0xA0, 0x03, 0x78, 0x1B, 0x7E, 0x27, 0x03, 0xB0, 0x0B, 0x24, + 0x7A, 0x27, 0x03, 0xB0, 0xBE, 0x37, 0x03, 0xB0, 0x58, 0x0B, 0x74, 0xFF, + 0x7A, 0xB3, 0x03, 0xBE, 0xE4, 0x7A, 0xB3, 0x03, 0xBF, 0x7E, 0xB3, 0x03, + 0xBE, 0xB4, 0xFF, 0x0E, 0x7E, 0xB3, 0x03, 0xCF, 0xBE, 0xB0, 0x00, 0x28, + 0x05, 0x14, 0x7A, 0xB3, 0x03, 0xCF, 0x7E, 0xB3, 0x03, 0xBF, 0x70, 0x05, + 0xE4, 0x7A, 0xB3, 0x04, 0x0A, 0x7E, 0x73, 0x04, 0x2A, 0xBE, 0x73, 0x03, + 0xD1, 0x38, 0x0D, 0x7E, 0xB3, 0x04, 0x11, 0x30, 0xE2, 0x06, 0x74, 0x01, + 0x7A, 0xB3, 0x04, 0x0A, 0x7E, 0x73, 0x03, 0xBF, 0xBE, 0x70, 0x02, 0x40, + 0x09, 0x7E, 0xB3, 0x04, 0x0A, 0x60, 0x03, 0x12, 0xF4, 0x0B, 0x7E, 0x73, + 0x03, 0xBD, 0xBE, 0x70, 0x0A, 0x28, 0x2C, 0x6C, 0x22, 0x7E, 0x33, 0x03, + 0xC0, 0xBE, 0x30, 0x10, 0x50, 0x03, 0x7E, 0x20, 0x02, 0x7D, 0x37, 0x7E, + 0x27, 0x03, 0x00, 0x7E, 0xB3, 0x05, 0x19, 0x7E, 0x30, 0x01, 0x12, 0x96, + 0x96, 0x7E, 0xB3, 0x03, 0xC0, 0xBE, 0xB0, 0xC8, 0x50, 0x05, 0x04, 0x7A, + 0xB3, 0x03, 0xC0, 0x7E, 0x73, 0x03, 0xBF, 0xBE, 0x70, 0x02, 0x40, 0x06, + 0x7E, 0xB3, 0x03, 0xBE, 0x80, 0x02, 0x74, 0xFF, 0xDA, 0x3B, 0x22, 0xCA, + 0x3B, 0x74, 0x02, 0x7E, 0x34, 0x03, 0x00, 0x7E, 0x24, 0x0A, 0xBA, 0x12, + 0xD2, 0x81, 0x7F, 0x31, 0xBE, 0x38, 0x00, 0x00, 0x68, 0x0F, 0x74, 0x60, + 0x7A, 0xB3, 0x2C, 0x5E, 0x74, 0x43, 0x7A, 0xB3, 0x18, 0xF1, 0x02, 0x4B, + 0x65, 0x7E, 0x08, 0x03, 0x00, 0x7E, 0x34, 0x10, 0x00, 0x7E, 0x24, 0x02, + 0xD8, 0x12, 0xF0, 0x0A, 0x74, 0x02, 0x7E, 0x34, 0x03, 0x00, 0x7E, 0x24, + 0x02, 0xD8, 0x12, 0xD2, 0x81, 0x7F, 0x31, 0x74, 0x02, 0x7E, 0x34, 0x10, + 0x00, 0x7E, 0x24, 0x02, 0xD8, 0x12, 0xD2, 0x81, 0xBF, 0x31, 0x68, 0x0F, + 0x74, 0x60, 0x7A, 0xB3, 0x2C, 0x5E, 0x74, 0x43, 0x7A, 0xB3, 0x18, 0xF1, + 0x02, 0x4B, 0x65, 0x7E, 0x73, 0x10, 0x06, 0xBE, 0x70, 0x23, 0x40, 0x09, + 0x7E, 0x73, 0x10, 0x07, 0xBE, 0x70, 0x23, 0x28, 0x0F, 0x74, 0x60, 0x7A, + 0xB3, 0x2C, 0x5E, 0x74, 0x42, 0x7A, 0xB3, 0x18, 0xF1, 0x02, 0x4B, 0x65, + 0x7E, 0x34, 0x10, 0x00, 0x7A, 0x37, 0x2D, 0xD5, 0x49, 0x33, 0x00, 0x0E, + 0x2E, 0x34, 0x10, 0x00, 0x7A, 0x37, 0x2D, 0xD7, 0x7E, 0x37, 0x2D, 0xD5, + 0x49, 0x33, 0x00, 0x10, 0x2E, 0x34, 0x10, 0x00, 0x7A, 0x37, 0x2D, 0xD9, + 0x7E, 0x37, 0x2D, 0xD5, 0x49, 0x33, 0x00, 0x12, 0x2E, 0x34, 0x10, 0x00, + 0x7A, 0x37, 0x2D, 0xDB, 0x7E, 0x37, 0x2D, 0xD5, 0x49, 0x33, 0x00, 0x14, + 0x2E, 0x34, 0x10, 0x00, 0x7A, 0x37, 0x2D, 0xDD, 0x7E, 0x37, 0x2D, 0xD5, + 0x49, 0x33, 0x00, 0x16, 0x2E, 0x34, 0x10, 0x00, 0x7A, 0x37, 0x2D, 0xDF, + 0x7E, 0x37, 0x2D, 0xD5, 0x49, 0x33, 0x00, 0x18, 0x2E, 0x34, 0x10, 0x00, + 0x7A, 0x37, 0x2D, 0xE1, 0x7E, 0x37, 0x2D, 0xD5, 0x49, 0x33, 0x00, 0x1A, + 0x2E, 0x34, 0x10, 0x00, 0x7A, 0x37, 0x2D, 0xE3, 0x7E, 0x37, 0x2D, 0xD5, + 0x49, 0x33, 0x00, 0x1C, 0x2E, 0x34, 0x10, 0x00, 0x7A, 0x37, 0x2D, 0xE5, + 0x7E, 0x37, 0x2D, 0xD5, 0x49, 0x33, 0x00, 0x1E, 0x2E, 0x34, 0x10, 0x00, + 0x7A, 0x37, 0x2D, 0xE7, 0x7E, 0x37, 0x2D, 0xD5, 0x49, 0x33, 0x00, 0x20, + 0x2E, 0x34, 0x10, 0x00, 0x7A, 0x37, 0x2D, 0xE9, 0x7E, 0x37, 0x2D, 0xD5, + 0x49, 0x33, 0x00, 0x22, 0x2E, 0x34, 0x10, 0x00, 0x7A, 0x37, 0x2D, 0xEB, + 0x7E, 0x37, 0x2D, 0xD5, 0x49, 0x33, 0x00, 0x24, 0x2E, 0x34, 0x10, 0x00, + 0x7A, 0x37, 0x2D, 0xED, 0x7E, 0x37, 0x2D, 0xD9, 0x0B, 0x34, 0x7E, 0x39, + 0xB0, 0x1E, 0xB0, 0x1E, 0xB0, 0x13, 0x92, 0x13, 0x7E, 0x37, 0x2D, 0xD9, + 0x0B, 0x34, 0x7E, 0x39, 0xB0, 0x1E, 0xB0, 0x13, 0x92, 0x12, 0x7E, 0x37, + 0x2D, 0xD9, 0x0B, 0x34, 0x7E, 0x39, 0xB0, 0x13, 0x92, 0x11, 0x7E, 0x37, + 0x2D, 0xD5, 0x49, 0x33, 0x00, 0x28, 0x09, 0x73, 0x03, 0x0E, 0x7C, 0x47, + 0x6C, 0x55, 0x7E, 0x37, 0x2D, 0xD5, 0x49, 0x33, 0x00, 0x28, 0x09, 0x73, + 0x03, 0x0F, 0x0A, 0x37, 0x2D, 0x32, 0x7A, 0x37, 0x2D, 0x89, 0x7E, 0x37, + 0x2D, 0xD5, 0x49, 0x33, 0x00, 0x28, 0x09, 0x73, 0x03, 0x60, 0x7C, 0x47, + 0x6C, 0x55, 0x7E, 0x37, 0x2D, 0xD5, 0x49, 0x33, 0x00, 0x28, 0x09, 0x73, + 0x03, 0x61, 0x0A, 0x37, 0x2D, 0x32, 0x7A, 0x37, 0x2C, 0x79, 0x7E, 0x37, + 0x2D, 0xD9, 0x2E, 0x34, 0x00, 0x07, 0x7E, 0x39, 0x60, 0x7E, 0x70, 0x07, + 0xAC, 0x67, 0x2E, 0x34, 0x00, 0x14, 0x1B, 0x34, 0x7A, 0x73, 0x12, 0xEE, + 0x7E, 0x71, 0x5F, 0x3E, 0x70, 0x7A, 0x73, 0x2C, 0x58, 0x30, 0x12, 0x0A, + 0x7E, 0x73, 0x2C, 0x58, 0x3E, 0x70, 0x7A, 0x73, 0x2C, 0x58, 0x7E, 0xB3, + 0x2C, 0x58, 0x24, 0x5A, 0x7A, 0xB3, 0x2C, 0x58, 0x7E, 0x37, 0x2D, 0xD5, + 0x49, 0x33, 0x00, 0x28, 0x09, 0xB3, 0x03, 0x06, 0x13, 0x92, 0x03, 0x7E, + 0x37, 0x2D, 0xE9, 0x0B, 0x35, 0x0B, 0x38, 0x30, 0x5E, 0x34, 0x00, 0x01, + 0x2E, 0x34, 0xFF, 0xFF, 0x92, 0x05, 0x7E, 0x37, 0x2D, 0xD9, 0x7E, 0x39, + 0xB0, 0x1E, 0xB0, 0x1E, 0xB0, 0x13, 0x92, 0x0A, 0x7E, 0x37, 0x2D, 0xD9, + 0x7E, 0x39, 0xB0, 0xC4, 0x23, 0x13, 0x92, 0x0B, 0x7E, 0x37, 0x2D, 0xD9, + 0x7E, 0x39, 0xB0, 0xC4, 0x13, 0x92, 0x0C, 0x7E, 0x37, 0x2D, 0xD9, 0x7E, + 0x39, 0xB0, 0xC4, 0x03, 0x13, 0x92, 0x0D, 0x7E, 0x37, 0x2D, 0xD5, 0x49, + 0x13, 0x00, 0x26, 0x2E, 0x14, 0x03, 0x0E, 0x6D, 0x00, 0x7E, 0x34, 0x28, + 0x01, 0x7E, 0x24, 0x00, 0x18, 0x12, 0xF0, 0x0A, 0x7E, 0x37, 0x2D, 0xD5, + 0x49, 0x13, 0x00, 0x28, 0x2E, 0x14, 0x03, 0x3C, 0x6D, 0x00, 0x7E, 0x34, + 0x2C, 0x40, 0x7E, 0x24, 0x00, 0x18, 0x12, 0xF0, 0x0A, 0x7E, 0x37, 0x2D, + 0xE3, 0x2E, 0x34, 0x00, 0x0B, 0x7E, 0x39, 0xB0, 0x30, 0xE7, 0x03, 0xD3, + 0x80, 0x01, 0xC3, 0x92, 0x17, 0xDA, 0x3B, 0x22, 0xCA, 0x3B, 0x7E, 0xB3, + 0x03, 0xF9, 0xBE, 0xB0, 0x03, 0x78, 0x03, 0x02, 0x4D, 0xCB, 0x7E, 0xF3, + 0x03, 0xFA, 0xE4, 0x7A, 0xB3, 0x03, 0xFA, 0x6C, 0xEE, 0x1A, 0x3E, 0x09, + 0x73, 0x07, 0x27, 0x7A, 0x73, 0x37, 0x47, 0x1A, 0x2E, 0x7E, 0x34, 0x00, + 0x0E, 0xAD, 0x32, 0x7D, 0x63, 0x2E, 0x64, 0x08, 0x53, 0xE4, 0x7A, 0x69, + 0xB0, 0x7E, 0xB3, 0x37, 0x47, 0xBE, 0xB0, 0x01, 0x68, 0x08, 0xB4, 0x02, + 0x02, 0x80, 0x03, 0x02, 0x4D, 0xC1, 0x74, 0x01, 0x7A, 0x69, 0xB0, 0x1A, + 0x3E, 0x09, 0x73, 0x07, 0x45, 0xBE, 0x73, 0x04, 0x31, 0x40, 0x4B, 0x1A, + 0x3E, 0x09, 0xB3, 0x08, 0x49, 0x7A, 0xB3, 0x37, 0x4C, 0x20, 0xE6, 0x4C, + 0x7E, 0xB3, 0x37, 0x4C, 0x04, 0x7A, 0xB3, 0x37, 0x4C, 0x7E, 0xB3, 0x04, + 0x10, 0x20, 0xE3, 0x13, 0x7E, 0xB3, 0x03, 0xB7, 0x60, 0x09, 0x7E, 0x73, + 0x37, 0x4C, 0xBE, 0x70, 0x09, 0x40, 0x13, 0x74, 0xC0, 0x80, 0x0B, 0x7E, + 0x73, 0x37, 0x4C, 0xBE, 0x70, 0x03, 0x40, 0x06, 0x74, 0x40, 0x7A, 0xB3, + 0x37, 0x4C, 0x7E, 0x73, 0x37, 0x4C, 0x1A, 0x2E, 0x19, 0x72, 0x08, 0x49, + 0x80, 0x0E, 0x1A, 0x3E, 0x2E, 0x34, 0x08, 0x49, 0x7E, 0x39, 0xB0, 0x54, + 0xC0, 0x7A, 0x39, 0xB0, 0x1A, 0x3E, 0x09, 0x73, 0x07, 0x95, 0x7A, 0x73, + 0x37, 0x48, 0x1A, 0x37, 0x3E, 0x34, 0x3E, 0x34, 0x3E, 0x34, 0x3E, 0x34, + 0x2E, 0x34, 0x07, 0x9F, 0x7A, 0x37, 0x37, 0x45, 0x09, 0xB6, 0x00, 0x01, + 0x70, 0x06, 0x74, 0x01, 0x19, 0xB6, 0x00, 0x01, 0x09, 0xB6, 0x00, 0x01, + 0xB4, 0x01, 0x55, 0x09, 0xB6, 0x00, 0x02, 0x70, 0x4F, 0x7E, 0x73, 0x04, + 0x73, 0x5E, 0x70, 0x7C, 0x1E, 0x70, 0x1E, 0x70, 0x7A, 0x73, 0x37, 0x4B, + 0x4C, 0xFF, 0x68, 0x1C, 0x7E, 0x63, 0x37, 0x4B, 0x7E, 0x70, 0x03, 0xAC, + 0x67, 0x1E, 0x34, 0x1E, 0x34, 0x7A, 0x73, 0x37, 0x4B, 0x7E, 0xB3, 0x37, + 0x4B, 0x70, 0x05, 0x04, 0x7A, 0xB3, 0x37, 0x4B, 0x7E, 0x37, 0x37, 0x45, + 0x09, 0x73, 0x00, 0x04, 0xBE, 0x73, 0x37, 0x4B, 0x40, 0x12, 0x7E, 0xB3, + 0x37, 0x4B, 0x60, 0x0C, 0x74, 0x01, 0x19, 0xB6, 0x00, 0x02, 0x74, 0x02, + 0x19, 0xB6, 0x00, 0x01, 0x7E, 0xB3, 0x37, 0x47, 0xB4, 0x02, 0x3C, 0x09, + 0xB6, 0x00, 0x08, 0x70, 0x36, 0x74, 0x01, 0x19, 0xB6, 0x00, 0x08, 0x7E, + 0x37, 0x37, 0x45, 0x09, 0x73, 0x00, 0x0B, 0x19, 0x76, 0x00, 0x09, 0x7E, + 0x37, 0x37, 0x45, 0x09, 0x73, 0x00, 0x0C, 0x19, 0x76, 0x00, 0x0A, 0x7E, + 0x37, 0x37, 0x45, 0x09, 0x73, 0x00, 0x0D, 0x19, 0x76, 0x00, 0x0B, 0x7E, + 0x37, 0x37, 0x45, 0x09, 0x73, 0x00, 0x0E, 0x19, 0x76, 0x00, 0x0C, 0x1A, + 0x3E, 0x09, 0xB3, 0x08, 0x49, 0x60, 0x0C, 0x74, 0x02, 0x19, 0xB6, 0x00, + 0x02, 0x74, 0x03, 0x19, 0xB6, 0x00, 0x01, 0x7E, 0x37, 0x37, 0x45, 0x09, + 0xB3, 0x00, 0x0F, 0x30, 0xE7, 0x0D, 0x09, 0xB6, 0x00, 0x02, 0xB4, 0x01, + 0x06, 0x74, 0x02, 0x19, 0xB6, 0x00, 0x02, 0x7D, 0x36, 0x7E, 0x27, 0x37, + 0x45, 0x12, 0x60, 0x92, 0x09, 0xB6, 0x00, 0x01, 0xB4, 0x02, 0x02, 0x80, + 0x03, 0x02, 0x4D, 0xB4, 0x7E, 0xB3, 0x03, 0xF9, 0x70, 0x3B, 0x09, 0xB6, + 0x00, 0x08, 0x30, 0xE0, 0x40, 0x09, 0x66, 0x00, 0x0A, 0x7E, 0x27, 0x37, + 0x45, 0x09, 0x72, 0x00, 0x0B, 0xBC, 0x76, 0x38, 0x24, 0x09, 0x66, 0x00, + 0x09, 0x09, 0x72, 0x00, 0x0C, 0xBC, 0x76, 0x40, 0x18, 0x09, 0x66, 0x00, + 0x0C, 0x09, 0x72, 0x00, 0x0D, 0xBC, 0x76, 0x38, 0x0C, 0x09, 0x66, 0x00, + 0x0B, 0x09, 0x72, 0x00, 0x0E, 0xBC, 0x76, 0x50, 0x0C, 0x74, 0x80, 0x19, + 0xB6, 0x00, 0x02, 0x74, 0x01, 0x19, 0xB6, 0x00, 0x01, 0x7E, 0x73, 0x04, + 0x72, 0x0A, 0x37, 0x3E, 0x34, 0x0A, 0x37, 0x7A, 0x37, 0x37, 0x49, 0x4D, + 0x33, 0x68, 0x30, 0x7E, 0x37, 0x37, 0x45, 0x0B, 0x38, 0x30, 0xBE, 0x37, + 0x37, 0x49, 0x48, 0x23, 0x09, 0xB6, 0x00, 0x0D, 0xBE, 0xB0, 0x05, 0x50, + 0x0C, 0x7D, 0x36, 0x2E, 0x34, 0x00, 0x0D, 0x04, 0x7A, 0x39, 0xB0, 0x80, + 0x13, 0x74, 0x80, 0x19, 0xB6, 0x00, 0x02, 0x74, 0x01, 0x19, 0xB6, 0x00, + 0x01, 0x80, 0x05, 0xE4, 0x19, 0xB6, 0x00, 0x0D, 0x09, 0xB6, 0x00, 0x01, + 0x30, 0xE1, 0x06, 0x74, 0x01, 0x7A, 0xB3, 0x03, 0xFA, 0x0B, 0xE0, 0xBE, + 0xE0, 0x0A, 0x58, 0x03, 0x02, 0x4B, 0x81, 0xDA, 0x3B, 0x22, 0xCA, 0xF8, + 0x7E, 0x47, 0x03, 0xD5, 0x7E, 0xF7, 0x03, 0xD3, 0xBD, 0xF4, 0x08, 0x29, + 0x7D, 0x34, 0x1A, 0x26, 0x1A, 0x24, 0x7E, 0x14, 0x00, 0x03, 0x12, 0x8C, + 0xCB, 0x7F, 0x01, 0x7D, 0x3F, 0x1A, 0x26, 0x1A, 0x24, 0x2F, 0x10, 0x74, + 0x02, 0x1E, 0x34, 0x0E, 0x24, 0x50, 0x03, 0x4E, 0x60, 0x80, 0x14, 0x78, + 0xF4, 0x7D, 0x43, 0x80, 0x25, 0x7D, 0x3F, 0x1A, 0x26, 0x1A, 0x24, 0x7E, + 0x14, 0x00, 0x03, 0x12, 0x8C, 0xCB, 0x7D, 0x14, 0x1A, 0x02, 0x1A, 0x00, + 0x2F, 0x10, 0x74, 0x02, 0x1E, 0x34, 0x0E, 0x24, 0x50, 0x03, 0x4E, 0x60, + 0x80, 0x14, 0x78, 0xF4, 0x7D, 0x43, 0x7A, 0x47, 0x03, 0xD5, 0x7A, 0x47, + 0x03, 0xD3, 0x7E, 0x47, 0x03, 0xD7, 0x7D, 0x14, 0x1A, 0x08, 0x1A, 0x00, + 0x7E, 0x37, 0x03, 0xD9, 0x1A, 0x26, 0x1A, 0x24, 0x2F, 0x10, 0x1E, 0x34, + 0x0E, 0x24, 0x50, 0x03, 0x4E, 0x60, 0x80, 0x7A, 0x37, 0x03, 0xD7, 0x7A, + 0x37, 0x03, 0xD9, 0x7E, 0x47, 0x03, 0xD7, 0x7E, 0x73, 0x04, 0x2F, 0x0A, + 0x37, 0x7E, 0xB3, 0x04, 0x10, 0x20, 0xE0, 0x06, 0x7E, 0x73, 0x04, 0x59, + 0x0A, 0x37, 0x6D, 0x22, 0x9D, 0x23, 0xBD, 0x24, 0x08, 0x1A, 0x74, 0x01, + 0x7A, 0xB3, 0x03, 0xC2, 0x7E, 0x27, 0x03, 0xD5, 0x2D, 0x42, 0x6E, 0x34, + 0xFF, 0xFF, 0x0B, 0x34, 0xBD, 0x34, 0x08, 0x09, 0x74, 0x02, 0x80, 0x01, + 0xE4, 0x7A, 0xB3, 0x03, 0xC2, 0x7E, 0x73, 0x03, 0xC2, 0x4C, 0x77, 0x68, + 0x15, 0xBE, 0x70, 0x01, 0x28, 0x08, 0x7E, 0x34, 0x00, 0x1E, 0x7A, 0x37, + 0x03, 0xB4, 0x7E, 0x34, 0x00, 0x78, 0x7A, 0x37, 0x03, 0xB2, 0x7E, 0x37, + 0x03, 0xB2, 0xBE, 0x34, 0x00, 0x00, 0x08, 0x06, 0x1B, 0x34, 0x7A, 0x37, + 0x03, 0xB2, 0x7E, 0x37, 0x03, 0xB4, 0xBE, 0x34, 0x00, 0x00, 0x08, 0x06, + 0x1B, 0x34, 0x7A, 0x37, 0x03, 0xB4, 0x7E, 0xB3, 0x03, 0xB7, 0x70, 0x03, + 0xE4, 0x80, 0x07, 0x7E, 0xB3, 0x03, 0xCA, 0x12, 0xF4, 0xEA, 0x7A, 0xB3, + 0x03, 0xCA, 0x12, 0xF3, 0xCA, 0x12, 0xC7, 0x82, 0x12, 0xDD, 0x7E, 0x12, + 0x52, 0x56, 0x12, 0xE9, 0xB3, 0x12, 0xB1, 0xEB, 0x7E, 0xB3, 0x03, 0xBB, + 0x70, 0x1D, 0x7E, 0xB3, 0x03, 0xBC, 0x12, 0xF4, 0xEA, 0x7A, 0xB3, 0x03, + 0xBC, 0x7E, 0xB3, 0x03, 0xB8, 0x12, 0xF4, 0xEA, 0x7A, 0xB3, 0x03, 0xB8, + 0xE4, 0x7A, 0xB3, 0x03, 0xCB, 0x80, 0x09, 0xE4, 0x7A, 0xB3, 0x03, 0xBC, + 0x7A, 0xB3, 0x03, 0xB8, 0xE4, 0x7A, 0xB3, 0x03, 0xDD, 0x7A, 0xB3, 0x03, + 0xDE, 0x7A, 0xB3, 0x03, 0xDF, 0x7E, 0x73, 0x03, 0xB6, 0xBE, 0x70, 0x00, + 0x28, 0x15, 0x7E, 0x73, 0x04, 0x02, 0xBE, 0x70, 0x00, 0x08, 0x07, 0xE4, + 0x7A, 0xB3, 0x03, 0xB6, 0x80, 0x0D, 0x12, 0xCE, 0xAA, 0x80, 0x08, 0x7E, + 0x34, 0x00, 0x06, 0x7A, 0x37, 0x03, 0xC4, 0x12, 0xEE, 0x60, 0x12, 0xDD, + 0xC7, 0x7A, 0x73, 0x03, 0xB7, 0x7E, 0xB3, 0x04, 0x10, 0x30, 0xE5, 0x20, + 0x7E, 0xB3, 0x03, 0xE1, 0x60, 0x06, 0x74, 0x01, 0x7A, 0xB3, 0x03, 0xE2, + 0x7E, 0xB3, 0x03, 0xB7, 0x70, 0x0E, 0x7E, 0x73, 0x03, 0xB8, 0xBE, 0x70, + 0x09, 0x28, 0x05, 0xE4, 0x7A, 0xB3, 0x03, 0xE2, 0x7E, 0xB3, 0x04, 0x10, + 0x30, 0xE2, 0x3B, 0x7E, 0xB3, 0x03, 0xC2, 0xB4, 0x02, 0x0B, 0x7E, 0xB3, + 0x03, 0xC3, 0x12, 0xF4, 0xEA, 0x7C, 0xFB, 0x80, 0x02, 0x6C, 0xFF, 0x7E, + 0xB3, 0x04, 0x10, 0x30, 0xE1, 0x08, 0x7E, 0xB3, 0x03, 0xC8, 0x60, 0x02, + 0x6C, 0xFF, 0x7A, 0xF3, 0x03, 0xC3, 0x7E, 0xA0, 0x10, 0x7E, 0xB3, 0x04, + 0x6D, 0x30, 0xE2, 0x03, 0x7E, 0xA0, 0x08, 0xBC, 0xAF, 0x38, 0x03, 0x12, + 0xF4, 0xDE, 0xE4, 0x7A, 0xB3, 0x03, 0xBA, 0x7E, 0x73, 0x03, 0xBC, 0xBE, + 0x70, 0x0A, 0x28, 0x32, 0x7E, 0xB3, 0x03, 0xD2, 0x70, 0x1E, 0x7E, 0xB3, + 0x03, 0xB9, 0xBE, 0xB0, 0x00, 0x28, 0x07, 0x14, 0x7A, 0xB3, 0x03, 0xB9, + 0x80, 0x0E, 0x7E, 0xB3, 0x04, 0x0B, 0x60, 0x08, 0x7E, 0x73, 0x04, 0x37, + 0x7A, 0x73, 0x03, 0xB9, 0x7E, 0xB3, 0x03, 0xB9, 0x70, 0x0D, 0x74, 0x01, + 0x7A, 0xB3, 0x03, 0xBA, 0x80, 0x05, 0xE4, 0x7A, 0xB3, 0x03, 0xB9, 0x7E, + 0xB3, 0x05, 0x36, 0x60, 0x06, 0x74, 0x02, 0x7A, 0xB3, 0x04, 0x0F, 0x7E, + 0xB3, 0x04, 0x0F, 0x60, 0x05, 0x14, 0x7A, 0xB3, 0x04, 0x0F, 0xDA, 0xF8, + 0x22, 0xCA, 0xD8, 0xCA, 0x79, 0x7C, 0xD5, 0x7C, 0xE7, 0x7C, 0xFB, 0x7E, + 0x73, 0x2D, 0x02, 0xBC, 0x7F, 0x38, 0x03, 0x02, 0x52, 0x51, 0x7C, 0xBE, + 0x7C, 0x76, 0x12, 0xEA, 0x6C, 0x7A, 0x37, 0x37, 0x2F, 0x7C, 0xBE, 0x7C, + 0x7D, 0x12, 0xEA, 0x6C, 0x7D, 0xD3, 0xBE, 0xD7, 0x37, 0x2F, 0x28, 0x18, + 0x7D, 0xCD, 0x6E, 0xC7, 0x37, 0x2F, 0x7A, 0xC7, 0x37, 0x2F, 0x6E, 0xD7, + 0x37, 0x2F, 0x7D, 0xCD, 0x6E, 0xC7, 0x37, 0x2F, 0x7A, 0xC7, 0x37, 0x2F, + 0x7E, 0xC7, 0x37, 0x2F, 0x7D, 0x3C, 0x1E, 0x34, 0x1E, 0x34, 0x1E, 0x34, + 0x9D, 0xC3, 0x1E, 0xD4, 0x2D, 0xDC, 0xBE, 0xD7, 0x37, 0x2F, 0x28, 0x04, + 0x7A, 0xD7, 0x37, 0x2F, 0x7E, 0xC7, 0x2D, 0xE1, 0x09, 0x7C, 0x00, 0x03, + 0x0A, 0x17, 0x6D, 0x00, 0x7E, 0x37, 0x37, 0x2F, 0x6D, 0x22, 0x12, 0x8C, + 0xBA, 0x7C, 0x76, 0x7C, 0x65, 0x0A, 0x24, 0x7D, 0xC3, 0x7A, 0xC7, 0x37, + 0x2F, 0x0A, 0xCF, 0x2E, 0xC4, 0x2D, 0x50, 0x7E, 0xC9, 0xB0, 0x04, 0x7A, + 0xC9, 0xB0, 0x7E, 0xC7, 0x2D, 0xE1, 0x2E, 0xC4, 0x00, 0x08, 0x7E, 0xC9, + 0x70, 0x4C, 0x77, 0x68, 0x12, 0x0A, 0xC7, 0xBE, 0xC7, 0x37, 0x2F, 0x50, + 0x0A, 0x7E, 0xB3, 0x2D, 0x6C, 0x44, 0x01, 0x7A, 0xB3, 0x2D, 0x6C, 0x7E, + 0xC7, 0x2D, 0xE1, 0x2E, 0xC4, 0x00, 0x31, 0x7E, 0xC9, 0x70, 0x4C, 0x77, + 0x68, 0x0E, 0x0A, 0xC7, 0xBE, 0xC7, 0x37, 0x2F, 0x50, 0x06, 0x74, 0x3C, + 0x7A, 0xB3, 0x2D, 0x80, 0x74, 0x02, 0xAC, 0xBF, 0x49, 0xE5, 0x2D, 0x16, + 0x49, 0xF5, 0x2D, 0x32, 0x0A, 0xCF, 0x09, 0x9C, 0x2D, 0x5E, 0x7E, 0xE0, + 0x07, 0x7E, 0x80, 0x01, 0x7E, 0xA3, 0x2D, 0x10, 0x4C, 0xAA, 0x78, 0x02, + 0x6C, 0x99, 0x4C, 0xAA, 0x78, 0x15, 0x7E, 0x73, 0x2D, 0x4F, 0xBE, 0x70, + 0x80, 0x40, 0x0C, 0x7E, 0xB3, 0x2C, 0x8B, 0xBE, 0xB0, 0x03, 0x78, 0x03, + 0x02, 0x51, 0xD1, 0x7E, 0xB3, 0x2D, 0x4F, 0xBE, 0xB0, 0xFF, 0x50, 0x05, + 0x04, 0x7A, 0xB3, 0x2D, 0x4F, 0xE4, 0x7A, 0xB3, 0x2D, 0x4E, 0x7E, 0xD7, + 0x37, 0x2F, 0xBD, 0xDF, 0x28, 0x06, 0x7D, 0xFD, 0x6C, 0x99, 0x80, 0x7D, + 0x7C, 0x89, 0x4C, 0x88, 0x78, 0x03, 0x7E, 0x80, 0x01, 0x0A, 0xC8, 0x7E, + 0x54, 0x00, 0x08, 0x9D, 0x5C, 0x7C, 0xEB, 0x7D, 0x3F, 0x6D, 0x22, 0x0A, + 0x1E, 0x6D, 0x00, 0x12, 0x8C, 0xBA, 0x0A, 0x18, 0xAD, 0x1D, 0x6D, 0x00, + 0x2F, 0x10, 0x74, 0x03, 0x1E, 0x34, 0x1E, 0x24, 0x50, 0x03, 0x4E, 0x60, + 0x80, 0x14, 0x78, 0xF4, 0x7D, 0xF3, 0x7E, 0x57, 0x2D, 0xE1, 0x09, 0xB5, + 0x00, 0x0B, 0x60, 0x14, 0x7E, 0x57, 0x2D, 0xE1, 0x09, 0x75, 0x00, 0x0B, + 0x0A, 0x57, 0xBE, 0x57, 0x37, 0x2F, 0x50, 0x04, 0x6C, 0x99, 0x80, 0x29, + 0x7D, 0x5D, 0x3E, 0x54, 0x7E, 0x73, 0x2D, 0x04, 0x0A, 0xD7, 0x2D, 0xD5, + 0xBD, 0xDF, 0x38, 0x0E, 0x7E, 0x57, 0x2D, 0xE1, 0x09, 0x75, 0x00, 0x07, + 0x0A, 0x57, 0xBD, 0x5F, 0x28, 0x04, 0x6C, 0x99, 0x80, 0x07, 0xBE, 0x90, + 0x04, 0x50, 0x02, 0x0B, 0x90, 0x7E, 0xD7, 0x37, 0x2F, 0xBD, 0xDE, 0x28, + 0x04, 0x7D, 0xED, 0x80, 0x32, 0x7D, 0x3E, 0x6D, 0x22, 0x0A, 0x1E, 0x6D, + 0x00, 0x12, 0x8C, 0xBA, 0x0A, 0x18, 0xAD, 0x1D, 0x6D, 0x00, 0x2F, 0x10, + 0x74, 0x03, 0x1E, 0x34, 0x1E, 0x24, 0x50, 0x03, 0x4E, 0x60, 0x80, 0x14, + 0x78, 0xF4, 0x7D, 0xE3, 0xBD, 0xFE, 0x28, 0x0B, 0x7D, 0xEF, 0x7E, 0xB3, + 0x2D, 0x4E, 0x04, 0x7A, 0xB3, 0x2D, 0x4E, 0x7E, 0x83, 0x2D, 0x03, 0x0A, + 0x38, 0xBD, 0x3E, 0x28, 0x05, 0xE4, 0x7A, 0xB3, 0x2D, 0x4E, 0x74, 0x02, + 0xAC, 0xBF, 0x59, 0xE5, 0x2D, 0x16, 0x74, 0x02, 0xAC, 0xBF, 0x59, 0xF5, + 0x2D, 0x32, 0x0A, 0x3F, 0x19, 0x93, 0x2D, 0x5E, 0x7E, 0x73, 0x2D, 0x4E, + 0xBE, 0x70, 0x1C, 0x28, 0x14, 0x74, 0x0E, 0x7A, 0xB3, 0x2D, 0x4E, 0x7E, + 0x34, 0x2D, 0x32, 0x12, 0xEF, 0x08, 0x7E, 0x34, 0x2D, 0x16, 0x12, 0xEF, + 0x08, 0xDA, 0x79, 0xDA, 0xD8, 0x22, 0xCA, 0xD8, 0xCA, 0x79, 0x7E, 0x83, + 0x05, 0x1A, 0x7E, 0x93, 0x05, 0x1B, 0x7E, 0x37, 0x03, 0xEB, 0x7E, 0x27, + 0x03, 0xD7, 0x7E, 0xD3, 0x04, 0x30, 0x5E, 0xD0, 0x7F, 0x4D, 0x22, 0x68, + 0x4B, 0x4C, 0xDD, 0x68, 0x47, 0x7D, 0x32, 0x1A, 0x26, 0x1A, 0x24, 0x7E, + 0x33, 0x03, 0xE5, 0x0A, 0x13, 0x6D, 0x00, 0x12, 0x8C, 0xBA, 0x74, 0x06, + 0x1E, 0x34, 0x0E, 0x24, 0x50, 0x03, 0x4E, 0x60, 0x80, 0x14, 0x78, 0xF4, + 0x7D, 0x23, 0x1A, 0x26, 0x1A, 0x24, 0x1A, 0x1D, 0x1A, 0x02, 0x12, 0x8C, + 0xBA, 0x74, 0x05, 0x1E, 0x34, 0x0E, 0x24, 0x50, 0x03, 0x4E, 0x60, 0x80, + 0x14, 0x78, 0xF4, 0x7D, 0x53, 0x7E, 0x73, 0x04, 0x12, 0x0A, 0x77, 0x9D, + 0x75, 0x02, 0x53, 0x61, 0x7D, 0x73, 0x0E, 0x74, 0x7E, 0x27, 0x03, 0xE9, + 0xBD, 0x27, 0x08, 0x1C, 0x7E, 0xB3, 0x04, 0x11, 0x30, 0xE3, 0x15, 0x7E, + 0xB3, 0x05, 0x20, 0x20, 0xE4, 0x0E, 0x7E, 0x34, 0x00, 0x07, 0xAD, 0x32, + 0x2D, 0x73, 0x0E, 0x74, 0x0E, 0x74, 0x0E, 0x74, 0x7A, 0x77, 0x03, 0xE9, + 0x7E, 0xB3, 0x04, 0x10, 0x20, 0xE0, 0x1C, 0x7E, 0xB3, 0x03, 0xC8, 0x60, + 0x07, 0x7E, 0xB3, 0x04, 0x11, 0x30, 0xE4, 0x0F, 0x7E, 0x57, 0x03, 0xB2, + 0x4D, 0x55, 0x68, 0x0D, 0x7E, 0xB3, 0x04, 0x11, 0x20, 0xE5, 0x06, 0x74, + 0x0A, 0x7A, 0xB3, 0x03, 0xCD, 0x74, 0x01, 0x7A, 0xB3, 0x03, 0xCC, 0x7E, + 0xB3, 0x03, 0xCD, 0x60, 0x05, 0xE4, 0x7A, 0xB3, 0x03, 0xCC, 0x7E, 0x73, + 0x04, 0x12, 0x0A, 0x37, 0x7D, 0x23, 0x7E, 0xB3, 0x03, 0xCC, 0x60, 0x06, + 0x7E, 0x53, 0x04, 0x38, 0x0A, 0x25, 0xBD, 0x27, 0x08, 0x02, 0x7D, 0x72, + 0x7E, 0x53, 0x04, 0x13, 0x0A, 0x25, 0xBD, 0x27, 0x58, 0x02, 0x7D, 0x72, + 0x7E, 0xB3, 0x05, 0x20, 0x20, 0xE0, 0x03, 0x30, 0xE3, 0x0B, 0x7D, 0x73, + 0x30, 0xE3, 0x06, 0x7E, 0x73, 0x04, 0x38, 0x0A, 0x77, 0xE4, 0x6C, 0x77, + 0x6C, 0x66, 0x7C, 0x58, 0x7C, 0x49, 0x7D, 0x17, 0x12, 0x79, 0xFB, 0x7C, + 0xDB, 0x12, 0xE8, 0x91, 0x4C, 0xDD, 0x78, 0x40, 0x7E, 0xB3, 0x03, 0xCD, + 0xBE, 0xB0, 0x00, 0x28, 0x05, 0x14, 0x7A, 0xB3, 0x03, 0xCD, 0x7E, 0x73, + 0x04, 0x12, 0x0A, 0x77, 0x7E, 0xB3, 0x04, 0x10, 0x20, 0xE0, 0x0C, 0x7E, + 0xB3, 0x03, 0xCD, 0x70, 0x06, 0x7E, 0x73, 0x04, 0x38, 0x0A, 0x77, 0xBE, + 0x77, 0x03, 0xE9, 0x08, 0x06, 0x6D, 0x33, 0x7A, 0x37, 0x03, 0xE9, 0x7E, + 0xB3, 0x03, 0xFC, 0x60, 0x35, 0x14, 0x7A, 0xB3, 0x03, 0xFC, 0x80, 0x2E, + 0x7E, 0x73, 0x04, 0x6B, 0x7A, 0x73, 0x03, 0xC9, 0x7E, 0x73, 0x05, 0x29, + 0x4C, 0x77, 0x68, 0x04, 0x7A, 0x73, 0x03, 0xC9, 0x7E, 0xB3, 0x04, 0x32, + 0x60, 0x07, 0x7C, 0xBD, 0x12, 0x2C, 0x0E, 0x7C, 0xDB, 0x7E, 0xB3, 0x04, + 0x69, 0x60, 0x07, 0x7C, 0xBD, 0x12, 0x6A, 0x90, 0x7C, 0xDB, 0x7A, 0xD3, + 0x03, 0xBB, 0x7C, 0xBD, 0x12, 0x74, 0xC1, 0x7C, 0xBD, 0x12, 0x99, 0x34, + 0x7C, 0xBD, 0x12, 0x33, 0xDB, 0x7C, 0xBD, 0x12, 0xEF, 0x29, 0x7C, 0xBD, + 0x12, 0xAC, 0x97, 0x7C, 0xBD, 0x12, 0x6F, 0x0E, 0x7A, 0x73, 0x03, 0xB6, + 0x7E, 0x73, 0x03, 0xBF, 0xBE, 0x70, 0x02, 0x40, 0x10, 0x7E, 0xB3, 0x04, + 0x10, 0x30, 0xE6, 0x09, 0xE4, 0x7A, 0xB3, 0x03, 0xB6, 0x7A, 0xB3, 0x03, + 0xD1, 0x12, 0xB7, 0x97, 0xDA, 0x79, 0xDA, 0xD8, 0x22, 0xCA, 0x3B, 0x7F, + 0x31, 0x7A, 0xB3, 0x37, 0x45, 0x7A, 0x0F, 0x37, 0x41, 0x7E, 0x18, 0x3A, + 0x1B, 0x7A, 0x1F, 0x37, 0x4D, 0xE4, 0x7A, 0xB3, 0x37, 0x4B, 0x02, 0x55, + 0xED, 0x7E, 0x73, 0x37, 0x4B, 0x5E, 0x70, 0x01, 0x74, 0x14, 0xAC, 0xB7, + 0x7E, 0x0F, 0x37, 0x4D, 0x2D, 0x51, 0x7D, 0x40, 0x7A, 0x2F, 0x37, 0x51, + 0x0A, 0x37, 0x6D, 0x22, 0x9D, 0x23, 0x7E, 0x34, 0x00, 0x14, 0xAD, 0x32, + 0x2D, 0x31, 0x7D, 0x20, 0x2E, 0x34, 0x00, 0x14, 0x7A, 0x1F, 0x37, 0x55, + 0x7E, 0x34, 0x00, 0x80, 0x7A, 0x37, 0x37, 0x5B, 0xE4, 0x7A, 0xB3, 0x37, + 0x4C, 0x02, 0x55, 0xC9, 0x7E, 0x73, 0x37, 0x4B, 0x0A, 0x17, 0x7E, 0x1F, + 0x37, 0x41, 0x2D, 0x31, 0x7E, 0x1B, 0xB0, 0x7E, 0xA3, 0x37, 0x4C, 0x0A, + 0x3A, 0x2D, 0x37, 0x7D, 0x26, 0x7E, 0x1B, 0x70, 0x12, 0xE5, 0x97, 0x0A, + 0x3B, 0x7A, 0x37, 0x37, 0x59, 0xBE, 0x34, 0x00, 0x02, 0x40, 0x15, 0x7E, + 0x57, 0x37, 0x59, 0x0B, 0x54, 0x7E, 0x37, 0x37, 0x59, 0x60, 0x05, 0x3E, + 0x34, 0x14, 0x78, 0xFB, 0x7A, 0x37, 0x37, 0x59, 0x7E, 0x73, 0x37, 0x4C, + 0x0A, 0x27, 0x7E, 0x0F, 0x37, 0x47, 0x2D, 0x12, 0x7E, 0x0B, 0x60, 0x0A, + 0x16, 0x7E, 0x07, 0x37, 0x59, 0xAD, 0x10, 0x7A, 0x17, 0x37, 0x59, 0x7E, + 0x63, 0x37, 0x4B, 0xBE, 0x60, 0x00, 0x28, 0x40, 0xBE, 0x70, 0x00, 0x28, + 0x3B, 0x7E, 0x0F, 0x37, 0x51, 0x2D, 0x12, 0x1B, 0x14, 0x7E, 0x0B, 0x70, + 0x0A, 0x37, 0x7E, 0x0F, 0x37, 0x55, 0x2D, 0x12, 0x1B, 0x14, 0x7E, 0x0B, + 0x50, 0x0A, 0x25, 0x12, 0xF4, 0x7C, 0x7E, 0x53, 0x37, 0x4C, 0x0A, 0x25, + 0x7E, 0x0F, 0x37, 0x55, 0x2D, 0x12, 0x7E, 0x0B, 0x50, 0x0A, 0x25, 0x12, + 0xF4, 0x7C, 0x2E, 0x37, 0x37, 0x59, 0x7A, 0x37, 0x37, 0x59, 0x80, 0x58, + 0x7E, 0x73, 0x37, 0x4C, 0xBE, 0x70, 0x00, 0x28, 0x1D, 0x7E, 0x73, 0x37, + 0x4C, 0x0A, 0x17, 0x7E, 0x1F, 0x37, 0x51, 0x2D, 0x31, 0x1B, 0x34, 0x7E, + 0x1B, 0x70, 0x0A, 0x37, 0x2E, 0x37, 0x37, 0x59, 0x7A, 0x37, 0x37, 0x59, + 0x80, 0x32, 0x7E, 0x73, 0x37, 0x4B, 0xBE, 0x70, 0x00, 0x28, 0x1B, 0x7E, + 0x73, 0x37, 0x4C, 0x0A, 0x17, 0x7E, 0x1F, 0x37, 0x55, 0x2D, 0x31, 0x7E, + 0x1B, 0x70, 0x0A, 0x37, 0x2E, 0x37, 0x37, 0x59, 0x7A, 0x37, 0x37, 0x59, + 0x80, 0x0E, 0x7E, 0x37, 0x37, 0x59, 0xBE, 0x34, 0x00, 0x80, 0x40, 0x04, + 0x74, 0x80, 0x80, 0x7A, 0x7E, 0x34, 0x00, 0x80, 0x7E, 0x27, 0x37, 0x59, + 0x12, 0xF4, 0x7C, 0x7A, 0x37, 0x37, 0x59, 0x7C, 0x37, 0x7E, 0x23, 0x37, + 0x4C, 0x0A, 0x02, 0x7E, 0x1F, 0x37, 0x51, 0x2D, 0x30, 0x7A, 0x1B, 0x30, + 0x7E, 0x37, 0x37, 0x5B, 0x7E, 0x53, 0x37, 0x4C, 0x0A, 0x25, 0x7E, 0x0F, + 0x37, 0x51, 0x2D, 0x12, 0x7E, 0x0B, 0x50, 0x0A, 0x25, 0x12, 0xF4, 0x7C, + 0x7A, 0x37, 0x37, 0x5B, 0x7E, 0xB3, 0x37, 0x4C, 0x04, 0x7A, 0xB3, 0x37, + 0x4C, 0x7E, 0x73, 0x37, 0x46, 0xBE, 0x73, 0x37, 0x4C, 0x28, 0x03, 0x02, + 0x54, 0x88, 0x7E, 0x37, 0x37, 0x5B, 0xBE, 0x34, 0x00, 0x80, 0x40, 0x04, + 0x74, 0x80, 0x80, 0x1A, 0x7E, 0xB3, 0x37, 0x4B, 0x04, 0x7A, 0xB3, 0x37, + 0x4B, 0x7E, 0x73, 0x37, 0x45, 0xBE, 0x73, 0x37, 0x4B, 0x28, 0x03, 0x02, + 0x54, 0x49, 0x7E, 0x57, 0x37, 0x59, 0xDA, 0x3B, 0x22, 0x74, 0xFF, 0x7A, + 0xB3, 0x12, 0xE4, 0x74, 0xFF, 0x7A, 0xB3, 0x12, 0xDE, 0x12, 0xE0, 0xC1, + 0xE4, 0x12, 0xCB, 0xA2, 0x7E, 0x37, 0x2D, 0xE9, 0x0B, 0x36, 0x0B, 0x38, + 0x30, 0x7A, 0x37, 0xF1, 0x68, 0x7E, 0x37, 0x2D, 0xE9, 0x2E, 0x34, 0x00, + 0x06, 0x0B, 0x38, 0x20, 0x5E, 0x24, 0x00, 0x03, 0x5E, 0x24, 0x00, 0x03, + 0x7E, 0x37, 0xF3, 0x22, 0x5E, 0x70, 0xFC, 0x4D, 0x32, 0x7A, 0x37, 0xF3, + 0x22, 0x7E, 0x37, 0x2D, 0xD5, 0x49, 0x13, 0x00, 0x26, 0x2E, 0x14, 0x03, + 0x00, 0x6D, 0x00, 0x7E, 0x34, 0xF0, 0x4E, 0x7E, 0x24, 0x00, 0x8A, 0x12, + 0xEE, 0x3D, 0x7E, 0x37, 0x2D, 0xD5, 0x49, 0x13, 0x00, 0x28, 0x2E, 0x14, + 0x03, 0x00, 0x6D, 0x00, 0x7E, 0x34, 0xF2, 0x00, 0x7E, 0x24, 0x00, 0x35, + 0x12, 0xEE, 0x3D, 0x7E, 0x37, 0xF3, 0x12, 0x5E, 0x34, 0xF0, 0x00, 0x4E, + 0x60, 0x02, 0x7A, 0x37, 0xF3, 0x12, 0x7E, 0x34, 0x01, 0x35, 0x7A, 0x37, + 0xF3, 0x14, 0x7E, 0x37, 0x2D, 0xD5, 0x49, 0x13, 0x00, 0x2A, 0x2E, 0x14, + 0x03, 0x00, 0x6D, 0x00, 0x7E, 0x34, 0xE0, 0x00, 0x7E, 0x24, 0x03, 0x30, + 0x12, 0xEE, 0x3D, 0x7E, 0x34, 0x2B, 0xB1, 0x7E, 0x24, 0x00, 0x0E, 0x12, + 0xF2, 0x4B, 0x7E, 0x37, 0x2D, 0xD5, 0x49, 0x33, 0x00, 0x28, 0x49, 0x33, + 0x03, 0x36, 0x7A, 0x37, 0x2B, 0xBB, 0x7E, 0x37, 0x2D, 0xD5, 0x49, 0x33, + 0x00, 0x28, 0x49, 0x33, 0x03, 0x64, 0x7A, 0x37, 0x2B, 0xBD, 0x6D, 0x33, + 0x7E, 0x17, 0x2D, 0xED, 0x6D, 0x00, 0x7E, 0x24, 0x00, 0x25, 0x12, 0xE3, + 0xF8, 0x7E, 0x37, 0x2D, 0xE9, 0x2E, 0x34, 0x00, 0x08, 0x0B, 0x38, 0x30, + 0x5E, 0x60, 0xFB, 0x7A, 0x37, 0xF0, 0x20, 0x7E, 0x37, 0x2D, 0xE9, 0x2E, + 0x34, 0x00, 0x0C, 0x0B, 0x38, 0x30, 0x5E, 0x70, 0xF0, 0x7A, 0x37, 0xF0, + 0x26, 0x7E, 0x37, 0x2D, 0xE9, 0x2E, 0x34, 0x00, 0x0E, 0x0B, 0x38, 0x30, + 0x5E, 0x60, 0xC7, 0x7A, 0x37, 0xF0, 0x2A, 0xE5, 0x5F, 0x7C, 0x4B, 0x6C, + 0x55, 0x2E, 0x24, 0xC0, 0x00, 0xA2, 0x05, 0xE4, 0x33, 0x0A, 0x3B, 0x2D, + 0x32, 0x7A, 0x37, 0xF0, 0x4A, 0x7E, 0x71, 0x5E, 0x1E, 0x70, 0x0A, 0x57, + 0x7D, 0x25, 0x0B, 0x25, 0x3E, 0x24, 0x3E, 0x24, 0x3E, 0x24, 0x3E, 0x24, + 0xC4, 0x54, 0xF0, 0x7C, 0xAB, 0xE4, 0x7D, 0x35, 0x2E, 0x34, 0x02, 0x00, + 0x2D, 0x32, 0x7A, 0x37, 0xF0, 0x24, 0x7E, 0x37, 0xF0, 0x24, 0x7A, 0x37, + 0x28, 0x1B, 0x7E, 0x37, 0xF2, 0x64, 0x7A, 0x37, 0x18, 0xFA, 0x7E, 0x37, + 0x2D, 0xE9, 0x2E, 0x34, 0x00, 0x10, 0x0B, 0x38, 0x30, 0x7A, 0x37, 0xF2, + 0x66, 0x7E, 0x37, 0x2D, 0xE9, 0x2E, 0x34, 0x00, 0x12, 0x0B, 0x38, 0x30, + 0x7A, 0x37, 0xF2, 0x68, 0x7E, 0x37, 0x2D, 0xE9, 0x2E, 0x34, 0x00, 0x14, + 0x0B, 0x38, 0x30, 0x7A, 0x37, 0xF2, 0x6A, 0x7E, 0x37, 0x2D, 0xE9, 0x2E, + 0x34, 0x00, 0x16, 0x0B, 0x38, 0x30, 0x5E, 0x34, 0x07, 0x3F, 0x7A, 0x37, + 0x2B, 0xB3, 0x7E, 0x37, 0x2D, 0xE9, 0x0B, 0x35, 0x0B, 0x38, 0x50, 0x0A, + 0x5A, 0x23, 0x23, 0x7D, 0x25, 0x5E, 0x24, 0x00, 0x03, 0x3E, 0x24, 0x3E, + 0x24, 0x7E, 0x37, 0x2B, 0xBD, 0x5E, 0x70, 0xF3, 0x4D, 0x32, 0x7A, 0x37, + 0x2B, 0xBD, 0x12, 0xF4, 0xAE, 0x75, 0xEF, 0xF7, 0x22, 0xCA, 0x3B, 0x7C, + 0xD3, 0x7A, 0x43, 0x37, 0x69, 0x7A, 0x53, 0x37, 0x68, 0x7C, 0xCB, 0x7D, + 0x73, 0x0B, 0x78, 0x30, 0x1A, 0x26, 0x7D, 0x03, 0x49, 0x37, 0x00, 0x02, + 0x7D, 0x20, 0x7A, 0x1F, 0x37, 0x6A, 0x0B, 0x76, 0x0B, 0x78, 0x30, 0x1A, + 0x26, 0x7D, 0x03, 0x49, 0x37, 0x00, 0x02, 0x7D, 0x20, 0x7A, 0x1F, 0x37, + 0x6E, 0x0B, 0x76, 0x7E, 0x73, 0x04, 0x3F, 0x7A, 0x73, 0x37, 0x7B, 0x4C, + 0xD3, 0x68, 0x08, 0x7E, 0x73, 0x04, 0x3E, 0x7A, 0x73, 0x37, 0x7B, 0x0A, + 0x2C, 0x7E, 0x73, 0x37, 0x68, 0x0A, 0x37, 0x9D, 0x32, 0x7A, 0x73, 0x37, + 0x77, 0x4C, 0xCC, 0x68, 0x03, 0x02, 0x58, 0xAA, 0x0B, 0x78, 0x30, 0x7A, + 0x37, 0x37, 0x72, 0x6D, 0x33, 0x7A, 0x37, 0x37, 0x74, 0x7E, 0x73, 0x37, + 0x77, 0xBE, 0x70, 0x00, 0x28, 0x08, 0x49, 0x37, 0x00, 0x02, 0x7A, 0x37, + 0x37, 0x74, 0x7E, 0x73, 0x04, 0x40, 0x0A, 0x37, 0x3E, 0x34, 0x3E, 0x34, + 0x3E, 0x34, 0xBE, 0x37, 0x37, 0x72, 0x50, 0x06, 0x74, 0x40, 0x7A, 0xB3, + 0x03, 0xFC, 0x7E, 0x73, 0x37, 0x7B, 0x7A, 0x73, 0x37, 0x7A, 0x7E, 0xB3, + 0x03, 0xFC, 0x70, 0x05, 0xE4, 0x7A, 0xB3, 0x37, 0x7A, 0x7E, 0x73, 0x04, + 0x82, 0x7A, 0x73, 0x37, 0x76, 0x4C, 0xDD, 0x68, 0x08, 0x7E, 0x73, 0x04, + 0x84, 0x7A, 0x73, 0x37, 0x76, 0x7E, 0x37, 0x37, 0x72, 0x7E, 0x27, 0x37, + 0x74, 0x7E, 0xB3, 0x37, 0x76, 0x7E, 0x33, 0x37, 0x7A, 0x12, 0xCF, 0xD6, + 0x7A, 0x37, 0x37, 0x72, 0x7D, 0x13, 0x6D, 0x00, 0x7E, 0x1F, 0x37, 0x6E, + 0x2F, 0x10, 0x7A, 0x1F, 0x37, 0x6E, 0x7E, 0x73, 0x37, 0x69, 0xBE, 0x73, + 0x37, 0x68, 0x68, 0x03, 0x02, 0x59, 0x5F, 0x7E, 0x53, 0x37, 0x77, 0x7E, + 0x70, 0x02, 0xAC, 0x75, 0x2D, 0x37, 0x0B, 0x38, 0x10, 0x7A, 0x17, 0x37, + 0x72, 0x6D, 0x11, 0x7A, 0x17, 0x37, 0x74, 0xBE, 0x50, 0x00, 0x28, 0x08, + 0x49, 0x33, 0xFF, 0xFE, 0x7A, 0x37, 0x37, 0x74, 0x7E, 0x73, 0x04, 0x40, + 0x0A, 0x37, 0x3E, 0x34, 0x3E, 0x34, 0x3E, 0x34, 0xBE, 0x37, 0x37, 0x72, + 0x50, 0x06, 0x74, 0x40, 0x7A, 0xB3, 0x03, 0xFC, 0x7E, 0x73, 0x37, 0x7B, + 0x7A, 0x73, 0x37, 0x7A, 0x7E, 0xB3, 0x03, 0xFC, 0x70, 0x05, 0xE4, 0x7A, + 0xB3, 0x37, 0x7A, 0x7E, 0x73, 0x04, 0x83, 0x7A, 0x73, 0x37, 0x76, 0x4C, + 0xDD, 0x68, 0x08, 0x7E, 0x73, 0x04, 0x85, 0x7A, 0x73, 0x37, 0x76, 0x7E, + 0x37, 0x37, 0x72, 0x7E, 0x27, 0x37, 0x74, 0x7E, 0xB3, 0x37, 0x76, 0x7E, + 0x33, 0x37, 0x7A, 0x12, 0xCF, 0xD6, 0x7D, 0x53, 0x7A, 0x37, 0x37, 0x72, + 0x7E, 0x73, 0x37, 0x77, 0x0A, 0x37, 0x0B, 0x35, 0x1A, 0x26, 0x1A, 0x24, + 0x7D, 0x15, 0x12, 0x8C, 0xCB, 0x7F, 0x01, 0x7E, 0x1F, 0x37, 0x6A, 0x2F, + 0x10, 0x7A, 0x1F, 0x37, 0x6A, 0x7D, 0x15, 0x6D, 0x00, 0x7E, 0x1F, 0x37, + 0x6E, 0x2F, 0x10, 0x7A, 0x1F, 0x37, 0x6E, 0x7E, 0x0F, 0x37, 0x6E, 0xBE, + 0x08, 0x00, 0x00, 0x78, 0x04, 0x6D, 0x33, 0x80, 0x1D, 0x7E, 0x1F, 0x37, + 0x6A, 0x7C, 0x45, 0x7C, 0x56, 0x7C, 0x67, 0x6C, 0x77, 0x12, 0x8D, 0x27, + 0x7F, 0x01, 0x9E, 0x08, 0x01, 0x00, 0x6D, 0x22, 0x7C, 0x6C, 0x6C, 0x77, + 0x2F, 0x10, 0x7A, 0x37, 0x37, 0x78, 0xDA, 0x3B, 0x22, 0xCA, 0x3B, 0x7C, + 0xF5, 0x7D, 0x63, 0x7A, 0xB3, 0x05, 0x21, 0x7A, 0x53, 0x05, 0x22, 0xE4, + 0x7A, 0xB3, 0x03, 0xD2, 0x6D, 0x33, 0x7A, 0x37, 0x03, 0xD5, 0x7A, 0x37, + 0x03, 0xD7, 0x7A, 0x37, 0x03, 0xDB, 0x7A, 0xB3, 0x03, 0xD0, 0x7E, 0x73, + 0x05, 0x1B, 0x7A, 0x73, 0x37, 0x45, 0x6C, 0xEE, 0x80, 0x12, 0x0A, 0x3E, + 0x09, 0x73, 0x03, 0x12, 0xBE, 0x73, 0x03, 0xD0, 0x28, 0x04, 0x7A, 0x73, + 0x03, 0xD0, 0x0B, 0xE0, 0x7E, 0x73, 0x37, 0x45, 0xBC, 0x7E, 0x38, 0xE6, + 0x7E, 0x73, 0x04, 0x43, 0x0A, 0x37, 0x7E, 0xB3, 0x05, 0x20, 0x30, 0xE2, + 0x02, 0x6D, 0x33, 0x7D, 0x23, 0x3E, 0x24, 0x7E, 0x33, 0x04, 0x12, 0x0A, + 0x13, 0x2D, 0x12, 0x7E, 0x27, 0x03, 0xE3, 0x9D, 0x21, 0x7E, 0x33, 0x04, + 0x42, 0x0A, 0x43, 0x7E, 0xA3, 0x03, 0xE8, 0x7E, 0x17, 0x03, 0xC4, 0xBE, + 0x14, 0x00, 0x50, 0x50, 0x1B, 0x7E, 0xB3, 0x03, 0xB6, 0xB4, 0x01, 0x14, + 0xBE, 0x24, 0x00, 0x00, 0x08, 0x0E, 0x2D, 0x43, 0xBE, 0x44, 0x00, 0xFF, + 0x08, 0x14, 0x7E, 0x44, 0x00, 0xFF, 0x80, 0x0E, 0x4C, 0xAA, 0x68, 0x02, + 0x1B, 0xA0, 0x0A, 0x3A, 0xBD, 0x34, 0x58, 0x02, 0x7C, 0xA9, 0x74, 0x07, + 0xA4, 0x2D, 0x54, 0x0B, 0x56, 0x0E, 0x54, 0x0E, 0x54, 0x0E, 0x54, 0x7A, + 0xB3, 0x03, 0xE8, 0x7E, 0x73, 0x04, 0x13, 0x0A, 0x27, 0x3E, 0x24, 0x7E, + 0x73, 0x04, 0x14, 0x7E, 0x63, 0x04, 0x7E, 0x1A, 0x06, 0x0A, 0x17, 0x2D, + 0x10, 0x7A, 0x33, 0x03, 0xE6, 0x7E, 0x63, 0x04, 0x7F, 0x1A, 0x06, 0x0A, + 0x17, 0x2D, 0x10, 0x7A, 0x33, 0x03, 0xE7, 0xBE, 0x27, 0x03, 0xE3, 0x50, + 0x24, 0x7E, 0xB3, 0x04, 0x11, 0x30, 0xE0, 0x1D, 0x7E, 0xB3, 0x05, 0x20, + 0x20, 0xE1, 0x16, 0x7D, 0x32, 0x6D, 0x22, 0x7E, 0x33, 0x04, 0x14, 0x0A, + 0x13, 0x6D, 0x00, 0x12, 0x8C, 0xBA, 0x7E, 0x17, 0x03, 0xE3, 0x12, 0x8C, + 0xD4, 0x7E, 0x43, 0x03, 0xE5, 0xA5, 0xBC, 0x00, 0x04, 0x7E, 0x43, 0x04, + 0x14, 0x7E, 0x50, 0x03, 0xAC, 0x45, 0x0A, 0x37, 0x2D, 0x23, 0x2E, 0x24, + 0x00, 0x03, 0x1E, 0x24, 0x1E, 0x24, 0x7C, 0x45, 0x7A, 0x53, 0x03, 0xE5, + 0x7E, 0x53, 0x04, 0x14, 0x4C, 0x55, 0x68, 0x2D, 0x7C, 0x64, 0x6C, 0x77, + 0x0A, 0x25, 0x8D, 0x32, 0x4C, 0x77, 0x68, 0x21, 0x7E, 0xB3, 0x03, 0xE6, + 0xAC, 0xB7, 0x0A, 0x2A, 0x7A, 0xA3, 0x03, 0xE6, 0x7E, 0xB3, 0x03, 0xE7, + 0xAC, 0xB7, 0x0A, 0x2A, 0x7A, 0xA3, 0x03, 0xE7, 0x7C, 0xB7, 0x7E, 0x34, + 0xC0, 0x00, 0x12, 0xCA, 0xBF, 0x6D, 0x33, 0x7A, 0x37, 0x03, 0xE3, 0x7A, + 0x37, 0x03, 0xEB, 0x7E, 0xB3, 0x04, 0x0B, 0x60, 0x4D, 0x12, 0xC5, 0x7F, + 0x12, 0xD9, 0x83, 0x7E, 0x73, 0x05, 0x1B, 0x7A, 0x73, 0x37, 0x45, 0x6C, + 0xEE, 0x80, 0x1A, 0x7C, 0xBE, 0x7E, 0x08, 0x37, 0x46, 0x9F, 0x11, 0x12, + 0xE9, 0x55, 0x7D, 0x36, 0x7C, 0xBE, 0x12, 0x40, 0x6A, 0x1A, 0x3F, 0x3E, + 0x34, 0x2D, 0x63, 0x0B, 0xE0, 0x7E, 0xB3, 0x37, 0x45, 0xBC, 0xBE, 0x38, + 0xDE, 0x24, 0x03, 0x7A, 0xB3, 0x37, 0x45, 0x80, 0x09, 0x9F, 0x11, 0x7C, + 0xBE, 0x12, 0x40, 0x6A, 0x0B, 0xE0, 0x7E, 0x73, 0x37, 0x45, 0xBC, 0x7E, + 0x38, 0xEF, 0xDA, 0x3B, 0x22, 0xCA, 0x3B, 0x7C, 0xE7, 0x7C, 0xFB, 0x6C, + 0xDD, 0x7C, 0xBD, 0x12, 0xF1, 0xD2, 0x7A, 0x1F, 0x37, 0x38, 0x7E, 0x30, + 0x14, 0xAC, 0x3D, 0x2E, 0x14, 0x39, 0x47, 0x6D, 0x00, 0x0A, 0x3D, 0x09, + 0xB3, 0x39, 0x45, 0x7C, 0x7E, 0x12, 0xEF, 0x4A, 0x7E, 0x70, 0x14, 0xAC, + 0x7D, 0x09, 0x53, 0x39, 0x47, 0x7A, 0x53, 0x37, 0x31, 0x0A, 0x2D, 0x09, + 0x52, 0x39, 0x45, 0x0A, 0x25, 0x2D, 0x32, 0x09, 0x73, 0x39, 0x46, 0x7A, + 0x73, 0x37, 0x32, 0x02, 0x5C, 0x51, 0x7E, 0x0F, 0x37, 0x38, 0x7E, 0x0B, + 0xC0, 0x4C, 0xDD, 0x78, 0x09, 0x0A, 0x3C, 0x09, 0xB3, 0x3A, 0x49, 0x20, + 0xE0, 0x11, 0xBE, 0xD0, 0x01, 0x68, 0x03, 0x02, 0x5C, 0x3D, 0x0A, 0x3C, + 0x09, 0xB3, 0x3A, 0x49, 0x30, 0xE1, 0x7A, 0xBE, 0xC0, 0x03, 0x78, 0x48, + 0x7E, 0x63, 0x37, 0x31, 0x0A, 0x26, 0x7F, 0x20, 0x2D, 0x52, 0x29, 0x72, + 0x00, 0x02, 0xBE, 0x73, 0x37, 0x31, 0x78, 0x06, 0x7E, 0x73, 0x37, 0x31, + 0x80, 0x0A, 0x0A, 0x56, 0x7E, 0x24, 0x00, 0x07, 0x9D, 0x25, 0x7C, 0x75, + 0x7A, 0x73, 0x37, 0x30, 0x0A, 0x27, 0x2D, 0x12, 0x0B, 0x15, 0x7A, 0x0F, + 0x37, 0x33, 0x7C, 0xBD, 0x7C, 0x7C, 0x7E, 0x53, 0x37, 0x32, 0x7E, 0x40, + 0x08, 0x12, 0x94, 0xD3, 0x74, 0x09, 0x7A, 0xB3, 0x37, 0x37, 0x80, 0x16, + 0x7E, 0x1F, 0x37, 0x38, 0x0B, 0x35, 0x7A, 0x1F, 0x37, 0x33, 0x7E, 0x1F, + 0x37, 0x38, 0x29, 0x71, 0x00, 0x01, 0x7A, 0x73, 0x37, 0x37, 0x7C, 0xBD, + 0x7C, 0x7C, 0x7E, 0x63, 0x37, 0x31, 0x7E, 0x53, 0x37, 0x32, 0x7E, 0x0F, + 0x37, 0x33, 0x7E, 0x43, 0x37, 0x37, 0x12, 0x94, 0xD3, 0x7E, 0x0F, 0x37, + 0x38, 0x29, 0x70, 0x00, 0x01, 0x0A, 0x37, 0x0B, 0x35, 0x2D, 0x31, 0x7D, + 0x20, 0x7A, 0x1F, 0x37, 0x38, 0x7E, 0x1F, 0x37, 0x38, 0x7E, 0x1B, 0xB0, + 0xB4, 0x11, 0x02, 0x80, 0x03, 0x02, 0x5B, 0x9E, 0x0B, 0xD0, 0xBE, 0xD0, + 0x01, 0x38, 0x03, 0x02, 0x5B, 0x5D, 0x6C, 0x77, 0x0A, 0x27, 0x09, 0x32, + 0x3A, 0x49, 0xA5, 0xBB, 0x07, 0x77, 0x74, 0x02, 0xAC, 0xB7, 0x09, 0x65, + 0x3A, 0x5A, 0x0A, 0x06, 0x09, 0x65, 0x3A, 0x5B, 0x0A, 0x26, 0x2D, 0x20, + 0x7C, 0x65, 0x7C, 0xB7, 0x24, 0xF3, 0x68, 0x12, 0x14, 0x68, 0x14, 0x14, + 0x68, 0x16, 0x14, 0x68, 0x18, 0x0B, 0xB2, 0x78, 0x19, 0x7E, 0xC0, 0x02, + 0x80, 0x16, 0x7E, 0xC0, 0x08, 0x80, 0x11, 0x7E, 0xC0, 0x09, 0x80, 0x0C, + 0x7E, 0xC0, 0x0A, 0x80, 0x07, 0x7E, 0xC0, 0x0B, 0x80, 0x02, 0x7C, 0xC7, + 0x7E, 0x23, 0x3A, 0x43, 0xBC, 0x26, 0x28, 0x14, 0x7A, 0xF3, 0x3A, 0x45, + 0x7A, 0x63, 0x3A, 0x43, 0x74, 0x01, 0x7A, 0xB3, 0x3A, 0x44, 0x7A, 0xC3, + 0x39, 0x30, 0x80, 0x19, 0xBC, 0x26, 0x78, 0x15, 0xBE, 0xF3, 0x3A, 0x45, + 0x78, 0x0F, 0xBE, 0xC3, 0x39, 0x30, 0x68, 0x09, 0x7E, 0xB3, 0x3A, 0x44, + 0x04, 0x7A, 0xB3, 0x3A, 0x44, 0x0A, 0x27, 0x2E, 0x24, 0x3A, 0x49, 0x7C, + 0xB3, 0x54, 0x01, 0x7A, 0x29, 0xB0, 0x7E, 0x30, 0x80, 0x7E, 0x50, 0x02, + 0xAC, 0x57, 0x19, 0x32, 0x3A, 0x5A, 0x74, 0x80, 0x19, 0xB2, 0x3A, 0x5B, + 0x0B, 0x70, 0xBE, 0x70, 0x11, 0x50, 0x03, 0x02, 0x5C, 0x6C, 0xDA, 0x3B, + 0x22, 0xCA, 0x3B, 0x7D, 0x73, 0xE4, 0x6D, 0x33, 0x7D, 0x27, 0x09, 0xA7, + 0x00, 0x01, 0x0A, 0x1A, 0x0B, 0x14, 0x5E, 0x20, 0x00, 0x12, 0xAC, 0x00, + 0x09, 0xA7, 0x00, 0x01, 0x0A, 0x4A, 0x2D, 0x47, 0x09, 0x74, 0x00, 0x01, + 0xBC, 0xB7, 0x68, 0x05, 0x74, 0x81, 0x02, 0x5E, 0xD6, 0x7E, 0x79, 0xB0, + 0xB4, 0x01, 0x6D, 0x09, 0xD7, 0x00, 0x02, 0x5E, 0xD0, 0x1F, 0x7C, 0xCA, + 0x9E, 0xC0, 0x05, 0x49, 0x37, 0x00, 0x03, 0x7A, 0x37, 0x37, 0x2E, 0x4C, + 0xDD, 0x78, 0x18, 0x7D, 0x17, 0x2E, 0x14, 0x00, 0x06, 0x6D, 0x00, 0x0A, + 0x2C, 0x7E, 0x37, 0x37, 0x2E, 0x2E, 0x34, 0x00, 0x00, 0x12, 0xF0, 0x0A, + 0x02, 0x5E, 0xD5, 0xBE, 0xD0, 0x01, 0x78, 0x0E, 0x7D, 0x37, 0x7E, 0x27, + 0x37, 0x2E, 0x7C, 0xBC, 0x12, 0xEC, 0x7C, 0x02, 0x5E, 0xD5, 0xBE, 0xD0, + 0x04, 0x78, 0x0E, 0x7D, 0x37, 0x7E, 0x27, 0x37, 0x2E, 0x7C, 0xBC, 0x12, + 0xE6, 0xEB, 0x02, 0x5E, 0xD5, 0xBE, 0xD0, 0x05, 0x68, 0x03, 0x02, 0x5E, + 0xB5, 0xE4, 0x7D, 0x37, 0x7E, 0x27, 0x37, 0x2E, 0x7C, 0x3C, 0x12, 0x65, + 0xAC, 0x02, 0x5E, 0xD5, 0x7E, 0x79, 0xB0, 0xB4, 0x02, 0x02, 0x80, 0x03, + 0x02, 0x5E, 0x82, 0x09, 0xD7, 0x00, 0x02, 0x5E, 0xD0, 0x1F, 0x09, 0xC7, + 0x00, 0x05, 0x49, 0x37, 0x00, 0x03, 0x7A, 0x37, 0x37, 0x2E, 0x74, 0x82, + 0x7A, 0x79, 0xB0, 0x0A, 0x3C, 0x2E, 0x34, 0x00, 0x03, 0x19, 0x77, 0x00, + 0x01, 0x19, 0xD7, 0x00, 0x02, 0x19, 0xC7, 0x00, 0x03, 0x4C, 0xDD, 0x78, + 0x16, 0x7E, 0x17, 0x37, 0x2E, 0x2E, 0x14, 0x00, 0x00, 0x6D, 0x00, 0x0A, + 0x2C, 0x7D, 0x37, 0x0B, 0x36, 0x12, 0xF0, 0x0A, 0x02, 0x5E, 0xB9, 0xBE, + 0xD0, 0x01, 0x78, 0x0E, 0x7D, 0x37, 0x7E, 0x27, 0x37, 0x2E, 0x7C, 0xBC, + 0x12, 0xED, 0x1A, 0x02, 0x5E, 0xB9, 0xBE, 0xD0, 0x02, 0x78, 0x18, 0x7E, + 0x17, 0x37, 0x2E, 0x2E, 0x14, 0x00, 0x00, 0x7E, 0x04, 0x00, 0xFF, 0x0A, + 0x2C, 0x7D, 0x37, 0x0B, 0x36, 0x12, 0xF0, 0x0A, 0x02, 0x5E, 0xB9, 0xBE, + 0xD0, 0x03, 0x78, 0x20, 0x7E, 0x17, 0x37, 0x2E, 0x5E, 0x20, 0x0F, 0x1E, + 0x14, 0x3E, 0x14, 0x2E, 0x14, 0xE0, 0x00, 0x6D, 0x00, 0x7C, 0x7C, 0x1E, + 0x70, 0x0A, 0x27, 0x7D, 0x37, 0x0B, 0x36, 0x12, 0xEE, 0x3D, 0x80, 0x5D, + 0xBE, 0xD0, 0x04, 0x78, 0x0D, 0x7D, 0x37, 0x7E, 0x27, 0x37, 0x2E, 0x7C, + 0xBC, 0x12, 0xE8, 0xC4, 0x80, 0x4B, 0xBE, 0xD0, 0x05, 0x78, 0x42, 0x74, + 0x01, 0x7D, 0x37, 0x7E, 0x27, 0x37, 0x2E, 0x7C, 0x3C, 0x12, 0x65, 0xAC, + 0x80, 0x37, 0x7E, 0x79, 0xB0, 0xB4, 0x04, 0x0E, 0x09, 0xB7, 0x00, 0x02, + 0xB4, 0x02, 0x46, 0x7D, 0x37, 0x12, 0xB9, 0xFD, 0x80, 0x23, 0x7E, 0x79, + 0xB0, 0xB4, 0x05, 0x15, 0x09, 0xD7, 0x00, 0x02, 0x5E, 0xD0, 0x0F, 0xBE, + 0xD0, 0x01, 0x78, 0x0D, 0x7D, 0x37, 0x12, 0xE2, 0x87, 0x70, 0x0A, 0x80, + 0x24, 0x74, 0x80, 0x80, 0x21, 0x74, 0x82, 0x80, 0x1D, 0xE4, 0x6D, 0x33, + 0x7D, 0x27, 0x09, 0xA7, 0x00, 0x01, 0x0A, 0x1A, 0x0B, 0x14, 0x12, 0xAC, + 0x00, 0x09, 0xA7, 0x00, 0x01, 0x0A, 0x3A, 0x2D, 0x37, 0x19, 0xB3, 0x00, + 0x01, 0xE4, 0xDA, 0x3B, 0x22, 0xCA, 0x3B, 0x7D, 0x73, 0x7E, 0xC3, 0x2A, + 0x18, 0x7E, 0xB3, 0x28, 0x22, 0xB4, 0x01, 0x02, 0x80, 0x03, 0x02, 0x60, + 0x7F, 0x7E, 0xB3, 0x2C, 0x77, 0x70, 0x1F, 0xE5, 0x52, 0x7A, 0xB3, 0x2C, + 0x77, 0xE4, 0x7A, 0xB3, 0x2C, 0x85, 0xBE, 0xC0, 0x00, 0x28, 0x0F, 0x7C, + 0xBC, 0x20, 0xE7, 0x0A, 0x7C, 0x7C, 0x5E, 0x73, 0x2C, 0x77, 0x7A, 0x73, + 0x2C, 0x77, 0x7E, 0xD3, 0x2C, 0x77, 0x7C, 0xBD, 0x30, 0xE0, 0x1B, 0x7C, + 0xBD, 0x54, 0xFE, 0x7A, 0xB3, 0x2C, 0x77, 0x7D, 0x37, 0x74, 0x10, 0x7E, + 0x50, 0x09, 0x7E, 0x43, 0x2C, 0x77, 0x6C, 0x33, 0x12, 0x43, 0x63, 0x02, + 0x60, 0x6E, 0x7C, 0xBD, 0x30, 0xE1, 0x71, 0x7C, 0xBC, 0x30, 0xE7, 0x08, + 0x7C, 0xBC, 0x54, 0x7F, 0x7A, 0xB3, 0x2C, 0x85, 0x7E, 0xD1, 0x49, 0x30, + 0x05, 0x05, 0x30, 0x00, 0x02, 0x0B, 0xD0, 0x30, 0x05, 0x19, 0x7E, 0x73, + 0x2C, 0x85, 0xBE, 0x71, 0x49, 0x78, 0x10, 0x7D, 0x37, 0x74, 0x0A, 0x7E, + 0x51, 0x5A, 0x6C, 0x44, 0x6C, 0x33, 0x12, 0x43, 0x63, 0x80, 0x10, 0x7D, + 0x37, 0x74, 0x13, 0x7E, 0x51, 0x5F, 0x7E, 0x43, 0x2C, 0x85, 0x6C, 0x33, + 0x12, 0x43, 0x63, 0x7E, 0xB3, 0x2C, 0x85, 0x04, 0x7A, 0xB3, 0x2C, 0x85, + 0x7C, 0xBC, 0x30, 0xE7, 0x04, 0x7A, 0xD3, 0x2C, 0x85, 0xBE, 0xD3, 0x2C, + 0x85, 0x68, 0x03, 0x02, 0x60, 0x6E, 0x7E, 0xB3, 0x2C, 0x77, 0x54, 0xFD, + 0x7A, 0xB3, 0x2C, 0x77, 0xE4, 0x7A, 0xB3, 0x2C, 0x85, 0x02, 0x60, 0x6E, + 0x7E, 0xB3, 0x2C, 0x77, 0x30, 0xE2, 0x37, 0x7D, 0x37, 0x74, 0x12, 0x7E, + 0x51, 0x5F, 0x7E, 0x43, 0x2C, 0x85, 0x6C, 0x33, 0x12, 0x43, 0x63, 0x7E, + 0xB3, 0x2C, 0x85, 0x04, 0x7A, 0xB3, 0x2C, 0x85, 0x7E, 0x71, 0x43, 0xBE, + 0x73, 0x2C, 0x85, 0x68, 0x03, 0x02, 0x60, 0x6E, 0x7E, 0xB3, 0x2C, 0x77, + 0x54, 0xFB, 0x7A, 0xB3, 0x2C, 0x77, 0xE4, 0x7A, 0xB3, 0x2C, 0x85, 0x02, + 0x60, 0x6E, 0x7E, 0xB3, 0x2C, 0x77, 0x30, 0xE3, 0x33, 0x7D, 0x37, 0x74, + 0x15, 0x7E, 0x51, 0x5F, 0x7E, 0x43, 0x2C, 0x85, 0x6C, 0x33, 0x12, 0x43, + 0x63, 0x7E, 0xB3, 0x2C, 0x85, 0x04, 0x7A, 0xB3, 0x2C, 0x85, 0x7E, 0x73, + 0x2C, 0x85, 0xBE, 0x71, 0x48, 0x78, 0x5B, 0x7E, 0xB3, 0x2C, 0x77, 0x54, + 0xF7, 0x7A, 0xB3, 0x2C, 0x77, 0xE4, 0x7A, 0xB3, 0x2C, 0x85, 0x80, 0x4A, + 0x7E, 0xB3, 0x2C, 0x77, 0x30, 0xE5, 0x43, 0x7D, 0x37, 0x74, 0x16, 0x7E, + 0x51, 0x5F, 0x7E, 0x43, 0x2C, 0x85, 0x6C, 0x33, 0x12, 0x43, 0x63, 0x7E, + 0xB3, 0x2C, 0x85, 0x04, 0x7A, 0xB3, 0x2C, 0x85, 0x7E, 0xB3, 0x18, 0xF8, + 0xBE, 0xB0, 0x02, 0x68, 0x09, 0x20, 0x00, 0x06, 0xE5, 0x40, 0x7A, 0xB3, + 0x2C, 0x85, 0x7E, 0x73, 0x2C, 0x85, 0xBE, 0x71, 0x40, 0x78, 0x0F, 0x7E, + 0xB3, 0x2C, 0x77, 0x54, 0xDF, 0x7A, 0xB3, 0x2C, 0x77, 0xE4, 0x7A, 0xB3, + 0x2C, 0x85, 0x30, 0x00, 0x1E, 0x7E, 0xB3, 0x2C, 0x77, 0x70, 0x18, 0x74, + 0x02, 0x7A, 0xB3, 0x28, 0x22, 0x80, 0x10, 0xE4, 0x7A, 0x79, 0xB0, 0x74, + 0x01, 0x19, 0xB7, 0x00, 0x01, 0x74, 0x02, 0x19, 0xB7, 0x00, 0x02, 0xDA, + 0x3B, 0x22, 0xCA, 0x3B, 0x7D, 0x02, 0x7D, 0x13, 0x09, 0xB1, 0x00, 0x01, + 0x30, 0xE0, 0x24, 0x09, 0xB0, 0x00, 0x0B, 0x19, 0xB1, 0x00, 0x03, 0x09, + 0xB0, 0x00, 0x0C, 0x19, 0xB1, 0x00, 0x04, 0x09, 0xB0, 0x00, 0x0D, 0x19, + 0xB1, 0x00, 0x05, 0x09, 0xB0, 0x00, 0x0E, 0x19, 0xB1, 0x00, 0x06, 0xE4, + 0x02, 0x62, 0x3C, 0x09, 0xB1, 0x00, 0x07, 0x60, 0x03, 0x02, 0x62, 0x48, + 0x09, 0xD0, 0x00, 0x0B, 0x0A, 0x2D, 0x09, 0xB0, 0x00, 0x0C, 0x0A, 0x3B, + 0x9D, 0x32, 0x0B, 0x34, 0x7C, 0xC7, 0x09, 0xE0, 0x00, 0x0D, 0x4C, 0xEE, + 0x68, 0x39, 0x1B, 0xE0, 0x7E, 0x73, 0x05, 0x1A, 0x0A, 0x37, 0x1A, 0x2E, + 0xAD, 0x32, 0x1A, 0x4D, 0x2D, 0x43, 0x3E, 0x44, 0x2E, 0x47, 0x03, 0x10, + 0x6C, 0xFF, 0x6C, 0xAA, 0x80, 0x0F, 0x0B, 0x48, 0x30, 0xBE, 0x34, 0x00, + 0x00, 0x08, 0x02, 0x0B, 0xF0, 0x0B, 0x45, 0x0B, 0xA0, 0xBC, 0xCA, 0x18, + 0xED, 0x7C, 0xBC, 0x0E, 0xB0, 0xBC, 0xBF, 0x08, 0x02, 0x0B, 0xE0, 0x19, + 0xE1, 0x00, 0x05, 0x09, 0xE0, 0x00, 0x0E, 0x7E, 0xB3, 0x05, 0x1B, 0x0A, + 0x2B, 0x1B, 0x24, 0x1A, 0x3E, 0xBD, 0x32, 0x58, 0x39, 0x0B, 0xE0, 0x7E, + 0x73, 0x05, 0x1A, 0x0A, 0x37, 0x1A, 0x2E, 0xAD, 0x32, 0x1A, 0x4D, 0x2D, + 0x43, 0x3E, 0x44, 0x2E, 0x47, 0x03, 0x10, 0x6C, 0xFF, 0x6C, 0xAA, 0x80, + 0x0F, 0x0B, 0x48, 0x30, 0xBE, 0x34, 0x00, 0x00, 0x08, 0x02, 0x0B, 0xF0, + 0x0B, 0x45, 0x0B, 0xA0, 0xBC, 0xCA, 0x18, 0xED, 0x7C, 0xBC, 0x0E, 0xB0, + 0xBC, 0xBF, 0x08, 0x02, 0x1B, 0xE0, 0x19, 0xE1, 0x00, 0x06, 0x09, 0xE0, + 0x00, 0x0D, 0x0A, 0x3E, 0x09, 0xB0, 0x00, 0x0E, 0x0A, 0x6B, 0x9D, 0x63, + 0x0B, 0x64, 0x7C, 0xCD, 0x09, 0xD0, 0x00, 0x0B, 0x4C, 0xDD, 0x68, 0x42, + 0x1B, 0xD0, 0x7E, 0x73, 0x05, 0x1A, 0x0A, 0x37, 0x1A, 0x2E, 0xAD, 0x32, + 0x1A, 0x4D, 0x2D, 0x43, 0x3E, 0x44, 0x2E, 0x47, 0x03, 0x10, 0x6C, 0xFF, + 0x6C, 0xAA, 0x80, 0x18, 0x0B, 0x48, 0x30, 0xBE, 0x34, 0x00, 0x00, 0x08, + 0x02, 0x0B, 0xF0, 0x7E, 0x63, 0x05, 0x1A, 0x7E, 0x70, 0x02, 0xAC, 0x67, + 0x2D, 0x43, 0x0B, 0xA0, 0xBC, 0xCA, 0x18, 0xE4, 0x7C, 0xBC, 0x0E, 0xB0, + 0xBC, 0xBF, 0x08, 0x02, 0x0B, 0xD0, 0x19, 0xD1, 0x00, 0x03, 0x09, 0xD0, + 0x00, 0x0C, 0x7E, 0xB3, 0x05, 0x1A, 0x0A, 0x3B, 0x7D, 0x03, 0x1B, 0x04, + 0x1A, 0x2D, 0xBD, 0x20, 0x58, 0x3C, 0x0B, 0xD0, 0x1A, 0x2E, 0xAD, 0x32, + 0x1A, 0x4D, 0x2D, 0x43, 0x3E, 0x44, 0x2E, 0x47, 0x03, 0x10, 0x6C, 0xFF, + 0x6C, 0xAA, 0x80, 0x18, 0x0B, 0x48, 0x00, 0xBE, 0x04, 0x00, 0x00, 0x08, + 0x02, 0x0B, 0xF0, 0x7E, 0x03, 0x05, 0x1A, 0x7E, 0x10, 0x02, 0xAC, 0x01, + 0x2D, 0x40, 0x0B, 0xA0, 0xBC, 0xCA, 0x18, 0xE4, 0x7C, 0xBC, 0x0E, 0xB0, + 0xBC, 0xBF, 0x08, 0x02, 0x1B, 0xD0, 0x19, 0xD1, 0x00, 0x04, 0x7E, 0xB3, + 0x04, 0x73, 0x20, 0xE7, 0x15, 0x09, 0xB1, 0x00, 0x02, 0xB4, 0x02, 0x14, + 0x74, 0x02, 0x19, 0xB1, 0x00, 0x08, 0x74, 0x01, 0x19, 0xB1, 0x00, 0x07, + 0x80, 0x06, 0x74, 0x02, 0x19, 0xB1, 0x00, 0x08, 0xDA, 0x3B, 0x22, 0xCA, + 0x3B, 0x7D, 0x60, 0x7A, 0x17, 0x37, 0x5A, 0x7C, 0xE5, 0x7C, 0xFB, 0x7D, + 0x23, 0x7E, 0x29, 0x70, 0x7A, 0x73, 0x37, 0x60, 0x09, 0x72, 0x00, 0x01, + 0x7A, 0x73, 0x37, 0x61, 0x09, 0x72, 0x00, 0x02, 0x7A, 0x73, 0x37, 0x62, + 0x09, 0x72, 0x00, 0x03, 0x7A, 0x73, 0x37, 0x63, 0x7E, 0xB3, 0x04, 0x08, + 0x60, 0x03, 0x02, 0x63, 0x49, 0x7E, 0x63, 0x37, 0x60, 0x0A, 0x16, 0x7E, + 0x73, 0x37, 0x61, 0x0A, 0x27, 0x9D, 0x21, 0xBE, 0x24, 0x00, 0x01, 0x78, + 0x50, 0x1A, 0x1F, 0x7E, 0x73, 0x37, 0x62, 0x0A, 0x47, 0xAD, 0x14, 0x3E, + 0x14, 0x7E, 0x70, 0x02, 0xAC, 0x67, 0x2D, 0x31, 0x2E, 0x37, 0x03, 0x10, + 0x7D, 0x52, 0x0B, 0x54, 0x7E, 0xA3, 0x37, 0x63, 0x0A, 0x2A, 0x9D, 0x24, + 0x0B, 0x24, 0x7E, 0x40, 0x01, 0x7C, 0x3F, 0x12, 0x78, 0xB6, 0x7A, 0x37, + 0x37, 0x5E, 0x7E, 0x39, 0xB0, 0x60, 0x1A, 0x7E, 0x37, 0x37, 0x5E, 0x09, + 0x73, 0x00, 0x01, 0x0A, 0x27, 0x7E, 0x73, 0x37, 0x60, 0x0A, 0x37, 0x2D, + 0x32, 0x7A, 0x73, 0x37, 0x61, 0x7A, 0x73, 0x37, 0x60, 0x7E, 0x73, 0x37, + 0x62, 0x0A, 0x07, 0x7E, 0x73, 0x37, 0x63, 0x0A, 0x47, 0x9D, 0x40, 0xBE, + 0x44, 0x00, 0x01, 0x78, 0x50, 0x1A, 0x1F, 0xAD, 0x10, 0x3E, 0x14, 0x7E, + 0x53, 0x37, 0x60, 0x7E, 0x70, 0x02, 0xAC, 0x75, 0x2D, 0x31, 0x2E, 0x37, + 0x03, 0x10, 0x7D, 0x54, 0x0B, 0x54, 0x0A, 0x15, 0x7E, 0xA3, 0x37, 0x61, + 0x0A, 0x2A, 0x9D, 0x21, 0x0B, 0x24, 0x7C, 0x4F, 0x7E, 0x30, 0x01, 0x12, + 0x78, 0xB6, 0x7A, 0x37, 0x37, 0x5E, 0x7E, 0x39, 0xB0, 0x60, 0x1A, 0x7E, + 0x37, 0x37, 0x5E, 0x09, 0x73, 0x00, 0x01, 0x0A, 0x27, 0x7E, 0x73, 0x37, + 0x62, 0x0A, 0x37, 0x2D, 0x32, 0x7A, 0x73, 0x37, 0x63, 0x7A, 0x73, 0x37, + 0x62, 0x7E, 0xA3, 0x04, 0x08, 0x4C, 0xAA, 0x78, 0x14, 0x7E, 0xB3, 0x37, + 0x60, 0x0A, 0x2B, 0x7E, 0xB3, 0x37, 0x61, 0x0A, 0x3B, 0x9D, 0x32, 0xBE, + 0x34, 0x00, 0x01, 0x18, 0x21, 0x7E, 0xB3, 0x37, 0x60, 0xBE, 0xB0, 0x00, + 0x28, 0x05, 0x14, 0x7A, 0xB3, 0x37, 0x60, 0x1A, 0x3F, 0x1B, 0x34, 0x7E, + 0xB3, 0x37, 0x61, 0x0A, 0x4B, 0xBD, 0x43, 0x58, 0x05, 0x04, 0x7A, 0xB3, + 0x37, 0x61, 0x4C, 0xAA, 0x78, 0x14, 0x7E, 0x73, 0x37, 0x62, 0x0A, 0x27, + 0x7E, 0x73, 0x37, 0x63, 0x0A, 0x37, 0x9D, 0x32, 0xBE, 0x34, 0x00, 0x01, + 0x18, 0x21, 0x7E, 0xB3, 0x37, 0x62, 0xBE, 0xB0, 0x00, 0x28, 0x05, 0x14, + 0x7A, 0xB3, 0x37, 0x62, 0x1A, 0x2E, 0x1B, 0x24, 0x7E, 0xB3, 0x37, 0x63, + 0x0A, 0x3B, 0xBD, 0x32, 0x58, 0x05, 0x04, 0x7A, 0xB3, 0x37, 0x63, 0x1A, + 0x3F, 0x7E, 0x53, 0x37, 0x62, 0x0A, 0x25, 0xAD, 0x32, 0x7D, 0x23, 0x3E, + 0x24, 0x7E, 0x63, 0x37, 0x60, 0x7E, 0x70, 0x02, 0xAC, 0x67, 0x2D, 0x32, + 0x2E, 0x37, 0x03, 0x10, 0x7A, 0x67, 0x37, 0x64, 0x7E, 0x27, 0x37, 0x5C, + 0x7A, 0x27, 0x37, 0x66, 0x7E, 0xB3, 0x37, 0x60, 0x7E, 0x53, 0x37, 0x61, + 0x7E, 0x43, 0x37, 0x62, 0x7E, 0x33, 0x37, 0x63, 0x7E, 0x07, 0x37, 0x5A, + 0x12, 0x7F, 0xFA, 0xDA, 0x3B, 0x22, 0xCA, 0x3B, 0x7E, 0x37, 0x39, 0x39, + 0x2E, 0x37, 0x39, 0x3D, 0x1E, 0x34, 0x7A, 0x37, 0x37, 0x34, 0x7E, 0x37, + 0x39, 0x3B, 0x2E, 0x37, 0x39, 0x3F, 0x1E, 0x34, 0x7A, 0x37, 0x37, 0x36, + 0x7E, 0x37, 0x39, 0x3D, 0x9E, 0x37, 0x39, 0x39, 0x7E, 0x04, 0x00, 0x06, + 0x8D, 0x30, 0x7A, 0x37, 0x37, 0x38, 0x7E, 0x17, 0x39, 0x3F, 0x9E, 0x17, + 0x39, 0x3B, 0x8D, 0x10, 0x7A, 0x17, 0x37, 0x3A, 0x4D, 0x33, 0x68, 0x08, + 0x7E, 0x27, 0x37, 0x3A, 0x4D, 0x22, 0x78, 0x09, 0x74, 0x36, 0x7A, 0xB3, + 0x39, 0x2B, 0x02, 0x65, 0xA9, 0x7E, 0x37, 0x37, 0x38, 0x12, 0xF4, 0x7C, + 0x3E, 0x34, 0x7A, 0x37, 0x3A, 0x47, 0x9F, 0x33, 0x7E, 0x47, 0x39, 0x35, + 0x7E, 0xB3, 0x39, 0x46, 0x7E, 0x70, 0x02, 0xAC, 0xB7, 0x59, 0x45, 0x39, + 0x97, 0x7E, 0x47, 0x39, 0x37, 0x59, 0x45, 0x39, 0xC1, 0x6D, 0x33, 0x59, + 0x35, 0x39, 0xEB, 0x74, 0x09, 0x7A, 0xB3, 0x37, 0x31, 0xE4, 0x7A, 0xB3, + 0x37, 0x33, 0xE4, 0x7A, 0xB3, 0x37, 0x30, 0x80, 0x65, 0x7E, 0x03, 0x37, + 0x30, 0x7E, 0x10, 0x02, 0xAC, 0x01, 0x49, 0x30, 0x39, 0xEB, 0x6D, 0x22, + 0x2F, 0x31, 0x7E, 0x17, 0x37, 0x34, 0x7A, 0x17, 0x37, 0x3C, 0x7E, 0x17, + 0x37, 0x36, 0x7A, 0x17, 0x37, 0x3E, 0xE4, 0x7E, 0x37, 0x37, 0x38, 0x7E, + 0x27, 0x37, 0x3A, 0x49, 0x10, 0x39, 0x97, 0x49, 0x00, 0x39, 0xC1, 0x12, + 0xA8, 0x5E, 0x7A, 0xB3, 0x37, 0x32, 0xBE, 0xB3, 0x37, 0x31, 0x68, 0x1D, + 0x7E, 0xA3, 0x37, 0x32, 0x7E, 0x73, 0x37, 0x33, 0x7C, 0xB7, 0x04, 0x7A, + 0xB3, 0x37, 0x33, 0x0A, 0x37, 0x19, 0xA3, 0x39, 0x47, 0x7E, 0x73, 0x37, + 0x32, 0x7A, 0x73, 0x37, 0x31, 0x7E, 0xB3, 0x37, 0x30, 0x04, 0x7A, 0xB3, + 0x37, 0x30, 0x7E, 0x73, 0x39, 0x46, 0x0A, 0x27, 0x0B, 0x24, 0x7E, 0x73, + 0x37, 0x30, 0x0A, 0x37, 0xBD, 0x32, 0x48, 0x89, 0x7E, 0x73, 0x37, 0x33, + 0x7A, 0x73, 0x39, 0x45, 0xE4, 0x7A, 0xB3, 0x37, 0x30, 0x80, 0x24, 0x7E, + 0x53, 0x37, 0x33, 0x7C, 0x45, 0x1E, 0x40, 0x0A, 0x34, 0x2E, 0x34, 0x00, + 0x80, 0x0A, 0x25, 0x12, 0x8C, 0x88, 0x7C, 0xA7, 0x7E, 0xB3, 0x37, 0x30, + 0x0A, 0x4B, 0x19, 0xA4, 0x39, 0x6F, 0x04, 0x7A, 0xB3, 0x37, 0x30, 0x7E, + 0x73, 0x37, 0x33, 0xBE, 0x73, 0x37, 0x30, 0x38, 0xD2, 0xE4, 0x7A, 0xB3, + 0x37, 0x30, 0x80, 0x2E, 0x7E, 0xB3, 0x37, 0x30, 0x7E, 0x70, 0x02, 0xAC, + 0xB7, 0x49, 0x35, 0x39, 0xEB, 0x6D, 0x22, 0x74, 0x07, 0x2F, 0x11, 0x14, + 0x78, 0xFB, 0x7F, 0x03, 0x12, 0x8C, 0xD6, 0x7E, 0x63, 0x37, 0x30, 0x0A, + 0x26, 0x19, 0x72, 0x39, 0x83, 0x7E, 0xB3, 0x37, 0x30, 0x04, 0x7A, 0xB3, + 0x37, 0x30, 0x7E, 0x73, 0x39, 0x46, 0xBE, 0x73, 0x37, 0x30, 0x38, 0xC8, + 0x7E, 0x37, 0x3A, 0x15, 0x7E, 0x27, 0x3A, 0x17, 0x12, 0xF4, 0x7C, 0x7A, + 0x37, 0x3A, 0x15, 0x6D, 0x22, 0x74, 0x07, 0x2F, 0x11, 0x14, 0x78, 0xFB, + 0x7F, 0x03, 0x12, 0x8C, 0xD6, 0x7A, 0x37, 0x3A, 0x15, 0xDA, 0x3B, 0x22, + 0xCA, 0x3B, 0x7C, 0xE3, 0x7D, 0x62, 0x7A, 0x37, 0x37, 0x30, 0x7C, 0xFB, + 0x6D, 0x33, 0x7D, 0x26, 0x5E, 0x24, 0xF0, 0x00, 0x2E, 0x24, 0xF0, 0x00, + 0x78, 0x0E, 0x12, 0xF5, 0x8C, 0x5E, 0xC0, 0x0F, 0x2D, 0x63, 0x7D, 0x36, + 0x2E, 0x34, 0x00, 0x00, 0xBE, 0x64, 0x00, 0x80, 0x40, 0x03, 0x02, 0x67, + 0x2A, 0xBE, 0xE0, 0x01, 0x68, 0x03, 0x02, 0x67, 0x2A, 0x7E, 0x17, 0x37, + 0x30, 0x09, 0xA1, 0x00, 0x06, 0x1B, 0x64, 0x78, 0x03, 0x02, 0x66, 0xB3, + 0x1B, 0x64, 0x78, 0x03, 0x02, 0x66, 0xB9, 0x1B, 0x64, 0x78, 0x03, 0x02, + 0x66, 0xCD, 0x1B, 0x64, 0x78, 0x03, 0x02, 0x66, 0xD6, 0x1B, 0x65, 0x78, + 0x03, 0x02, 0x66, 0xDC, 0x1B, 0x65, 0x78, 0x03, 0x02, 0x66, 0xF0, 0x2E, + 0x64, 0xFF, 0xF6, 0x78, 0x03, 0x02, 0x66, 0xF6, 0x1B, 0x64, 0x78, 0x03, + 0x02, 0x66, 0xFC, 0x1B, 0x64, 0x78, 0x03, 0x02, 0x67, 0x10, 0x2E, 0x64, + 0xFF, 0xA4, 0x78, 0x03, 0x02, 0x67, 0x16, 0x1B, 0x64, 0x78, 0x03, 0x02, + 0x67, 0x21, 0x2E, 0x64, 0x00, 0x71, 0x68, 0x03, 0x02, 0x67, 0x2A, 0x4C, + 0xFF, 0x78, 0x62, 0xA2, 0x20, 0xE4, 0x33, 0xB4, 0x01, 0x02, 0x80, 0x03, + 0x02, 0x67, 0x2A, 0xE5, 0x59, 0xBE, 0xB1, 0x5B, 0x68, 0x03, 0x02, 0x67, + 0x2A, 0x7E, 0xB3, 0x2C, 0x64, 0xBE, 0xB3, 0x2C, 0x78, 0x68, 0x03, 0x02, + 0x67, 0x2A, 0xBE, 0xA3, 0x2C, 0x78, 0x78, 0x03, 0x02, 0x67, 0x2A, 0xBE, + 0xA0, 0xFF, 0x68, 0x24, 0xA2, 0x01, 0xE4, 0x33, 0x78, 0x09, 0x4C, 0xAA, + 0x68, 0x1A, 0xBE, 0xA0, 0x01, 0x68, 0x15, 0xB4, 0x01, 0x02, 0x80, 0x03, + 0x02, 0x67, 0x2A, 0xBE, 0xA0, 0x02, 0x68, 0x08, 0xBE, 0xA0, 0x03, 0x68, + 0x03, 0x02, 0x67, 0x2A, 0x7E, 0x34, 0x2C, 0x78, 0x74, 0xAA, 0x7A, 0xB3, + 0x2C, 0x64, 0x02, 0x67, 0x2A, 0x7E, 0x34, 0x2C, 0x64, 0x80, 0x77, 0x7E, + 0x34, 0x2A, 0x18, 0x80, 0x71, 0x4C, 0xFF, 0x78, 0x06, 0x7A, 0xA3, 0x2D, + 0x83, 0x80, 0x67, 0x7E, 0x53, 0x2D, 0x83, 0x19, 0x51, 0x00, 0x04, 0x80, + 0x5D, 0x20, 0x00, 0x5A, 0x7E, 0x34, 0x18, 0xF8, 0x80, 0x54, 0x7E, 0x34, + 0x12, 0xEB, 0x80, 0x4E, 0x4C, 0xFF, 0x78, 0x06, 0x7A, 0xA3, 0x2D, 0x82, + 0x80, 0x44, 0x7E, 0x53, 0x2D, 0x82, 0x19, 0x51, 0x00, 0x04, 0x80, 0x3A, + 0x7E, 0x34, 0x12, 0xDF, 0x80, 0x34, 0x7E, 0x34, 0x12, 0xE3, 0x80, 0x2E, + 0x7E, 0x34, 0x2B, 0xAF, 0x4C, 0xFF, 0x78, 0x26, 0xE4, 0x7A, 0xB3, 0x2B, + 0xB0, 0xE4, 0x7A, 0xB3, 0x2C, 0x84, 0x80, 0x1A, 0x7E, 0x34, 0x12, 0xE8, + 0x80, 0x14, 0xBE, 0xF0, 0x01, 0x78, 0x0F, 0x7E, 0x34, 0x18, 0xF1, 0x80, + 0x09, 0xBE, 0xF0, 0x01, 0x78, 0x04, 0x7E, 0x34, 0x00, 0x59, 0x4D, 0x33, + 0x68, 0x24, 0x4C, 0xFF, 0x78, 0x11, 0x7E, 0x17, 0x37, 0x30, 0x2E, 0x14, + 0x00, 0x06, 0x6D, 0x00, 0x0A, 0x2E, 0x12, 0xF0, 0x0A, 0x80, 0x0F, 0x7D, + 0x13, 0x6D, 0x00, 0x0A, 0x2E, 0x7E, 0x37, 0x37, 0x30, 0x0B, 0x36, 0x12, + 0xF0, 0x0A, 0xDA, 0x3B, 0x22, 0xCA, 0x3B, 0x7D, 0x73, 0x6C, 0xDD, 0x0A, + 0x3D, 0x09, 0xB3, 0x07, 0x27, 0x70, 0x03, 0x02, 0x68, 0xDE, 0xBE, 0xB0, + 0x05, 0x78, 0x03, 0x02, 0x68, 0xDE, 0x0A, 0x3D, 0x2D, 0x37, 0x7E, 0x39, + 0x70, 0x7A, 0x73, 0x37, 0x45, 0x7E, 0x73, 0x03, 0xB6, 0xBE, 0x73, 0x37, + 0x45, 0x38, 0x03, 0x02, 0x68, 0xDE, 0x7E, 0x63, 0x37, 0x45, 0x7E, 0x70, + 0x03, 0xAC, 0x67, 0x7A, 0x73, 0x37, 0x46, 0x7E, 0xB3, 0x37, 0x46, 0x7E, + 0x70, 0x02, 0xAC, 0xB7, 0x49, 0x45, 0x03, 0x52, 0x7A, 0x47, 0x37, 0x47, + 0x49, 0x45, 0x03, 0x54, 0x7A, 0x47, 0x37, 0x49, 0x49, 0x35, 0x03, 0x56, + 0x7A, 0x37, 0x37, 0x4B, 0x7C, 0xBD, 0x7E, 0x34, 0x37, 0x4D, 0x7E, 0x24, + 0x37, 0x4F, 0x12, 0xC8, 0x00, 0x7E, 0x37, 0x37, 0x47, 0x7E, 0x27, 0x37, + 0x49, 0x7E, 0x17, 0x37, 0x4D, 0x7E, 0x07, 0x37, 0x4F, 0x12, 0xF1, 0x4D, + 0x7A, 0x37, 0x37, 0x53, 0x7C, 0xCD, 0x3E, 0xC0, 0x3E, 0xC0, 0x74, 0x02, + 0xAC, 0xBC, 0x49, 0x25, 0x05, 0xA1, 0x7A, 0x27, 0x37, 0x55, 0x49, 0x25, + 0x05, 0xA3, 0x7A, 0x27, 0x37, 0x57, 0x49, 0x45, 0x05, 0xA5, 0x7A, 0x47, + 0x37, 0x59, 0x49, 0x15, 0x05, 0xA7, 0x7A, 0x17, 0x37, 0x5B, 0x2E, 0x27, + 0x37, 0x55, 0x2E, 0x27, 0x37, 0x59, 0x2E, 0x27, 0x37, 0x5B, 0x9D, 0x32, + 0x7A, 0x37, 0x37, 0x51, 0x9E, 0x37, 0x37, 0x55, 0x7A, 0x37, 0x37, 0x51, + 0x0A, 0x3D, 0x09, 0xB3, 0x08, 0x49, 0x60, 0x12, 0x7E, 0x37, 0x37, 0x51, + 0xBE, 0x34, 0x00, 0x00, 0x08, 0x08, 0x0E, 0x34, 0x0E, 0x34, 0x7A, 0x37, + 0x37, 0x51, 0x7E, 0xB3, 0x04, 0x2E, 0x0A, 0x3B, 0xBE, 0x37, 0x37, 0x51, + 0x58, 0x78, 0x60, 0x76, 0x0A, 0x3D, 0x09, 0xB3, 0x07, 0x27, 0xB4, 0x01, + 0x13, 0x7C, 0xBD, 0x7E, 0x37, 0x37, 0x47, 0x7E, 0x27, 0x37, 0x49, 0x7E, + 0x17, 0x37, 0x4B, 0x12, 0x71, 0xF4, 0x80, 0x7E, 0x7E, 0xB3, 0x05, 0x2E, + 0x60, 0x3D, 0x7E, 0xB3, 0x05, 0x2F, 0x60, 0x37, 0x7C, 0xBD, 0x7E, 0x34, + 0x37, 0x5D, 0x7E, 0x24, 0x37, 0x5F, 0x12, 0xED, 0x64, 0x7E, 0x37, 0x37, + 0x47, 0x7E, 0x27, 0x37, 0x5D, 0x12, 0xF2, 0xB9, 0x7E, 0x53, 0x05, 0x2E, + 0x0A, 0x25, 0xBD, 0x32, 0x58, 0x15, 0x7E, 0x37, 0x37, 0x49, 0x7E, 0x27, + 0x37, 0x5F, 0x12, 0xF2, 0xB9, 0x7E, 0x53, 0x05, 0x2F, 0x0A, 0x25, 0xBD, + 0x32, 0x48, 0x17, 0x74, 0x05, 0x7A, 0xB3, 0x03, 0xE0, 0x74, 0x01, 0x7A, + 0xB3, 0x0A, 0x9E, 0x74, 0xFF, 0x0A, 0x3D, 0x2D, 0x37, 0x7A, 0x39, 0xB0, + 0x80, 0x24, 0x7E, 0x47, 0x37, 0x53, 0x74, 0x02, 0xAC, 0xBC, 0x59, 0x45, + 0x05, 0xA1, 0x7E, 0x47, 0x37, 0x55, 0x59, 0x45, 0x05, 0xA3, 0x7E, 0x47, + 0x37, 0x57, 0x59, 0x45, 0x05, 0xA5, 0x7E, 0x37, 0x37, 0x59, 0x59, 0x35, + 0x05, 0xA7, 0x0B, 0xD0, 0xBE, 0xD0, 0x0A, 0x68, 0x03, 0x02, 0x67, 0x5B, + 0x7E, 0xB3, 0x03, 0xE0, 0x60, 0x05, 0x14, 0x7A, 0xB3, 0x03, 0xE0, 0xDA, + 0x3B, 0x22, 0xCA, 0x3B, 0x7C, 0xFB, 0x7E, 0x18, 0x3A, 0x7C, 0x7A, 0x1F, + 0x38, 0xFB, 0x7E, 0x18, 0x3A, 0x7C, 0x29, 0xB1, 0x00, 0x09, 0x70, 0x04, + 0xE4, 0x02, 0x6A, 0x8D, 0x6C, 0xEE, 0x29, 0xB1, 0x00, 0x0B, 0x60, 0x1C, + 0xE4, 0x39, 0xB1, 0x00, 0x0B, 0x74, 0x01, 0x7E, 0x0F, 0x38, 0xFB, 0x39, + 0xB0, 0x00, 0x0D, 0x74, 0x01, 0x7E, 0x0F, 0x38, 0xFB, 0x39, 0xB0, 0x00, + 0x0C, 0x02, 0x6A, 0x8B, 0xE4, 0x39, 0xB1, 0x00, 0x0F, 0x7E, 0x1F, 0x38, + 0xFB, 0x29, 0xB1, 0x00, 0x0C, 0xBE, 0xB0, 0x02, 0x50, 0x08, 0x2E, 0x34, + 0x00, 0x0C, 0x04, 0x7A, 0x1B, 0xB0, 0x7E, 0x0F, 0x38, 0xFB, 0x7F, 0x10, + 0x2E, 0x34, 0x00, 0x13, 0x2E, 0x14, 0x00, 0x53, 0x7D, 0x21, 0x7E, 0x14, + 0x00, 0x40, 0x12, 0xF3, 0x47, 0x7E, 0x0F, 0x38, 0xFB, 0x7F, 0x10, 0x2E, + 0x34, 0x00, 0x53, 0x2E, 0x14, 0x00, 0x93, 0x7D, 0x21, 0x7E, 0x14, 0x00, + 0x40, 0x12, 0xF3, 0x47, 0x7E, 0x1F, 0x38, 0xFB, 0x29, 0xB1, 0x00, 0x94, + 0x29, 0x71, 0x00, 0x10, 0x12, 0xF3, 0x80, 0x7C, 0x3B, 0x7E, 0x1F, 0x38, + 0xFB, 0x2E, 0x34, 0x00, 0x53, 0x7A, 0x1B, 0x30, 0x7E, 0x1F, 0x38, 0xFB, + 0x29, 0xC1, 0x00, 0x0D, 0x4C, 0xCC, 0x78, 0x62, 0x0A, 0x1F, 0x1B, 0x15, + 0x7C, 0xD3, 0x7C, 0xBD, 0x29, 0x71, 0x00, 0x10, 0x12, 0xF3, 0x80, 0x7C, + 0xFB, 0x7E, 0x1F, 0x38, 0xFB, 0x29, 0xB1, 0x00, 0x13, 0x7C, 0x7F, 0x12, + 0xF3, 0x6D, 0x7E, 0x1F, 0x38, 0xFB, 0x39, 0xB1, 0x00, 0x13, 0x7E, 0x1F, + 0x38, 0xFB, 0x29, 0xB1, 0x00, 0x53, 0x7C, 0x7F, 0x12, 0xF3, 0x6D, 0x7E, + 0x1F, 0x38, 0xFB, 0x39, 0xB1, 0x00, 0x53, 0x7E, 0x1F, 0x38, 0xFB, 0x39, + 0xD1, 0x00, 0x10, 0x7E, 0x1F, 0x38, 0xFB, 0x29, 0xD1, 0x00, 0x0D, 0x29, + 0x31, 0x00, 0x0C, 0xBE, 0x30, 0x02, 0x50, 0x03, 0x7E, 0xD0, 0xFF, 0x74, + 0x01, 0x39, 0xB1, 0x00, 0x0D, 0x7E, 0xE0, 0x01, 0x80, 0x55, 0x7E, 0x1F, + 0x38, 0xFB, 0x29, 0xB1, 0x00, 0x07, 0x60, 0x1E, 0x7C, 0xDC, 0x7E, 0xE0, + 0x01, 0x7E, 0x1F, 0x38, 0xFB, 0x2E, 0x34, 0x00, 0x0D, 0x7C, 0xBC, 0x04, + 0x7A, 0x1B, 0xB0, 0xE4, 0x7E, 0x1F, 0x38, 0xFB, 0x39, 0xB1, 0x00, 0x07, + 0x80, 0x2D, 0x7E, 0x1F, 0x38, 0xFB, 0x29, 0x71, 0x00, 0x0E, 0x4C, 0x77, + 0x68, 0x21, 0x7E, 0x0F, 0x38, 0xFB, 0x29, 0x60, 0x00, 0x13, 0x1A, 0x16, + 0x7E, 0x2F, 0x38, 0xFB, 0x29, 0x62, 0x00, 0x53, 0x1A, 0x26, 0x9D, 0x21, + 0xBE, 0x24, 0x00, 0x01, 0x78, 0x05, 0x7C, 0xD7, 0x7E, 0xE0, 0x01, 0xE4, + 0x7E, 0x1F, 0x38, 0xFB, 0x39, 0xB1, 0x00, 0x0E, 0x4C, 0xEE, 0x68, 0x23, + 0x7C, 0xBD, 0x12, 0xA9, 0xCC, 0x7C, 0xEB, 0xBE, 0xE0, 0x00, 0x58, 0x04, + 0x6C, 0xEE, 0x80, 0x13, 0x4C, 0xEE, 0x68, 0x0F, 0x74, 0x01, 0x7E, 0x1F, + 0x38, 0xFB, 0x39, 0xB1, 0x00, 0x08, 0x12, 0xC4, 0x78, 0x7C, 0xEB, 0x7C, + 0xBE, 0xDA, 0x3B, 0x22, 0xCA, 0x3B, 0x7C, 0xFB, 0x7E, 0x34, 0xC1, 0x50, + 0x7A, 0x37, 0x37, 0x45, 0x7A, 0xF3, 0x37, 0x4E, 0xE4, 0x7A, 0xB3, 0x37, + 0x4D, 0x7E, 0xB3, 0x03, 0xC9, 0xC4, 0x54, 0x0F, 0x7C, 0xEB, 0xBE, 0xE0, + 0x0F, 0x78, 0x05, 0x7E, 0xE0, 0x02, 0x80, 0x03, 0x2E, 0xE0, 0x03, 0xE4, + 0x02, 0x6C, 0x03, 0x7E, 0x37, 0x37, 0x45, 0x09, 0xB3, 0x00, 0x09, 0x60, + 0x03, 0x02, 0x6B, 0xF2, 0x09, 0x53, 0x00, 0x04, 0x0A, 0x25, 0x09, 0x33, + 0x00, 0x05, 0x0A, 0x13, 0x9D, 0x12, 0x0A, 0x2E, 0xBD, 0x12, 0x58, 0x17, + 0x09, 0x53, 0x00, 0x06, 0x0A, 0x25, 0x09, 0x33, 0x00, 0x07, 0x0A, 0x13, + 0x9D, 0x12, 0x0A, 0x2E, 0xBD, 0x12, 0x58, 0x03, 0x02, 0x6B, 0xF2, 0x09, + 0x53, 0x00, 0x08, 0xBE, 0x53, 0x04, 0x31, 0x40, 0x13, 0x7E, 0x53, 0x04, + 0x12, 0x1E, 0x50, 0x0A, 0x15, 0x49, 0x23, 0x00, 0x02, 0xBD, 0x21, 0x48, + 0x03, 0x02, 0x6B, 0xF2, 0x7D, 0x63, 0x49, 0x56, 0x00, 0x02, 0x7A, 0x57, + 0x37, 0x4F, 0x0B, 0x68, 0x40, 0x9D, 0x54, 0x7A, 0x57, 0x37, 0x4F, 0x7E, + 0x73, 0x04, 0x6A, 0x5E, 0x70, 0xF0, 0x1E, 0x70, 0x1E, 0x70, 0x0A, 0x57, + 0x7A, 0x57, 0x37, 0x54, 0x4D, 0x55, 0x78, 0x08, 0x7E, 0x54, 0x00, 0x14, + 0x7A, 0x57, 0x37, 0x54, 0x7E, 0x57, 0x37, 0x54, 0xBE, 0x57, 0x37, 0x4F, + 0x08, 0x03, 0x02, 0x6B, 0xF2, 0x7E, 0x33, 0x04, 0x69, 0x7A, 0x33, 0x37, + 0x53, 0x7E, 0x37, 0x37, 0x4F, 0x1A, 0x26, 0x1A, 0x24, 0x0A, 0x13, 0x6D, + 0x00, 0x12, 0x8C, 0xBA, 0x7C, 0x76, 0x7C, 0x65, 0x7A, 0x37, 0x37, 0x51, + 0x7D, 0x34, 0x2E, 0x37, 0x37, 0x51, 0x7A, 0x37, 0x37, 0x51, 0x09, 0x76, + 0x00, 0x04, 0x7A, 0x73, 0x37, 0x48, 0x09, 0x66, 0x00, 0x05, 0x0A, 0x26, + 0x1A, 0x17, 0x9D, 0x21, 0x0B, 0x24, 0x7A, 0x53, 0x37, 0x4A, 0x09, 0x66, + 0x00, 0x06, 0x7A, 0x63, 0x37, 0x49, 0x09, 0x46, 0x00, 0x07, 0x0A, 0x14, + 0x1A, 0x06, 0x9D, 0x10, 0x0B, 0x14, 0x7C, 0x43, 0x7A, 0x33, 0x37, 0x4B, + 0x7E, 0xB3, 0x37, 0x4E, 0x7E, 0x17, 0x37, 0x51, 0x12, 0x79, 0xFB, 0x7C, + 0x7B, 0x7A, 0xB3, 0x37, 0x4D, 0x7E, 0xB3, 0x37, 0x4E, 0x12, 0x81, 0x23, + 0x7A, 0xB3, 0x37, 0x4C, 0xBE, 0xB0, 0x02, 0x48, 0x25, 0x7E, 0xB3, 0x37, + 0x4E, 0x7E, 0x73, 0x37, 0x4D, 0x7D, 0x26, 0x12, 0xE1, 0x86, 0x74, 0x01, + 0x19, 0xB6, 0x00, 0x09, 0x74, 0x02, 0x19, 0xB6, 0x00, 0x0B, 0x7E, 0x73, + 0x37, 0x4D, 0x2E, 0x73, 0x37, 0x4E, 0x7A, 0x73, 0x37, 0x4E, 0x7E, 0x37, + 0x37, 0x45, 0x2E, 0x34, 0x00, 0x10, 0x7A, 0x37, 0x37, 0x45, 0x7E, 0xB3, + 0x37, 0x47, 0x04, 0x7A, 0xB3, 0x37, 0x47, 0xBE, 0xF3, 0x37, 0x47, 0x08, + 0x03, 0x02, 0x6A, 0xBF, 0x7E, 0xF3, 0x37, 0x4E, 0x7C, 0xBF, 0xDA, 0x3B, + 0x22, 0xCA, 0x3B, 0x7C, 0xFB, 0xBE, 0xF0, 0x01, 0x68, 0x03, 0x02, 0x6D, + 0x92, 0xA2, 0x01, 0xE4, 0x33, 0xB4, 0x01, 0x66, 0xA2, 0x0F, 0xE4, 0x33, + 0x78, 0x60, 0x74, 0x01, 0x12, 0xF1, 0x15, 0xA2, 0x26, 0xE4, 0x33, 0x68, + 0x03, 0x02, 0x6D, 0x8D, 0x7E, 0xB3, 0x2C, 0x5F, 0x60, 0x03, 0x02, 0x6D, + 0x8D, 0x7E, 0xA3, 0x12, 0xE5, 0xA2, 0x24, 0xE4, 0x33, 0x0A, 0x2B, 0x7E, + 0x34, 0x00, 0xCB, 0xAD, 0x32, 0x19, 0xA3, 0x2A, 0x1B, 0xE4, 0xCA, 0xB8, + 0xA2, 0x24, 0xE4, 0x33, 0x0A, 0x0B, 0x7E, 0x14, 0x00, 0xCB, 0xAD, 0x10, + 0x2E, 0x14, 0x2A, 0x1D, 0x6D, 0x00, 0xDA, 0xB8, 0x12, 0xA7, 0xA5, 0xA2, + 0x24, 0xE4, 0x33, 0x0A, 0x2B, 0x7E, 0x34, 0x00, 0xCB, 0xAD, 0x32, 0x2E, + 0x34, 0x2A, 0x19, 0x7A, 0x37, 0x2C, 0x5C, 0xD2, 0x26, 0xD2, 0x2A, 0x02, + 0x6D, 0x8D, 0x30, 0x0F, 0x0C, 0x20, 0x0F, 0x03, 0x02, 0x6D, 0x2C, 0x30, + 0x11, 0x03, 0x02, 0x6D, 0x2C, 0xA2, 0x0A, 0xE4, 0x33, 0x68, 0x03, 0x02, + 0x6D, 0x2C, 0xA2, 0x26, 0xE4, 0x33, 0x78, 0x7C, 0x20, 0x24, 0x06, 0x7E, + 0x24, 0x00, 0x01, 0x80, 0x02, 0x6D, 0x22, 0x7E, 0x34, 0x00, 0xCB, 0xAD, + 0x32, 0x7D, 0x63, 0x2E, 0x64, 0x2A, 0x19, 0x6C, 0xEE, 0x0A, 0x2E, 0x09, + 0x62, 0x2D, 0x8B, 0x2D, 0x26, 0x7E, 0x29, 0x70, 0xBC, 0x76, 0x78, 0x07, + 0x0B, 0xE0, 0xBE, 0xE0, 0x04, 0x40, 0xEA, 0xBE, 0xE0, 0x04, 0x78, 0x48, + 0x80, 0x3C, 0x0A, 0x2E, 0x09, 0x62, 0x2D, 0x8B, 0x2D, 0x26, 0x7E, 0x29, + 0x70, 0xBC, 0x76, 0x78, 0x32, 0x0A, 0x37, 0x5E, 0x34, 0x00, 0x80, 0x68, + 0x22, 0x7E, 0xA0, 0x01, 0x0A, 0x3A, 0x0A, 0x2E, 0x2D, 0x23, 0x09, 0x72, + 0x2D, 0x8B, 0x2D, 0x26, 0x7E, 0x29, 0xB0, 0xBC, 0xB7, 0x78, 0x07, 0x0B, + 0xA0, 0xBE, 0xA0, 0x07, 0x40, 0xE6, 0xBE, 0xA0, 0x07, 0x40, 0x08, 0x2E, + 0xE0, 0x07, 0xBE, 0xE0, 0xCB, 0x40, 0xBF, 0xBE, 0xE0, 0xCB, 0x50, 0x66, + 0x74, 0x01, 0x12, 0xF1, 0x15, 0x7E, 0xB3, 0x2D, 0x8B, 0x54, 0xF7, 0x7A, + 0xB3, 0x2D, 0x8B, 0x4C, 0xFF, 0x68, 0x0A, 0x7E, 0xB3, 0x2D, 0x8B, 0x44, + 0x08, 0x7A, 0xB3, 0x2D, 0x8B, 0xA2, 0x24, 0xE4, 0x33, 0x0A, 0x2B, 0x7E, + 0x34, 0x00, 0xCB, 0xAD, 0x32, 0x2E, 0x34, 0x2A, 0x19, 0x7E, 0x08, 0x2D, + 0x8B, 0x7E, 0x24, 0x00, 0x4A, 0x12, 0xF0, 0x0A, 0x53, 0xA8, 0x7F, 0x00, + 0x00, 0xA2, 0x24, 0xE4, 0x33, 0x0A, 0x2B, 0x7E, 0x34, 0x00, 0xCB, 0xAD, + 0x32, 0x2E, 0x34, 0x2A, 0x19, 0x7A, 0x37, 0x2C, 0x5C, 0x20, 0x24, 0x03, + 0xD3, 0x80, 0x01, 0xC3, 0x92, 0x24, 0xD2, 0x26, 0xD2, 0x2A, 0x43, 0xA8, + 0x80, 0x74, 0x01, 0x12, 0xF4, 0x96, 0xDA, 0x3B, 0x22, 0x7E, 0x37, 0x2D, + 0x08, 0x0B, 0x34, 0x7A, 0x37, 0x2D, 0x08, 0xE4, 0x7A, 0xB3, 0x2D, 0x73, + 0xA2, 0x10, 0xB3, 0xE4, 0x33, 0x7A, 0xB3, 0x2D, 0x00, 0xA2, 0x0F, 0xE4, + 0x33, 0x7A, 0xB3, 0x2D, 0x01, 0xE5, 0x46, 0x7A, 0xB3, 0x2C, 0x88, 0x7E, + 0x37, 0x2C, 0x67, 0x5E, 0x34, 0x00, 0x0F, 0x7A, 0x73, 0x2D, 0x0B, 0x7E, + 0x37, 0x2C, 0x67, 0x1E, 0x34, 0x1E, 0x34, 0x1E, 0x34, 0x1E, 0x34, 0x5E, + 0x34, 0x00, 0x0F, 0x7A, 0x73, 0x2D, 0x0C, 0x7E, 0xB3, 0x2D, 0x0A, 0x60, + 0x26, 0x14, 0x7A, 0xB3, 0x2D, 0x0A, 0x7E, 0xB3, 0x2D, 0x0D, 0x7E, 0x73, + 0x2D, 0x0E, 0x6C, 0x66, 0x12, 0x88, 0x8E, 0x7E, 0xB3, 0x2D, 0x7C, 0x04, + 0x7A, 0xB3, 0x2D, 0x7C, 0x74, 0x01, 0x7A, 0xB3, 0x2D, 0x73, 0x74, 0x01, + 0x02, 0x6F, 0x0D, 0x7E, 0xB3, 0x2D, 0x00, 0x60, 0x21, 0x7E, 0xB3, 0x2D, + 0x0B, 0x7E, 0x70, 0x08, 0x6C, 0x66, 0x7E, 0x50, 0x01, 0x12, 0x50, 0x29, + 0x7E, 0xB3, 0x2D, 0x0C, 0x7E, 0x70, 0x08, 0x7E, 0x60, 0x02, 0x7E, 0x50, + 0x03, 0x12, 0x50, 0x29, 0x80, 0x20, 0x7E, 0xB3, 0x2D, 0x0B, 0x7E, 0x70, + 0x20, 0x7E, 0x60, 0x02, 0x7E, 0x50, 0x04, 0x12, 0x50, 0x29, 0x7E, 0xB3, + 0x2D, 0x0C, 0x7E, 0x70, 0x20, 0x7E, 0x60, 0x03, 0x7E, 0x50, 0x05, 0x12, + 0x50, 0x29, 0x7E, 0xB3, 0x2D, 0x0B, 0x7E, 0x70, 0x02, 0xAC, 0xB7, 0x49, + 0x35, 0x2D, 0x16, 0x7A, 0x37, 0x2D, 0x14, 0x6C, 0xAA, 0x80, 0x39, 0x7E, + 0xB3, 0x2D, 0x0B, 0xBC, 0xBA, 0x68, 0x08, 0x7E, 0xB3, 0x2D, 0x0C, 0xBC, + 0xBA, 0x78, 0x15, 0x0A, 0x3A, 0x09, 0xB3, 0x2D, 0x50, 0xBE, 0xB0, 0x06, + 0x28, 0x1C, 0x74, 0x06, 0x0A, 0x4A, 0x19, 0xB4, 0x2D, 0x50, 0x80, 0x12, + 0x0A, 0x3A, 0x09, 0xB3, 0x2D, 0x50, 0x60, 0x0A, 0x0A, 0x4A, 0x2E, 0x44, + 0x2D, 0x50, 0x14, 0x7A, 0x49, 0xB0, 0x0B, 0xA0, 0x7E, 0xB3, 0x2D, 0x02, + 0xBC, 0xBA, 0x38, 0xBF, 0x7E, 0xA3, 0x2D, 0x6C, 0x7C, 0xBA, 0x30, 0xE0, + 0x08, 0x74, 0x3C, 0x7A, 0xB3, 0x2D, 0x6D, 0x80, 0x10, 0xBE, 0xA0, 0x80, + 0x78, 0x0B, 0x7E, 0xB3, 0x2D, 0x6D, 0x60, 0x05, 0x14, 0x7A, 0xB3, 0x2D, + 0x6D, 0x7E, 0xB3, 0x2D, 0x80, 0x60, 0x05, 0x14, 0x7A, 0xB3, 0x2D, 0x80, + 0x7E, 0xB3, 0x2D, 0x0D, 0xBE, 0xB3, 0x2D, 0x0B, 0x68, 0x1D, 0x7E, 0x73, + 0x2D, 0x0E, 0x7E, 0x60, 0x01, 0x12, 0x88, 0x8E, 0x7E, 0xB3, 0x2D, 0x76, + 0x04, 0x7A, 0xB3, 0x2D, 0x76, 0x74, 0x01, 0x7A, 0xB3, 0x2D, 0x73, 0x74, + 0x01, 0x80, 0x16, 0xE4, 0x7A, 0xB3, 0x2D, 0x13, 0x7E, 0x73, 0x2D, 0x0E, + 0xBE, 0x73, 0x2D, 0x0C, 0x68, 0x06, 0x74, 0x01, 0x7A, 0xB3, 0x2D, 0x13, + 0xE4, 0x22, 0xCA, 0x3B, 0x7C, 0xFB, 0x7E, 0x34, 0x07, 0x95, 0x7E, 0x24, + 0x00, 0x0A, 0x12, 0xF2, 0xA4, 0x7E, 0x34, 0x07, 0x9F, 0x7E, 0x24, 0x00, + 0xA0, 0x12, 0xF2, 0xA4, 0x7E, 0x64, 0x03, 0x52, 0x7E, 0x73, 0x05, 0x1A, + 0x7A, 0x73, 0x37, 0x4B, 0x7E, 0x73, 0x05, 0x1B, 0x7A, 0x73, 0x37, 0x4C, + 0x6C, 0xEE, 0xE4, 0x7A, 0xB3, 0x37, 0x4D, 0x7E, 0x34, 0xC1, 0x50, 0x7A, + 0x37, 0x37, 0x45, 0x74, 0x01, 0x7A, 0xB3, 0x37, 0x48, 0x7E, 0x37, 0x03, + 0xB4, 0x4D, 0x33, 0x68, 0x0D, 0x7E, 0xB3, 0x04, 0x30, 0x30, 0xE7, 0x06, + 0x74, 0x04, 0x7A, 0xB3, 0x37, 0x48, 0xE4, 0x02, 0x70, 0x4D, 0xBE, 0xE0, + 0x0A, 0x48, 0x03, 0x02, 0x70, 0x5A, 0x7E, 0x37, 0x37, 0x45, 0x09, 0x53, + 0x00, 0x08, 0x7A, 0x53, 0x37, 0x47, 0x09, 0xB3, 0x00, 0x09, 0x7A, 0xB3, + 0x37, 0x49, 0x60, 0x03, 0x02, 0x70, 0x3C, 0x7E, 0x73, 0x37, 0x48, 0xBE, + 0x73, 0x37, 0x47, 0x28, 0x03, 0x02, 0x70, 0x3C, 0x7E, 0xB3, 0x37, 0x4D, + 0x04, 0x7A, 0xB3, 0x37, 0x4D, 0x7E, 0x73, 0x03, 0xCB, 0xBE, 0x73, 0x37, + 0x47, 0x50, 0x08, 0x7E, 0x73, 0x37, 0x47, 0x7A, 0x73, 0x03, 0xCB, 0x7E, + 0x34, 0x37, 0x50, 0x7A, 0x37, 0x37, 0x5C, 0x7E, 0x17, 0x37, 0x45, 0x7D, + 0x31, 0x0B, 0x36, 0x7E, 0xB3, 0x37, 0x4B, 0x7E, 0x53, 0x37, 0x4C, 0x49, + 0x11, 0x00, 0x02, 0x7E, 0x04, 0x37, 0x4E, 0x12, 0x62, 0x4B, 0x7D, 0x23, + 0x7A, 0x37, 0x37, 0x58, 0x7E, 0x73, 0x37, 0x47, 0x0A, 0x37, 0x7A, 0x37, + 0x37, 0x56, 0x7C, 0x6E, 0x6C, 0x77, 0x4E, 0x37, 0x37, 0x56, 0x7A, 0x37, + 0x37, 0x56, 0x7C, 0xBE, 0x7E, 0x37, 0x37, 0x45, 0x12, 0xBA, 0x92, 0x7E, + 0xB3, 0x05, 0x16, 0x60, 0x0E, 0x7E, 0x37, 0x37, 0x50, 0x7A, 0x37, 0x37, + 0x52, 0x7E, 0x37, 0x37, 0x4E, 0x80, 0x0C, 0x7E, 0x37, 0x37, 0x4E, 0x7A, + 0x37, 0x37, 0x52, 0x7E, 0x37, 0x37, 0x50, 0x7A, 0x37, 0x37, 0x54, 0x7E, + 0x37, 0x37, 0x52, 0x1B, 0x68, 0x30, 0x0B, 0x65, 0x7E, 0x37, 0x37, 0x54, + 0x1B, 0x68, 0x30, 0x0B, 0x65, 0x7E, 0x37, 0x37, 0x56, 0x1B, 0x68, 0x30, + 0x0B, 0x65, 0x0B, 0xE0, 0x7E, 0x37, 0x37, 0x45, 0x2E, 0x34, 0x00, 0x10, + 0x7A, 0x37, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4A, 0x04, 0x7A, 0xB3, 0x37, + 0x4A, 0xBE, 0xF3, 0x37, 0x4A, 0x08, 0x03, 0x02, 0x6F, 0x6A, 0x7E, 0x73, + 0x37, 0x4D, 0xBE, 0x70, 0x00, 0x08, 0x10, 0x7E, 0xB3, 0x03, 0xD1, 0xBE, + 0xB0, 0xFF, 0x50, 0x11, 0x04, 0x7A, 0xB3, 0x03, 0xD1, 0x80, 0x0A, 0x7E, + 0x73, 0x03, 0xD1, 0x1E, 0x70, 0x7A, 0x73, 0x03, 0xD1, 0x1A, 0x3E, 0xDA, + 0x3B, 0x22, 0xCA, 0x79, 0x7E, 0x37, 0xFF, 0xE0, 0x5E, 0x34, 0x00, 0x02, + 0x68, 0x5C, 0x7E, 0x34, 0xFF, 0xFD, 0x7A, 0x37, 0xFF, 0xE0, 0xD2, 0x29, + 0x30, 0x2A, 0x40, 0x20, 0x30, 0x3D, 0x7E, 0x37, 0x2C, 0x5C, 0x7A, 0x37, + 0xFF, 0xD2, 0x7E, 0x34, 0x00, 0x01, 0x7A, 0x37, 0xFF, 0xD0, 0xC2, 0x2A, + 0x30, 0x01, 0x0C, 0x20, 0x0F, 0x09, 0x7E, 0xB3, 0x2C, 0x5F, 0x04, 0x7A, + 0xB3, 0x2C, 0x5F, 0xD2, 0x31, 0x7E, 0x37, 0xFF, 0xD0, 0x5E, 0x34, 0x00, + 0x01, 0x78, 0xF6, 0x7E, 0x37, 0x12, 0xE9, 0x09, 0xB3, 0x00, 0x10, 0x54, + 0x0C, 0x7A, 0xB3, 0x18, 0xF2, 0x80, 0x0F, 0x30, 0x00, 0x0C, 0x20, 0x27, + 0x09, 0x7E, 0x34, 0x00, 0x5C, 0x12, 0xDE, 0xE3, 0xD2, 0x27, 0x7E, 0x37, + 0xFF, 0xE0, 0x5E, 0x34, 0x00, 0x04, 0x78, 0x03, 0x02, 0x71, 0xF1, 0x7E, + 0x34, 0xFF, 0xFB, 0x7A, 0x37, 0xFF, 0xE0, 0x7E, 0x37, 0xFF, 0xE0, 0x1E, + 0x34, 0x1E, 0x34, 0x1E, 0x34, 0x1E, 0x34, 0x5E, 0x34, 0x00, 0x01, 0x78, + 0x03, 0x02, 0x71, 0xB4, 0x30, 0x00, 0x03, 0x02, 0x71, 0x9F, 0x7E, 0x37, + 0xFF, 0xFC, 0xBE, 0x34, 0x01, 0x40, 0x78, 0x09, 0x7E, 0x34, 0x00, 0x5C, + 0x12, 0xDE, 0xE3, 0x80, 0x19, 0x7E, 0x37, 0xFF, 0xFC, 0xBE, 0x34, 0x00, + 0x10, 0x48, 0x0F, 0x7E, 0x37, 0xFF, 0xFC, 0xBE, 0x34, 0x00, 0x13, 0x18, + 0x05, 0x30, 0x31, 0x02, 0xD2, 0x30, 0xA2, 0x30, 0xE4, 0x33, 0xB4, 0x01, + 0x02, 0x80, 0x03, 0x02, 0x71, 0xD7, 0x7E, 0x37, 0xFF, 0xFC, 0x7E, 0x27, + 0xFF, 0xF2, 0x2E, 0x27, 0xFF, 0xFC, 0x9E, 0x24, 0x00, 0x03, 0x1B, 0x24, + 0x12, 0xCF, 0x10, 0x7E, 0xB3, 0x18, 0xF2, 0x60, 0x03, 0x02, 0x71, 0xD7, + 0xC2, 0x30, 0xC2, 0x31, 0xA2, 0x2A, 0xE4, 0x33, 0x78, 0x5D, 0xC2, 0x26, + 0xE4, 0x12, 0xF0, 0x67, 0x30, 0x01, 0x54, 0x20, 0x0F, 0x51, 0xCA, 0x7B, + 0xCA, 0x6B, 0xCA, 0x5B, 0xCA, 0x4B, 0xCA, 0x3B, 0x12, 0xC9, 0xDA, 0xDA, + 0x3B, 0xDA, 0x4B, 0xDA, 0x5B, 0xDA, 0x6B, 0xDA, 0x7B, 0x80, 0x38, 0x7E, + 0x37, 0xFF, 0xFC, 0xBE, 0x34, 0x01, 0x40, 0x78, 0x2E, 0x12, 0xF4, 0x39, + 0xE4, 0x12, 0xF0, 0x84, 0xC2, 0x27, 0x80, 0x23, 0x7E, 0x37, 0xFF, 0xF2, + 0xBE, 0x34, 0x00, 0x02, 0x08, 0x19, 0x6D, 0x77, 0x80, 0x0B, 0x7D, 0x37, + 0x2E, 0x37, 0xFF, 0xFC, 0x12, 0xEC, 0x29, 0x0B, 0x74, 0x7E, 0x37, 0xFF, + 0xF2, 0x1B, 0x35, 0xBD, 0x37, 0x38, 0xEB, 0x7E, 0x34, 0x90, 0x10, 0x7A, + 0x37, 0xFF, 0xD6, 0x7E, 0x34, 0x00, 0xCB, 0x7A, 0x37, 0xFF, 0xDA, 0x7E, + 0x34, 0x90, 0x00, 0x7A, 0x37, 0xFF, 0xE8, 0xC2, 0x29, 0xDA, 0x79, 0x22, + 0xCA, 0x3B, 0x7A, 0x17, 0x37, 0x63, 0x7D, 0x62, 0x7A, 0x37, 0x37, 0x61, + 0x7C, 0xFB, 0xBE, 0xF0, 0xFF, 0x78, 0x1F, 0x6C, 0xEE, 0x1A, 0x3E, 0x09, + 0xB3, 0x07, 0x27, 0x60, 0x07, 0x0B, 0xE0, 0xBE, 0xE0, 0x0A, 0x48, 0xF1, + 0xBE, 0xE0, 0x0A, 0x78, 0x07, 0x7E, 0x34, 0xFF, 0xFF, 0x02, 0x73, 0x5E, + 0x7C, 0xFE, 0x7C, 0xEF, 0x3E, 0xE0, 0x3E, 0xE0, 0x6D, 0x33, 0x7C, 0xAE, + 0x0B, 0xE0, 0x1A, 0x2A, 0x3E, 0x24, 0x59, 0x32, 0x05, 0xA1, 0x7C, 0xAE, + 0x0B, 0xE0, 0x1A, 0x2A, 0x3E, 0x24, 0x59, 0x32, 0x05, 0xA1, 0x7E, 0xB3, + 0x03, 0xE0, 0x60, 0x10, 0x6D, 0x33, 0x7C, 0xAE, 0x0B, 0xE0, 0x1A, 0x2A, + 0x3E, 0x24, 0x59, 0x32, 0x05, 0xA1, 0x80, 0x26, 0x7E, 0x73, 0x04, 0x3A, + 0x0A, 0x27, 0xBE, 0x24, 0x00, 0xC0, 0x48, 0x04, 0x9E, 0x24, 0x01, 0x00, + 0x2E, 0x24, 0x00, 0x40, 0x7C, 0xAE, 0x0B, 0xE0, 0x1A, 0x3A, 0x3E, 0x34, + 0x59, 0x23, 0x05, 0xA1, 0x7E, 0x34, 0x00, 0x03, 0xAD, 0x32, 0x1A, 0x2E, + 0x3E, 0x24, 0x59, 0x32, 0x05, 0xA1, 0x6D, 0x33, 0x1A, 0x2F, 0x3E, 0x24, + 0x59, 0x32, 0x07, 0x09, 0x74, 0x01, 0x1A, 0x3F, 0x19, 0xB3, 0x07, 0x27, + 0xE4, 0x1A, 0x3F, 0x19, 0xB3, 0x07, 0x1D, 0x74, 0x01, 0x1A, 0x3F, 0x19, + 0xB3, 0x07, 0x31, 0x7E, 0x37, 0x37, 0x63, 0x0A, 0x36, 0x1A, 0x2F, 0x19, + 0x72, 0x07, 0x95, 0x1A, 0x3F, 0x19, 0xB3, 0x0A, 0xB5, 0x7C, 0xBF, 0x1A, + 0x3B, 0x09, 0x73, 0x07, 0x95, 0x12, 0xD3, 0xFA, 0x7E, 0x37, 0x37, 0x63, + 0x1A, 0x2F, 0x19, 0x72, 0x07, 0x45, 0xE4, 0x1A, 0x3F, 0x19, 0xB3, 0x0A, + 0x42, 0x7E, 0x37, 0x37, 0x61, 0x1A, 0x2F, 0x3E, 0x24, 0x59, 0x32, 0x06, + 0x91, 0x1A, 0x3F, 0x3E, 0x34, 0x59, 0x63, 0x06, 0xA5, 0x7C, 0xBF, 0x7E, + 0x37, 0x37, 0x61, 0x7D, 0x26, 0x12, 0xDF, 0x28, 0x7C, 0xBF, 0x7E, 0x37, + 0x37, 0x61, 0x7D, 0x26, 0x12, 0xEC, 0xCC, 0x7E, 0x37, 0x37, 0x61, 0x1A, + 0x2F, 0x3E, 0x24, 0x59, 0x32, 0x07, 0x4F, 0x1A, 0x3F, 0x3E, 0x34, 0x59, + 0x63, 0x07, 0x63, 0x74, 0x02, 0x1A, 0x3F, 0x19, 0xB3, 0x07, 0x77, 0x74, + 0xFF, 0x1A, 0x3F, 0x19, 0xB3, 0x07, 0x81, 0x74, 0x01, 0x7A, 0xB3, 0x03, + 0xDD, 0xE4, 0x1A, 0x3F, 0x19, 0xB3, 0x08, 0x49, 0x1A, 0x0F, 0x7E, 0x24, + 0x00, 0x0E, 0x7D, 0x10, 0xAD, 0x12, 0x7D, 0x31, 0x2E, 0x34, 0x08, 0x53, + 0x12, 0xF2, 0xA4, 0x1A, 0x3F, 0x3E, 0x34, 0x3E, 0x34, 0x3E, 0x34, 0x3E, + 0x34, 0x2E, 0x34, 0x08, 0xE3, 0x7E, 0x24, 0x00, 0x10, 0x12, 0xF2, 0xA4, + 0x6D, 0x33, 0xDA, 0x3B, 0x22, 0xCA, 0xF8, 0x7C, 0xF7, 0x7C, 0x3B, 0x7E, + 0x18, 0x3A, 0x7C, 0x7A, 0x1F, 0x37, 0x30, 0x4C, 0x33, 0x68, 0x09, 0x7E, + 0x1F, 0x37, 0x30, 0x7E, 0x1B, 0xB0, 0x70, 0x0C, 0xE4, 0x7E, 0x0F, 0x37, + 0x30, 0x39, 0xB0, 0x00, 0x09, 0x02, 0x74, 0xBE, 0x2E, 0x34, 0x00, 0x93, + 0x7A, 0x1F, 0x37, 0x34, 0xE4, 0x7E, 0x24, 0x00, 0x40, 0x12, 0xF2, 0xF7, + 0x7E, 0x1F, 0x37, 0x34, 0x2E, 0x34, 0x00, 0x0E, 0x7E, 0x24, 0x0E, 0x07, + 0x7E, 0x14, 0x00, 0x14, 0x12, 0xF3, 0x47, 0x7E, 0x1F, 0x37, 0x34, 0x2E, + 0x34, 0x00, 0x22, 0x7E, 0x24, 0x0E, 0x1B, 0x7E, 0x14, 0x00, 0x14, 0x12, + 0xF3, 0x47, 0x7E, 0x1F, 0x37, 0x34, 0x0B, 0x36, 0x7E, 0x24, 0x0D, 0xF7, + 0x7E, 0x14, 0x00, 0x0A, 0x12, 0xF3, 0x47, 0x7E, 0x1F, 0x37, 0x34, 0x2E, + 0x34, 0x00, 0x36, 0x7E, 0x24, 0x0D, 0xEB, 0x7E, 0x14, 0x00, 0x0A, 0x12, + 0xF3, 0x47, 0x7E, 0x73, 0x0E, 0x31, 0x7E, 0x0F, 0x37, 0x34, 0x39, 0x70, + 0x00, 0x03, 0x7E, 0x1F, 0x37, 0x34, 0x39, 0xF1, 0x00, 0x01, 0x7E, 0xB3, + 0x0E, 0x31, 0x70, 0x09, 0x7E, 0xB3, 0x0D, 0xBB, 0xBE, 0xB0, 0xFF, 0x68, + 0x0A, 0x74, 0x01, 0x7E, 0x1F, 0x37, 0x34, 0x39, 0xB1, 0x00, 0x02, 0xE4, + 0x7E, 0x1F, 0x37, 0x30, 0x39, 0xB1, 0x00, 0x08, 0x7E, 0x1F, 0x37, 0x30, + 0x29, 0xB1, 0x00, 0x09, 0x60, 0x29, 0x29, 0xA1, 0x00, 0x0A, 0x0B, 0xA0, + 0x7E, 0x0F, 0x37, 0x34, 0x29, 0xB0, 0x00, 0x02, 0x60, 0x02, 0x6C, 0xAA, + 0x39, 0xA1, 0x00, 0x0A, 0xBE, 0xA0, 0x03, 0x68, 0x03, 0x02, 0x74, 0xBE, + 0xE4, 0x7E, 0x0F, 0x37, 0x30, 0x39, 0xB0, 0x00, 0x09, 0x80, 0x73, 0x7E, + 0x0F, 0x37, 0x34, 0x29, 0xB0, 0x00, 0x02, 0x60, 0x69, 0x2E, 0x34, 0x00, + 0x13, 0xE4, 0x7E, 0x24, 0x00, 0x40, 0x12, 0xF2, 0xF7, 0x74, 0x80, 0x7E, + 0x1F, 0x37, 0x30, 0x39, 0xB1, 0x00, 0x13, 0x7E, 0x1F, 0x37, 0x30, 0x2E, + 0x34, 0x00, 0x53, 0x7E, 0x0F, 0x37, 0x34, 0x7D, 0x21, 0x7E, 0x14, 0x00, + 0x40, 0x12, 0xF3, 0x47, 0x74, 0x01, 0x7E, 0x1F, 0x37, 0x30, 0x39, 0xB1, + 0x00, 0x53, 0x0A, 0x3F, 0x1B, 0x34, 0x7E, 0x0F, 0x37, 0x30, 0x39, 0x70, + 0x00, 0x10, 0x74, 0x01, 0x7E, 0x1F, 0x37, 0x30, 0x39, 0xB1, 0x00, 0x08, + 0x74, 0x01, 0x7E, 0x1F, 0x37, 0x30, 0x39, 0xB1, 0x00, 0x0F, 0x74, 0x01, + 0x7E, 0x1F, 0x37, 0x30, 0x39, 0xB1, 0x00, 0x0B, 0x74, 0x01, 0x7E, 0x1F, + 0x37, 0x30, 0x39, 0xB1, 0x00, 0x09, 0xDA, 0xF8, 0x22, 0xCA, 0x3B, 0x7C, + 0xAB, 0x7E, 0xB3, 0x04, 0x6D, 0x20, 0xE4, 0x03, 0x02, 0x76, 0x13, 0xBE, + 0xA0, 0x01, 0x38, 0x03, 0x02, 0x76, 0x13, 0x7E, 0x74, 0xC1, 0x50, 0x7E, + 0xD0, 0x10, 0xAC, 0xDA, 0x2D, 0x67, 0x02, 0x76, 0x0C, 0x09, 0xB7, 0x00, + 0x09, 0x60, 0x03, 0x02, 0x76, 0x08, 0x09, 0xB7, 0x00, 0x05, 0x60, 0x15, + 0x7E, 0x73, 0x05, 0x1A, 0x0A, 0x27, 0x1B, 0x24, 0x09, 0x77, 0x00, 0x04, + 0x0A, 0x37, 0xBD, 0x32, 0x68, 0x03, 0x02, 0x76, 0x08, 0x09, 0xB7, 0x00, + 0x06, 0x0A, 0x1B, 0x09, 0xA7, 0x00, 0x07, 0x0A, 0x2A, 0x7D, 0x32, 0x9D, + 0x31, 0xBE, 0x34, 0x00, 0x01, 0x08, 0x03, 0x02, 0x76, 0x08, 0xBE, 0xB0, + 0x01, 0x68, 0x0F, 0x7E, 0x73, 0x05, 0x1B, 0x0A, 0x37, 0x1B, 0x35, 0xBD, + 0x23, 0x68, 0x03, 0x02, 0x76, 0x08, 0x7E, 0x34, 0xC1, 0x50, 0x02, 0x75, + 0xFB, 0xBE, 0x77, 0x37, 0x45, 0x78, 0x03, 0x02, 0x75, 0xF3, 0x7E, 0x27, + 0x37, 0x45, 0x09, 0xB2, 0x00, 0x09, 0x60, 0x03, 0x02, 0x75, 0xF3, 0x09, + 0xA2, 0x00, 0x07, 0x4C, 0xAA, 0x68, 0x15, 0x7E, 0xB3, 0x05, 0x1B, 0x0A, + 0x1B, 0x1B, 0x14, 0x09, 0xB2, 0x00, 0x06, 0x0A, 0x3B, 0xBD, 0x31, 0x68, + 0x03, 0x02, 0x75, 0xF3, 0x09, 0xB2, 0x00, 0x04, 0x0A, 0x1B, 0x09, 0x72, + 0x00, 0x05, 0x0A, 0x47, 0x7D, 0x34, 0x9D, 0x31, 0xBE, 0x34, 0x00, 0x01, + 0x18, 0x6D, 0xBE, 0xB0, 0x01, 0x68, 0x0C, 0x7E, 0xB3, 0x05, 0x1A, 0x0A, + 0x3B, 0x1B, 0x35, 0xBD, 0x43, 0x78, 0x5C, 0x09, 0xB2, 0x00, 0x04, 0x7A, + 0xB3, 0x37, 0x47, 0x09, 0xB7, 0x00, 0x05, 0x60, 0x12, 0x09, 0xB2, 0x00, + 0x05, 0x1A, 0x1B, 0x09, 0xB7, 0x00, 0x05, 0x1A, 0x3B, 0x9D, 0x31, 0x7A, + 0x73, 0x37, 0x47, 0x09, 0xB7, 0x00, 0x06, 0x7A, 0xB3, 0x37, 0x48, 0x4C, + 0xAA, 0x68, 0x12, 0x09, 0x77, 0x00, 0x07, 0x1A, 0x17, 0x09, 0x72, 0x00, + 0x07, 0x1A, 0x37, 0x9D, 0x31, 0x7A, 0x73, 0x37, 0x48, 0x7E, 0x73, 0x37, + 0x47, 0xBE, 0x70, 0x01, 0x18, 0x15, 0x7E, 0x73, 0x37, 0x48, 0xBE, 0x70, + 0x01, 0x18, 0x0C, 0x7D, 0x37, 0x12, 0xAD, 0xF1, 0xE4, 0x19, 0xB7, 0x00, + 0x0B, 0x80, 0x15, 0x7E, 0x37, 0x37, 0x45, 0x2E, 0x34, 0x00, 0x10, 0x7A, + 0x37, 0x37, 0x45, 0xBE, 0x67, 0x37, 0x45, 0x28, 0x03, 0x02, 0x75, 0x3D, + 0x2E, 0x74, 0x00, 0x10, 0xBD, 0x67, 0x28, 0x03, 0x02, 0x74, 0xE5, 0xDA, + 0x3B, 0x22, 0xCA, 0xF8, 0x7D, 0x43, 0x7C, 0x3B, 0x7E, 0xF3, 0x3B, 0x7D, + 0x6C, 0x22, 0x6C, 0x44, 0x7E, 0xE7, 0x0E, 0x73, 0x7E, 0xF7, 0x0E, 0x75, + 0x6C, 0x55, 0x7E, 0x37, 0x0E, 0x77, 0x7E, 0x07, 0x0E, 0x79, 0x7C, 0xBF, + 0x14, 0xBE, 0xB0, 0x17, 0x40, 0x03, 0x02, 0x77, 0x46, 0x7E, 0xA0, 0x03, + 0xA4, 0x90, 0x76, 0x49, 0x73, 0x02, 0x77, 0x1F, 0x02, 0x77, 0x1F, 0x02, + 0x77, 0x1F, 0x02, 0x77, 0x1F, 0x02, 0x77, 0x1F, 0x02, 0x77, 0x1F, 0x02, + 0x77, 0x1F, 0x02, 0x77, 0x1F, 0x02, 0x77, 0x1F, 0x02, 0x77, 0x1F, 0x02, + 0x77, 0x1F, 0x02, 0x77, 0x1F, 0x02, 0x77, 0x06, 0x02, 0x77, 0x06, 0x02, + 0x77, 0x06, 0x02, 0x77, 0x06, 0x02, 0x76, 0xE2, 0x02, 0x76, 0xE2, 0x02, + 0x76, 0xE2, 0x02, 0x76, 0xE2, 0x02, 0x76, 0x8E, 0x02, 0x76, 0x8E, 0x02, + 0x76, 0x8E, 0xBE, 0xF0, 0x15, 0x78, 0x05, 0x7E, 0x20, 0x02, 0x80, 0x12, + 0xBE, 0xF0, 0x16, 0x78, 0x05, 0x7E, 0x20, 0x04, 0x80, 0x08, 0xBE, 0xF0, + 0x17, 0x78, 0x03, 0x7E, 0x20, 0x01, 0x7C, 0xB3, 0x54, 0x01, 0x0A, 0xFB, + 0x7E, 0x54, 0x00, 0x01, 0x9D, 0x5F, 0x7C, 0x4B, 0xBE, 0x30, 0x02, 0x50, + 0x0B, 0xBE, 0xF0, 0x17, 0x68, 0x06, 0x7E, 0xE7, 0x3B, 0x73, 0x80, 0x04, + 0x7E, 0xE7, 0x3B, 0x6F, 0xBE, 0x30, 0x02, 0x50, 0x0B, 0xBE, 0xF0, 0x17, + 0x68, 0x06, 0x7E, 0xF7, 0x3B, 0x75, 0x80, 0x04, 0x7E, 0xF7, 0x3B, 0x71, + 0x80, 0x67, 0x7E, 0x20, 0x03, 0xBE, 0x30, 0x02, 0x50, 0x5F, 0x7E, 0x50, + 0x01, 0x7E, 0x40, 0x01, 0xA5, 0xBB, 0x00, 0x55, 0x7E, 0xE7, 0x3B, 0x56, + 0x7E, 0xF7, 0x3B, 0x58, 0x7E, 0x37, 0x3B, 0x60, 0x7E, 0x07, 0x3B, 0x62, + 0x80, 0x43, 0x7E, 0x20, 0x03, 0xBE, 0x30, 0x02, 0x50, 0x3B, 0x7E, 0x40, + 0x01, 0xA5, 0xBB, 0x00, 0x34, 0x7E, 0xE7, 0x3B, 0x56, 0x7E, 0xF7, 0x3B, + 0x58, 0x80, 0x2A, 0x7E, 0x23, 0x39, 0x46, 0x0A, 0x52, 0x0B, 0x54, 0x0B, + 0x54, 0x7C, 0x2B, 0x0A, 0xD2, 0x1B, 0xD4, 0x0A, 0x53, 0xBD, 0x5D, 0x58, + 0x14, 0x7E, 0x40, 0x01, 0x74, 0x02, 0xAC, 0xB3, 0x49, 0xE5, 0x39, 0x97, + 0x49, 0xF5, 0x39, 0xC1, 0x80, 0x03, 0xE4, 0x80, 0x1D, 0xBC, 0x23, 0x28, + 0x17, 0x7A, 0x49, 0x40, 0x59, 0xE4, 0x00, 0x01, 0x59, 0xF4, 0x00, 0x03, + 0x19, 0x54, 0x00, 0x05, 0x59, 0x34, 0x00, 0x06, 0x59, 0x04, 0x00, 0x08, + 0x7C, 0xB2, 0xDA, 0xF8, 0x22, 0x7E, 0x37, 0x12, 0xE9, 0x2E, 0x34, 0x00, + 0x03, 0x7E, 0x24, 0x01, 0xBA, 0x12, 0xF2, 0x4B, 0xE4, 0x7A, 0xB3, 0x12, + 0xE0, 0x7E, 0x34, 0x2E, 0x33, 0x7E, 0x24, 0x00, 0x20, 0x12, 0xF2, 0x4B, + 0xA2, 0x00, 0xE4, 0x33, 0x7C, 0x6B, 0x5E, 0x60, 0x01, 0x7C, 0xB6, 0x03, + 0x03, 0x54, 0xC0, 0x7C, 0x6B, 0x7E, 0x27, 0x12, 0xE9, 0x2E, 0x24, 0x00, + 0xF1, 0x7E, 0x29, 0x70, 0x5E, 0x70, 0xBF, 0x4C, 0x76, 0x7A, 0x29, 0x70, + 0x7E, 0x63, 0x12, 0xE2, 0x5E, 0x60, 0x07, 0x3E, 0x60, 0x3E, 0x60, 0x7E, + 0x27, 0x12, 0xE9, 0x2E, 0x24, 0x00, 0xF1, 0x7E, 0x29, 0x70, 0x5E, 0x70, + 0xE3, 0x4C, 0x76, 0x7A, 0x29, 0x70, 0x7E, 0x37, 0x12, 0xE9, 0x2E, 0x34, + 0x00, 0xF0, 0x7E, 0x39, 0xB0, 0x44, 0x03, 0x7A, 0x39, 0xB0, 0x7E, 0x37, + 0x12, 0xE9, 0x2E, 0x34, 0x00, 0xF0, 0x7E, 0x39, 0xB0, 0x44, 0x04, 0x7A, + 0x39, 0xB0, 0x7E, 0x37, 0x12, 0xE9, 0x2E, 0x34, 0x00, 0xF0, 0x7E, 0x39, + 0xB0, 0x44, 0x08, 0x7A, 0x39, 0xB0, 0xA9, 0xA0, 0xED, 0xE4, 0x33, 0x7C, + 0x6B, 0x5E, 0x60, 0x01, 0x7C, 0xB6, 0x03, 0x03, 0x54, 0xC0, 0x7C, 0x6B, + 0x7E, 0x27, 0x12, 0xE9, 0x2E, 0x24, 0x00, 0xF0, 0x7E, 0x29, 0x70, 0x5E, + 0x70, 0xBF, 0x4C, 0x76, 0x7A, 0x29, 0x70, 0x74, 0x83, 0x7E, 0x37, 0x12, + 0xE9, 0x19, 0xB3, 0x00, 0xF4, 0xE4, 0x12, 0xEA, 0x10, 0x74, 0x53, 0x7E, + 0x37, 0x12, 0xE9, 0x19, 0xB3, 0x01, 0x00, 0x74, 0x54, 0x7E, 0x37, 0x12, + 0xE9, 0x19, 0xB3, 0x01, 0x01, 0x74, 0x4A, 0x7E, 0x37, 0x12, 0xE9, 0x19, + 0xB3, 0x01, 0x02, 0x74, 0x30, 0x7E, 0x37, 0x12, 0xE9, 0x19, 0xB3, 0x01, + 0x03, 0x7E, 0x34, 0x01, 0x08, 0x7E, 0x27, 0x12, 0xE9, 0x59, 0x32, 0x01, + 0x04, 0x12, 0xDA, 0xC8, 0x7E, 0x37, 0x12, 0xE9, 0x2E, 0x34, 0x00, 0xF0, + 0x7E, 0x39, 0xB0, 0x44, 0x80, 0x7A, 0x39, 0xB0, 0x7E, 0x37, 0x12, 0xE9, + 0x2E, 0x34, 0x00, 0xF1, 0x7E, 0x39, 0xB0, 0x44, 0x80, 0x7A, 0x39, 0xB0, + 0x7E, 0x37, 0x2D, 0xD9, 0x0B, 0x34, 0x7E, 0x39, 0x60, 0x1E, 0x60, 0x1E, + 0x60, 0x5E, 0x60, 0x01, 0x7C, 0xB6, 0xC4, 0x23, 0x54, 0xE0, 0x7C, 0x6B, + 0x7E, 0x27, 0x12, 0xE9, 0x2E, 0x24, 0x00, 0xF0, 0x7E, 0x29, 0x70, 0x5E, + 0x70, 0xDF, 0x4C, 0x76, 0x7A, 0x29, 0x70, 0x12, 0xE9, 0xE2, 0x12, 0xE5, + 0x5D, 0x22, 0xCA, 0x3B, 0x7C, 0xA3, 0x7C, 0xD4, 0x7C, 0xF5, 0x7C, 0xEB, + 0x7D, 0x43, 0x7E, 0xF4, 0xC0, 0xE4, 0x7E, 0xE4, 0xC1, 0x26, 0x6D, 0xDD, + 0x6C, 0xCC, 0x80, 0x69, 0x7D, 0xC4, 0x9F, 0x11, 0x7E, 0x14, 0xFF, 0xFF, + 0xE4, 0x80, 0x2D, 0x0B, 0xC8, 0xB0, 0xBE, 0xB4, 0x00, 0x00, 0x58, 0x02, + 0x6D, 0xBB, 0xBD, 0x1B, 0x58, 0x09, 0x7D, 0x1B, 0x7E, 0xB3, 0x37, 0x64, + 0x7A, 0xE9, 0xB0, 0x7D, 0x0B, 0x7D, 0x9B, 0x1A, 0x00, 0x1A, 0x80, 0x2F, + 0x14, 0x1A, 0x0A, 0x3E, 0x04, 0x2D, 0xC0, 0x7E, 0xB3, 0x37, 0x64, 0x04, + 0x7A, 0xB3, 0x37, 0x64, 0xBE, 0xF3, 0x37, 0x64, 0x18, 0xC9, 0xBE, 0x18, + 0x7F, 0xFF, 0x08, 0x04, 0x7E, 0x18, 0x7F, 0xFF, 0x7D, 0x0D, 0x7D, 0xBD, + 0x1A, 0x00, 0x1A, 0xA0, 0xBF, 0x51, 0x58, 0x02, 0x7D, 0xD3, 0x1B, 0xF8, + 0x30, 0x0B, 0xF5, 0x1A, 0x0D, 0x3E, 0x04, 0x2D, 0x40, 0x0B, 0xE4, 0x0B, + 0xC0, 0xBC, 0xEC, 0x18, 0x93, 0x7E, 0xE4, 0x80, 0x01, 0x1B, 0xF8, 0xE0, + 0x7E, 0xE4, 0xC1, 0x26, 0x7E, 0x44, 0xC1, 0x47, 0x7E, 0xF4, 0xC0, 0xE4, + 0x7E, 0x33, 0x04, 0x32, 0x7D, 0x3D, 0x1A, 0x26, 0x1A, 0x24, 0x0A, 0x13, + 0x6D, 0x00, 0x12, 0x8C, 0xBA, 0x7C, 0x76, 0x7C, 0x65, 0x7D, 0xC3, 0x7E, + 0xB3, 0x04, 0x6A, 0x54, 0x0F, 0x0A, 0x5B, 0x3E, 0x54, 0x3E, 0x54, 0x78, + 0x04, 0x7E, 0x54, 0x00, 0x1E, 0xBD, 0x5C, 0x08, 0x02, 0x7D, 0xC5, 0x6C, + 0xAA, 0x6D, 0x33, 0x6D, 0xDD, 0x6C, 0x55, 0x6C, 0xCC, 0x80, 0x5A, 0x0B, + 0xF8, 0x10, 0x0B, 0xF5, 0xA5, 0xBD, 0x00, 0x39, 0xBD, 0x1D, 0x48, 0x06, + 0x7D, 0xD1, 0x7A, 0xC3, 0x37, 0x65, 0x7D, 0x0D, 0x9D, 0x0C, 0xBD, 0x01, + 0x08, 0x3D, 0x7E, 0x50, 0x01, 0x7D, 0x31, 0xBE, 0xA0, 0x04, 0x58, 0x33, + 0x0B, 0xA0, 0x7E, 0x43, 0x37, 0x65, 0x7A, 0x49, 0x40, 0x0B, 0x44, 0x7E, + 0x43, 0x37, 0x65, 0x1A, 0x04, 0x2D, 0x0E, 0x7E, 0x09, 0x40, 0x7A, 0x49, + 0x40, 0x0B, 0x44, 0x80, 0x16, 0xBD, 0x13, 0x18, 0x02, 0x7D, 0x31, 0x7D, + 0x0C, 0x2D, 0x03, 0xBD, 0x01, 0x58, 0x08, 0x6C, 0x55, 0x7D, 0xD1, 0x7A, + 0xC3, 0x37, 0x65, 0x0B, 0xC0, 0x1A, 0xBE, 0x0B, 0xB4, 0x1A, 0x0C, 0xBD, + 0x0B, 0x48, 0x9C, 0x7E, 0x44, 0xC1, 0x46, 0x7A, 0x49, 0xA0, 0x7D, 0x34, + 0xDA, 0x3B, 0x22, 0xCA, 0x3B, 0x7D, 0x41, 0x7C, 0xF4, 0x7C, 0xE5, 0x7C, + 0x16, 0x7C, 0x07, 0x7C, 0xAB, 0x7E, 0xB3, 0x05, 0x1A, 0x0A, 0x3B, 0x1A, + 0x21, 0xAD, 0x32, 0x1A, 0x20, 0x2D, 0x32, 0x3E, 0x34, 0x2E, 0x37, 0x03, + 0x10, 0x4C, 0xAA, 0x68, 0x1E, 0x7D, 0xD4, 0x7D, 0xC4, 0x1A, 0x1A, 0x7E, + 0x64, 0x00, 0x0F, 0x9D, 0x61, 0x1A, 0x1A, 0x3E, 0x14, 0x3E, 0x14, 0x3E, + 0x14, 0x3E, 0x14, 0x7E, 0x78, 0xC1, 0x50, 0x2D, 0xF1, 0x80, 0x0D, 0x7D, + 0xD4, 0x7D, 0xC4, 0x0E, 0xC4, 0x7E, 0xD0, 0x0F, 0x7E, 0x78, 0xC1, 0x50, + 0x1A, 0x1E, 0x4E, 0x20, 0x01, 0x7A, 0x17, 0xFF, 0xC2, 0x7E, 0xB3, 0x05, + 0x1A, 0x7C, 0x8B, 0x6C, 0x99, 0x1A, 0x1F, 0x4D, 0x14, 0x7A, 0x17, 0xFF, + 0xC4, 0x7E, 0x14, 0x00, 0x80, 0x7A, 0x17, 0xFF, 0xC6, 0x7A, 0xC7, 0xFF, + 0xC8, 0x7A, 0xD7, 0xFF, 0xCA, 0x7C, 0x2D, 0x7E, 0x30, 0x01, 0x7A, 0x17, + 0xFF, 0xCC, 0x7F, 0x57, 0x9E, 0xB4, 0x00, 0x10, 0x7A, 0xB7, 0xFF, 0xCE, + 0x7A, 0x37, 0xFF, 0xC0, 0x7E, 0x17, 0xFF, 0x00, 0x5E, 0x14, 0x00, 0x80, + 0x78, 0xF6, 0x6C, 0x77, 0x7D, 0x1F, 0x7D, 0x4F, 0x6C, 0x66, 0x02, 0x7B, + 0x28, 0x74, 0x01, 0x19, 0xB4, 0x00, 0x09, 0x09, 0xB1, 0x00, 0x08, 0x60, + 0x2A, 0xBD, 0x41, 0x68, 0x21, 0x6C, 0x55, 0x7E, 0xF0, 0x02, 0xAC, 0xF5, + 0x7D, 0xB7, 0x2D, 0xB1, 0x0B, 0xB8, 0xA0, 0x7D, 0xB7, 0x2D, 0xB4, 0x1B, + 0xB8, 0xA0, 0x0B, 0x50, 0xA5, 0xBD, 0x08, 0xE7, 0x74, 0x01, 0x19, 0xB1, + 0x00, 0x09, 0xE4, 0x19, 0xB4, 0x00, 0x09, 0x09, 0xB4, 0x00, 0x09, 0x70, + 0x45, 0xE4, 0x19, 0xB4, 0x00, 0x0B, 0x4C, 0xAA, 0x68, 0x36, 0x7D, 0xB4, + 0x0B, 0xB6, 0x7E, 0xB9, 0x40, 0x2C, 0x40, 0x7A, 0xB9, 0x40, 0x7D, 0xB4, + 0x2E, 0xB4, 0x00, 0x05, 0x7E, 0xB9, 0x40, 0x2C, 0x40, 0x7A, 0xB9, 0x40, + 0x7D, 0xB4, 0x2E, 0xB4, 0x00, 0x06, 0x7E, 0xB9, 0x40, 0x2C, 0x41, 0x7A, + 0xB9, 0x40, 0x7D, 0xB4, 0x2E, 0xB4, 0x00, 0x07, 0x7E, 0xB9, 0x40, 0x2C, + 0x41, 0x7A, 0xB9, 0x40, 0x0B, 0x70, 0x2E, 0x44, 0x00, 0x10, 0x2E, 0x14, + 0x00, 0x10, 0x0B, 0x60, 0xBC, 0xD6, 0x28, 0x03, 0x02, 0x7A, 0xA1, 0x7C, + 0xB7, 0xDA, 0x3B, 0x22, 0xCA, 0x3B, 0x7C, 0xAB, 0x7D, 0xD2, 0x7D, 0xC3, + 0xE4, 0x7A, 0xB3, 0x0E, 0x31, 0x7C, 0x9A, 0x7E, 0x80, 0x10, 0x9C, 0x89, + 0x6C, 0xFF, 0x0A, 0xFF, 0x2D, 0xFC, 0x09, 0xBF, 0x00, 0x04, 0xBE, 0xB0, + 0x01, 0x68, 0x08, 0xB4, 0x02, 0x02, 0x80, 0x03, 0x02, 0x7C, 0x0D, 0x0A, + 0xEF, 0x2D, 0xED, 0x09, 0xEE, 0x00, 0x04, 0xBE, 0xE0, 0x01, 0x68, 0x03, + 0x02, 0x7C, 0x0D, 0x7E, 0xD0, 0x02, 0xAC, 0xDF, 0x7D, 0x86, 0x2D, 0x8D, + 0x49, 0x38, 0x00, 0x0E, 0x1A, 0x26, 0x1A, 0x24, 0x0A, 0x19, 0x6D, 0x00, + 0x12, 0x8C, 0xBA, 0x7F, 0x51, 0x7D, 0x96, 0x2D, 0x9C, 0x49, 0x39, 0x00, + 0x0E, 0x1A, 0x26, 0x1A, 0x24, 0x0A, 0x18, 0x6D, 0x00, 0x12, 0x8C, 0xBA, + 0x2F, 0x15, 0x74, 0x04, 0x1E, 0x34, 0x0E, 0x24, 0x50, 0x03, 0x4E, 0x60, + 0x80, 0x14, 0x78, 0xF4, 0x7D, 0x53, 0x59, 0x56, 0x0E, 0x07, 0x49, 0x38, + 0x00, 0x22, 0x1A, 0x26, 0x1A, 0x24, 0x0A, 0x19, 0x6D, 0x00, 0x12, 0x8C, + 0xBA, 0x7F, 0x51, 0x49, 0x39, 0x00, 0x22, 0x1A, 0x26, 0x1A, 0x24, 0x0A, + 0x18, 0x6D, 0x00, 0x12, 0x8C, 0xBA, 0x2F, 0x15, 0x74, 0x04, 0x1E, 0x34, + 0x0E, 0x24, 0x50, 0x03, 0x4E, 0x60, 0x80, 0x14, 0x78, 0xF4, 0x74, 0x02, + 0xAC, 0xBF, 0x59, 0x35, 0x0E, 0x1B, 0x0A, 0x5F, 0x19, 0xE5, 0x0D, 0xF7, + 0x09, 0x7E, 0x00, 0x36, 0x0A, 0x27, 0x09, 0x7F, 0x00, 0x36, 0x0A, 0x37, + 0x2D, 0x32, 0x7E, 0x24, 0x00, 0x02, 0x12, 0x8C, 0x88, 0x0A, 0x5F, 0x19, + 0x75, 0x0D, 0xEB, 0x80, 0x3E, 0x7E, 0x50, 0x02, 0xAC, 0x5F, 0x7D, 0x52, + 0x2D, 0x5D, 0x49, 0x35, 0x00, 0x0E, 0x59, 0x32, 0x0E, 0x07, 0x49, 0x35, + 0x00, 0x22, 0x74, 0x02, 0xAC, 0xBF, 0x59, 0x35, 0x0E, 0x1B, 0x0A, 0x3F, + 0x2D, 0x3D, 0x09, 0xB3, 0x00, 0x04, 0x0A, 0x2F, 0x19, 0xB2, 0x0D, 0xF7, + 0x09, 0xA3, 0x00, 0x36, 0x0A, 0x2F, 0x19, 0xA2, 0x0D, 0xEB, 0xB4, 0x02, + 0x06, 0x74, 0x03, 0x19, 0xB3, 0x00, 0x04, 0x0A, 0x5F, 0x09, 0xB5, 0x0D, + 0xF7, 0x60, 0x09, 0x7E, 0xB3, 0x0E, 0x31, 0x04, 0x7A, 0xB3, 0x0E, 0x31, + 0x0B, 0xF0, 0xBE, 0xF0, 0x0A, 0x50, 0x03, 0x02, 0x7B, 0x4A, 0x74, 0x01, + 0xDA, 0x3B, 0x22, 0xCA, 0x3B, 0xE4, 0x7A, 0xB3, 0x37, 0x30, 0x7E, 0x37, + 0x0D, 0xE9, 0x7A, 0x37, 0x37, 0x32, 0x7E, 0x37, 0x0D, 0xF5, 0x7A, 0x37, + 0x37, 0x34, 0xBE, 0x37, 0x37, 0x32, 0x78, 0x20, 0x7E, 0x37, 0x37, 0x34, + 0x5E, 0x34, 0x00, 0x40, 0x78, 0x03, 0x02, 0x7D, 0x9A, 0x7E, 0x73, 0x0E, + 0x30, 0xBE, 0x73, 0x0E, 0x2F, 0x78, 0x03, 0x02, 0x7D, 0x9A, 0x74, 0x01, + 0x7A, 0xB3, 0x37, 0x30, 0x7E, 0x27, 0x37, 0x34, 0x5E, 0x24, 0x00, 0x40, + 0x7E, 0x37, 0x37, 0x32, 0x5E, 0x34, 0x00, 0x40, 0xBD, 0x32, 0x78, 0x06, + 0x7E, 0xB3, 0x37, 0x30, 0x60, 0x03, 0x12, 0xEB, 0x7C, 0x6C, 0xFF, 0x1A, + 0x3F, 0x1A, 0x26, 0x2E, 0x24, 0x00, 0xFF, 0x2E, 0x18, 0xF7, 0xA8, 0x7E, + 0x1B, 0x70, 0x7A, 0x73, 0x37, 0x2F, 0x1A, 0x1F, 0x1A, 0x02, 0x2E, 0x04, + 0x00, 0xFF, 0x2E, 0x08, 0xF7, 0xA9, 0x7E, 0x0B, 0xE0, 0x74, 0x01, 0x7C, + 0x6E, 0x12, 0xC3, 0x6F, 0x0B, 0xF0, 0xBE, 0xF0, 0x10, 0x48, 0xD0, 0x7E, + 0x64, 0x00, 0x02, 0x6C, 0xFF, 0xE4, 0x7A, 0xB3, 0x37, 0x31, 0xBE, 0xF0, + 0x05, 0x78, 0x0F, 0x7E, 0x73, 0x37, 0x30, 0xBE, 0x70, 0x00, 0x28, 0x06, + 0x74, 0x01, 0x7A, 0xB3, 0x37, 0x31, 0x7D, 0x36, 0x5E, 0x37, 0x37, 0x34, + 0x7D, 0x26, 0x5E, 0x27, 0x37, 0x32, 0xBD, 0x23, 0x78, 0x09, 0x7E, 0x53, + 0x37, 0x31, 0xBE, 0x50, 0x00, 0x28, 0x0D, 0x1A, 0x2F, 0x2E, 0x24, 0x0D, + 0xBC, 0x7E, 0x29, 0xB0, 0x04, 0x7A, 0x29, 0xB0, 0x4D, 0x33, 0x68, 0x46, + 0x1A, 0x3F, 0x1A, 0x26, 0x2E, 0x24, 0x00, 0xFF, 0x2E, 0x18, 0xF7, 0xA8, + 0x7E, 0x1B, 0x70, 0x7A, 0x73, 0x37, 0x2F, 0x1A, 0x3F, 0x1A, 0x26, 0x2E, + 0x24, 0x00, 0xFF, 0x2E, 0x18, 0xF7, 0xA9, 0x7E, 0x1B, 0xE0, 0xBE, 0x64, + 0x00, 0x40, 0x78, 0x14, 0x7E, 0x73, 0x0E, 0x30, 0x0A, 0x17, 0x7E, 0x24, + 0x00, 0x03, 0x9D, 0x21, 0x7C, 0x65, 0x9C, 0xE6, 0x7A, 0x73, 0x0E, 0x2F, + 0xE4, 0x7E, 0x73, 0x37, 0x2F, 0x7C, 0x6E, 0x12, 0xC3, 0x6F, 0x3E, 0x64, + 0x0B, 0xF0, 0xBE, 0xF0, 0x06, 0x58, 0x03, 0x02, 0x7C, 0xFD, 0x7E, 0x37, + 0x0D, 0xF5, 0x7A, 0x37, 0x0D, 0xE9, 0xDA, 0x3B, 0x22, 0xCA, 0xD8, 0xCA, + 0x79, 0x7C, 0x45, 0x7C, 0xDB, 0x7D, 0x73, 0x7E, 0x50, 0x02, 0xAC, 0x45, + 0x7D, 0x37, 0x12, 0xF2, 0x4B, 0x4C, 0xDD, 0x78, 0x2E, 0x7E, 0x08, 0x2D, + 0x16, 0x7D, 0x37, 0x7E, 0x24, 0x00, 0x1C, 0x12, 0xF0, 0x0A, 0x7E, 0x73, + 0x2D, 0x0C, 0x0A, 0x37, 0x59, 0x37, 0x00, 0x1E, 0x7E, 0x73, 0x2D, 0x10, + 0x0A, 0x37, 0x59, 0x37, 0x00, 0x20, 0x7E, 0x73, 0x2D, 0x4E, 0x0A, 0x37, + 0x59, 0x37, 0x00, 0x22, 0x02, 0x7E, 0xC9, 0xBE, 0xD0, 0x01, 0x68, 0x03, + 0x02, 0x7E, 0x96, 0x7E, 0x73, 0x2D, 0x0B, 0x0A, 0x37, 0x1B, 0x78, 0x30, + 0x7E, 0x37, 0x2D, 0x14, 0x59, 0x37, 0x00, 0x02, 0x7E, 0x73, 0x2D, 0x70, + 0x0A, 0x37, 0x59, 0x37, 0x00, 0x04, 0x7E, 0x73, 0x2D, 0x10, 0x0A, 0x37, + 0x59, 0x37, 0x00, 0x06, 0x7E, 0x73, 0x2C, 0x8B, 0x0A, 0x37, 0x59, 0x37, + 0x00, 0x08, 0x7E, 0x37, 0x2C, 0xA6, 0x59, 0x37, 0x00, 0x0A, 0x7E, 0x73, + 0x2D, 0x81, 0x0A, 0x37, 0x59, 0x37, 0x00, 0x10, 0x7E, 0x73, 0x2D, 0x7D, + 0x0A, 0x37, 0x59, 0x37, 0x00, 0x12, 0x7E, 0x73, 0x2D, 0x84, 0x0A, 0x37, + 0x59, 0x37, 0x00, 0x14, 0x7E, 0x37, 0x2D, 0x85, 0x59, 0x37, 0x00, 0x16, + 0x7E, 0x37, 0x2D, 0x87, 0x59, 0x37, 0x00, 0x18, 0x7E, 0x37, 0x2D, 0x74, + 0x59, 0x37, 0x00, 0x1E, 0x7E, 0x73, 0x2D, 0x76, 0x0A, 0x37, 0x59, 0x37, + 0x00, 0x20, 0x7E, 0x73, 0x2D, 0x77, 0x0A, 0x37, 0x59, 0x37, 0x00, 0x22, + 0x7E, 0x73, 0x2D, 0x78, 0x0A, 0x37, 0x59, 0x37, 0x00, 0x24, 0x7E, 0x73, + 0x2D, 0x79, 0x0A, 0x37, 0x59, 0x37, 0x00, 0x26, 0x7E, 0x73, 0x2D, 0x7A, + 0x0A, 0x37, 0x59, 0x37, 0x00, 0x28, 0x7E, 0x73, 0x2D, 0x7B, 0x0A, 0x37, + 0x59, 0x37, 0x00, 0x2A, 0x80, 0x33, 0xBE, 0xD0, 0x02, 0x78, 0x1C, 0x6C, + 0x77, 0x0A, 0x27, 0x09, 0x62, 0x2C, 0xC4, 0x0A, 0x46, 0x7E, 0x50, 0x02, + 0xAC, 0x57, 0x2D, 0x27, 0x1B, 0x28, 0x40, 0x0B, 0x70, 0xA5, 0xBF, 0x0E, + 0xE8, 0x80, 0x12, 0xBE, 0xD0, 0x03, 0x78, 0x0D, 0x7E, 0x08, 0x2D, 0x32, + 0x7D, 0x37, 0x7E, 0x24, 0x00, 0x1C, 0x12, 0xF0, 0x0A, 0xDA, 0x79, 0xDA, + 0xD8, 0x22, 0xCA, 0x3B, 0x6C, 0xEE, 0x6C, 0xFF, 0x6C, 0xDD, 0x6C, 0xCC, + 0xA2, 0x20, 0xE4, 0x33, 0x78, 0x03, 0x02, 0x7F, 0xF7, 0x30, 0x00, 0x03, + 0x02, 0x7F, 0x99, 0x12, 0xE9, 0x26, 0x7C, 0xCB, 0xE5, 0x59, 0x60, 0x05, + 0xE5, 0x59, 0xB4, 0x02, 0x6E, 0xE5, 0x59, 0x12, 0xE3, 0x42, 0x70, 0x0F, + 0xE5, 0x59, 0x12, 0xCE, 0x3F, 0x7E, 0xF0, 0x01, 0xE4, 0x7A, 0xB3, 0x12, + 0xDD, 0x80, 0x4C, 0xE5, 0x59, 0x12, 0xE3, 0x05, 0xBE, 0xB0, 0x01, 0x68, + 0x03, 0x30, 0x0F, 0x05, 0x7E, 0xF0, 0x01, 0x80, 0x3A, 0x7E, 0x37, 0x2D, + 0xE1, 0x7E, 0x39, 0xB0, 0x30, 0xE0, 0x30, 0x7E, 0x73, 0x2D, 0x0D, 0xBE, + 0x73, 0x2D, 0x0B, 0x78, 0x06, 0x7E, 0xB3, 0x2D, 0x73, 0x60, 0x06, 0x74, + 0x0A, 0x7A, 0xB3, 0x12, 0xDD, 0x7E, 0xB3, 0x2C, 0x89, 0x60, 0x03, 0x7E, + 0xF0, 0x01, 0x7E, 0xB3, 0x12, 0xDD, 0xBE, 0xB0, 0x00, 0x28, 0x08, 0x14, + 0x7A, 0xB3, 0x12, 0xDD, 0x7E, 0xF0, 0x01, 0x4C, 0xFF, 0x68, 0x2E, 0x6D, + 0x33, 0x7A, 0x37, 0x18, 0xFC, 0x80, 0x26, 0xE5, 0x59, 0xBE, 0xB0, 0x01, + 0x68, 0x05, 0xE5, 0x59, 0xB4, 0x03, 0x1A, 0xE5, 0x59, 0x12, 0xE3, 0x05, + 0xBE, 0xB0, 0x01, 0x68, 0x03, 0x30, 0x0F, 0x03, 0x7E, 0xD0, 0x01, 0x4C, + 0xCC, 0x78, 0x04, 0x4C, 0xDD, 0x68, 0x02, 0xD2, 0x32, 0x4C, 0xFF, 0x78, + 0x04, 0x4C, 0xCC, 0x78, 0x05, 0xBE, 0xD0, 0x01, 0x78, 0x03, 0x7E, 0xE0, + 0x01, 0x7E, 0xA3, 0x2C, 0x78, 0x7C, 0x6A, 0x7E, 0x53, 0x2C, 0x64, 0x7C, + 0x45, 0x7E, 0x71, 0x59, 0xA5, 0xBE, 0xFF, 0x0D, 0xA5, 0xBC, 0xFF, 0x09, + 0x2E, 0xE0, 0xFF, 0x72, 0x21, 0x92, 0x21, 0x80, 0x3E, 0x6D, 0x11, 0x7A, + 0x17, 0x18, 0xFC, 0xBC, 0x46, 0x68, 0x34, 0xA5, 0xBD, 0xAA, 0x30, 0xA5, + 0xBE, 0xFF, 0x0A, 0x30, 0x01, 0x05, 0x7E, 0x60, 0x02, 0x80, 0x02, 0x6C, + 0x66, 0xBC, 0x67, 0x68, 0x1A, 0x4C, 0xFF, 0x78, 0x05, 0x7C, 0xB7, 0x30, + 0xE0, 0x07, 0x7C, 0xB7, 0x54, 0x01, 0xB4, 0x01, 0x0E, 0xD2, 0x21, 0x74, + 0xBB, 0x7A, 0xB3, 0x2C, 0x64, 0x80, 0x04, 0x7A, 0xA3, 0x2C, 0x64, 0xDA, + 0x3B, 0x22, 0xCA, 0x79, 0x7C, 0xF3, 0x7C, 0xE4, 0x7C, 0xA5, 0x7C, 0x3B, + 0x7D, 0x43, 0x0A, 0x23, 0x0A, 0x3A, 0x9D, 0x32, 0x0B, 0x34, 0x0A, 0xFE, + 0x0A, 0x2F, 0x9D, 0x2F, 0x0B, 0x24, 0x7C, 0x65, 0x7E, 0x20, 0x05, 0xBE, + 0x04, 0x04, 0x00, 0x58, 0x04, 0x6C, 0x22, 0x80, 0x2A, 0xBE, 0x04, 0x08, + 0x00, 0x58, 0x05, 0x7E, 0x20, 0x01, 0x80, 0x1F, 0xBE, 0x04, 0x10, 0x00, + 0x58, 0x05, 0x7E, 0x20, 0x02, 0x80, 0x14, 0xBE, 0x04, 0x20, 0x00, 0x58, + 0x05, 0x7E, 0x20, 0x03, 0x80, 0x09, 0xBE, 0x04, 0x40, 0x00, 0x58, 0x03, + 0x7E, 0x20, 0x04, 0x0A, 0x27, 0x7E, 0x40, 0x01, 0x7A, 0x27, 0xFF, 0xA2, + 0x7E, 0xB3, 0x05, 0x1A, 0x7C, 0x0B, 0x6C, 0x11, 0x0A, 0x26, 0x4D, 0x20, + 0x7A, 0x27, 0xFF, 0xA4, 0x6D, 0x22, 0x7A, 0x27, 0xFF, 0xA6, 0x0A, 0x22, + 0x7A, 0x27, 0xFF, 0xA8, 0x7E, 0x24, 0xC0, 0xC0, 0x7A, 0x27, 0xFF, 0xAA, + 0x7A, 0x47, 0xFF, 0xA0, 0x7E, 0x27, 0xFF, 0x00, 0x5E, 0x24, 0x00, 0x40, + 0x78, 0xF6, 0x7E, 0xB3, 0x05, 0x1A, 0x7C, 0x4B, 0x6C, 0x55, 0x0A, 0x06, + 0x4D, 0x02, 0x7A, 0x07, 0xFF, 0xA2, 0x0A, 0x07, 0x7E, 0x00, 0x01, 0x7A, + 0x07, 0xFF, 0xA4, 0x6D, 0x00, 0x7A, 0x07, 0xFF, 0xA6, 0x0A, 0x32, 0x7A, + 0x37, 0xFF, 0xA8, 0x7E, 0x34, 0xC1, 0x08, 0x7A, 0x37, 0xFF, 0xAA, 0x7A, + 0x47, 0xFF, 0xA0, 0x7E, 0x37, 0xFF, 0x00, 0x5E, 0x34, 0x00, 0x40, 0x78, + 0xF6, 0x7E, 0x34, 0xC0, 0xC0, 0x7C, 0xB3, 0x7C, 0x5A, 0x7E, 0x43, 0x05, + 0x1A, 0x0A, 0x14, 0x1B, 0x14, 0x7C, 0x43, 0x6C, 0x33, 0x12, 0x57, 0xC9, + 0x7D, 0x23, 0x7E, 0x37, 0x37, 0x64, 0x1B, 0x38, 0x20, 0x7E, 0x34, 0xC1, + 0x08, 0x7C, 0xBE, 0x7C, 0x5F, 0x7E, 0x43, 0x05, 0x1B, 0x0A, 0x14, 0x1B, + 0x14, 0x7C, 0x43, 0x7E, 0x30, 0x01, 0x12, 0x57, 0xC9, 0x7D, 0x23, 0x7E, + 0x37, 0x37, 0x66, 0x1B, 0x38, 0x20, 0x7E, 0x37, 0xC1, 0x0C, 0x1A, 0x26, + 0x7D, 0x03, 0x6D, 0x11, 0x7E, 0x37, 0xC1, 0x0E, 0x7D, 0x20, 0xBE, 0x18, + 0xFF, 0xFF, 0x28, 0x04, 0x7E, 0x18, 0xFF, 0xFF, 0xDA, 0x79, 0x22, 0xCA, + 0xF8, 0x7C, 0x17, 0x7E, 0x24, 0xC1, 0x50, 0x1A, 0x1B, 0x3E, 0x14, 0x3E, + 0x14, 0x3E, 0x14, 0x3E, 0x14, 0x2D, 0x21, 0x7D, 0x42, 0x6C, 0x66, 0x6C, + 0x00, 0x80, 0x16, 0x09, 0xB4, 0x00, 0x09, 0x70, 0x0A, 0x09, 0x34, 0x00, + 0x08, 0xBC, 0x36, 0x28, 0x02, 0x7C, 0x63, 0x2E, 0x44, 0x00, 0x10, 0x0B, + 0x00, 0xBC, 0x10, 0x18, 0xE6, 0x7C, 0xB6, 0xC4, 0x23, 0x54, 0x1F, 0x7C, + 0x6B, 0x7D, 0x42, 0x6C, 0x77, 0x6C, 0x00, 0x02, 0x82, 0x3C, 0x09, 0x54, + 0x00, 0x09, 0xA5, 0xBD, 0x00, 0x02, 0x80, 0x03, 0x02, 0x82, 0x22, 0x09, + 0x44, 0x00, 0x08, 0xBC, 0x46, 0x38, 0x03, 0x7E, 0x50, 0x01, 0xA5, 0xBC, + 0x01, 0x02, 0x80, 0x03, 0x02, 0x82, 0x22, 0x7E, 0x43, 0x05, 0x1A, 0x7E, + 0x33, 0x05, 0x1B, 0x7A, 0x33, 0x37, 0x56, 0x09, 0xF4, 0x00, 0x04, 0x7A, + 0xF3, 0x37, 0x57, 0x09, 0xB4, 0x00, 0x06, 0x7A, 0xB3, 0x37, 0x58, 0xAC, + 0xB4, 0x0A, 0xDF, 0x7D, 0xF5, 0x2D, 0xFD, 0x3E, 0xF4, 0x2E, 0xF7, 0x03, + 0x10, 0x6D, 0xEE, 0x0B, 0x7A, 0x10, 0xBE, 0xF0, 0x00, 0x28, 0x0D, 0x7F, + 0x57, 0x1B, 0xB5, 0x0B, 0x5A, 0x50, 0xBD, 0x51, 0x08, 0x02, 0x80, 0x53, + 0x0A, 0x54, 0x1B, 0x54, 0xBD, 0xD5, 0x58, 0x0A, 0x69, 0x57, 0x00, 0x02, + 0xBD, 0x51, 0x08, 0x02, 0x80, 0x41, 0x7E, 0xB3, 0x37, 0x58, 0xBE, 0xB0, + 0x00, 0x28, 0x17, 0x0A, 0x54, 0x6E, 0x54, 0xFF, 0xFF, 0x0B, 0x54, 0x3E, + 0x54, 0x7F, 0x67, 0x2D, 0xD5, 0x0B, 0x6A, 0x50, 0xBD, 0x51, 0x08, 0x02, + 0x80, 0x21, 0x7E, 0xB3, 0x37, 0x56, 0x0A, 0xDB, 0x1B, 0xD4, 0x7E, 0xB3, + 0x37, 0x58, 0x0A, 0x5B, 0xBD, 0x5D, 0x58, 0x12, 0x74, 0x02, 0xAC, 0xB4, + 0x7F, 0x67, 0x2D, 0xD5, 0x0B, 0x6A, 0x50, 0xBD, 0x51, 0x08, 0x03, 0x7E, + 0x50, 0x01, 0x4C, 0x55, 0x68, 0x08, 0x74, 0x01, 0x19, 0xB4, 0x00, 0x09, + 0x80, 0x08, 0x74, 0x02, 0x19, 0xB4, 0x00, 0x0B, 0x0B, 0x70, 0x2E, 0x44, + 0x00, 0x10, 0x0B, 0x00, 0xBC, 0x10, 0x08, 0x03, 0x02, 0x81, 0x6A, 0x7C, + 0xB7, 0xDA, 0xF8, 0x22, 0x12, 0xBF, 0x2C, 0x75, 0xBB, 0x00, 0x12, 0xF3, + 0xA6, 0x12, 0xF5, 0x0E, 0x75, 0xBB, 0x00, 0x12, 0xF5, 0x2F, 0x12, 0x48, + 0xD7, 0x75, 0xA8, 0x00, 0x00, 0x00, 0x85, 0x42, 0xE8, 0x75, 0xA8, 0x80, + 0x12, 0xF4, 0xA2, 0x75, 0xBB, 0x00, 0xE4, 0x12, 0xF4, 0x55, 0x12, 0xF1, + 0xEB, 0x75, 0xBB, 0x00, 0x12, 0x9B, 0xBF, 0x75, 0xBB, 0x00, 0x12, 0xF2, + 0x03, 0x75, 0xBB, 0x00, 0x12, 0x77, 0x69, 0x75, 0xBB, 0x00, 0x12, 0xF5, + 0x72, 0x75, 0xBB, 0x00, 0x12, 0xD1, 0xBF, 0x12, 0xE6, 0x0A, 0x75, 0xBB, + 0x00, 0x12, 0xEA, 0x3E, 0x7E, 0xB3, 0x2C, 0x5E, 0x12, 0xE4, 0x34, 0x75, + 0xA8, 0x00, 0x00, 0x00, 0x85, 0x62, 0xE8, 0x85, 0x53, 0xA8, 0x75, 0xBB, + 0x00, 0x12, 0xF5, 0xD0, 0x12, 0xC0, 0x43, 0xA2, 0x04, 0xE4, 0x33, 0xB4, + 0x01, 0x52, 0x74, 0x01, 0x12, 0xF1, 0x15, 0x75, 0x9A, 0x03, 0xE5, 0x9B, + 0x7A, 0xB3, 0x2C, 0x5B, 0x7E, 0x73, 0x2C, 0x5B, 0x0A, 0x27, 0xE5, 0x9B, + 0x0A, 0x3B, 0x9D, 0x32, 0xBE, 0x34, 0x00, 0x05, 0x48, 0xEE, 0x7E, 0x37, + 0x12, 0xE9, 0x2E, 0x34, 0x00, 0x10, 0x7E, 0x39, 0xB0, 0x44, 0x80, 0x7A, + 0x39, 0xB0, 0x74, 0x01, 0x12, 0xF4, 0x55, 0x75, 0x9A, 0x03, 0xE5, 0x9B, + 0x7A, 0xB3, 0x2C, 0x5B, 0x7E, 0x73, 0x2C, 0x5B, 0x0A, 0x27, 0xE5, 0x9B, + 0x0A, 0x3B, 0x9D, 0x32, 0xBE, 0x34, 0x00, 0x5F, 0x48, 0xEE, 0x80, 0x9E, + 0x12, 0xF5, 0x87, 0x60, 0x03, 0x12, 0xC1, 0xDD, 0x12, 0xED, 0x89, 0x60, + 0x03, 0x02, 0x82, 0x5D, 0x12, 0xF4, 0xBA, 0x60, 0x89, 0x20, 0x00, 0x05, + 0x12, 0xEF, 0x6B, 0x60, 0x81, 0x12, 0xE8, 0xF6, 0x70, 0x03, 0x02, 0x82, + 0xAE, 0x7E, 0x27, 0x12, 0xE9, 0x2E, 0x24, 0x00, 0x0A, 0x0B, 0x28, 0x30, + 0x0B, 0x34, 0x1B, 0x28, 0x30, 0x20, 0x00, 0x06, 0x12, 0x98, 0x56, 0x02, + 0x82, 0xAE, 0x20, 0x00, 0x03, 0x02, 0x82, 0xAE, 0x12, 0xF4, 0x47, 0x02, + 0x82, 0xAE, 0xCA, 0x3B, 0x7C, 0xAB, 0xE5, 0x46, 0x0A, 0x6B, 0x7E, 0x74, + 0x01, 0x80, 0xAD, 0x76, 0x2E, 0x74, 0x12, 0xF1, 0x7E, 0x64, 0x18, 0xFE, + 0x1B, 0xA0, 0x68, 0x1D, 0x1B, 0xA1, 0x68, 0x41, 0x2E, 0xA0, 0x03, 0x78, + 0x28, 0x74, 0x03, 0x7A, 0xB3, 0x37, 0x37, 0x74, 0x02, 0x7A, 0xB3, 0x37, + 0x38, 0x74, 0x02, 0x7A, 0xB3, 0x37, 0x39, 0x80, 0x3A, 0x74, 0x07, 0x7A, + 0xB3, 0x37, 0x37, 0x74, 0x03, 0x7A, 0xB3, 0x37, 0x38, 0x74, 0x04, 0x7A, + 0xB3, 0x37, 0x39, 0x80, 0x26, 0x74, 0x0F, 0x7A, 0xB3, 0x37, 0x37, 0x74, + 0x04, 0x7A, 0xB3, 0x37, 0x38, 0x74, 0x08, 0x7A, 0xB3, 0x37, 0x39, 0x80, + 0x12, 0x74, 0x1F, 0x7A, 0xB3, 0x37, 0x37, 0x74, 0x05, 0x7A, 0xB3, 0x37, + 0x38, 0x74, 0x10, 0x7A, 0xB3, 0x37, 0x39, 0x6D, 0x33, 0x7A, 0x37, 0x37, + 0x31, 0x02, 0x84, 0x56, 0x6D, 0x33, 0x7A, 0x37, 0x37, 0x2F, 0x80, 0x66, + 0x0B, 0x68, 0x30, 0x7A, 0x37, 0x37, 0x33, 0x0B, 0x78, 0x30, 0x7A, 0x37, + 0x37, 0x35, 0x12, 0xD6, 0x7D, 0x70, 0x09, 0x7E, 0x37, 0x37, 0x33, 0x1B, + 0x78, 0x30, 0x80, 0x3C, 0x7E, 0x37, 0x37, 0x35, 0x1A, 0x26, 0x1A, 0x24, + 0x7E, 0x33, 0x37, 0x37, 0x0A, 0x13, 0x6D, 0x00, 0x12, 0x8C, 0xBA, 0x7E, + 0x17, 0x37, 0x33, 0x1A, 0x02, 0x1A, 0x00, 0x2F, 0x01, 0x7E, 0x73, 0x37, + 0x39, 0x0A, 0x37, 0x6D, 0x22, 0x2F, 0x10, 0x7E, 0xB3, 0x37, 0x38, 0x60, + 0x0C, 0x1E, 0x34, 0x0E, 0x24, 0x50, 0x03, 0x4E, 0x60, 0x80, 0x14, 0x78, + 0xF4, 0x1B, 0x78, 0x30, 0x0B, 0x75, 0x0B, 0x65, 0x7E, 0x37, 0x37, 0x2F, + 0x0B, 0x34, 0x7A, 0x37, 0x37, 0x2F, 0xE5, 0x5F, 0x0A, 0x3B, 0xBE, 0x37, + 0x37, 0x2F, 0x38, 0x90, 0x7E, 0x37, 0x37, 0x31, 0x0B, 0x34, 0x7A, 0x37, + 0x37, 0x31, 0xE5, 0x43, 0x0A, 0x3B, 0xBE, 0x37, 0x37, 0x31, 0x28, 0x03, + 0x02, 0x83, 0xD4, 0xDA, 0x3B, 0x22, 0xCA, 0x3B, 0x7C, 0xE0, 0x7C, 0xF1, + 0x7C, 0xD2, 0x7C, 0xC3, 0x7C, 0x9B, 0x7D, 0xD2, 0x7D, 0xC3, 0x1B, 0x90, + 0x78, 0x05, 0x6D, 0x33, 0x02, 0x85, 0x6E, 0x7E, 0x87, 0x37, 0x89, 0x7D, + 0x18, 0x1A, 0x02, 0x1A, 0x00, 0x7D, 0x3C, 0x1A, 0x26, 0x1A, 0x24, 0x12, + 0x8C, 0xBA, 0x7C, 0x76, 0x7C, 0x65, 0x1A, 0x24, 0x0A, 0x19, 0x6D, 0x00, + 0x2F, 0x10, 0x12, 0x8D, 0x27, 0x7F, 0x51, 0x7D, 0xC8, 0x0E, 0xC4, 0x7D, + 0x3C, 0x1A, 0x26, 0x1A, 0x24, 0x9F, 0x51, 0x1A, 0x1D, 0x2E, 0x14, 0x01, + 0x00, 0x1A, 0x02, 0x1A, 0x00, 0x7F, 0x15, 0x12, 0x8C, 0xBA, 0x7C, 0x76, + 0x7C, 0x65, 0xBE, 0xF0, 0x00, 0x28, 0x5B, 0x0A, 0x4F, 0x7D, 0x1C, 0x9D, + 0x14, 0x6D, 0xFF, 0x9D, 0xF1, 0x7D, 0x2F, 0x1A, 0x24, 0x1A, 0xE4, 0xBF, + 0x57, 0x48, 0x08, 0x1A, 0x02, 0x1A, 0x00, 0xBF, 0x50, 0x08, 0x3F, 0xBE, + 0x58, 0x00, 0x00, 0x08, 0x06, 0x7D, 0x9C, 0x9D, 0x9B, 0x80, 0x04, 0x7D, + 0x9B, 0x2D, 0x9C, 0xBE, 0x94, 0x00, 0x00, 0x58, 0x02, 0x6D, 0x99, 0x9D, + 0x49, 0x7D, 0x13, 0x1A, 0x02, 0x1A, 0x00, 0x7D, 0x39, 0x1A, 0x26, 0x1A, + 0x24, 0x12, 0x8C, 0xBA, 0x7F, 0x71, 0x7D, 0x34, 0x1A, 0x28, 0x1A, 0x24, + 0x7F, 0x05, 0x12, 0x8C, 0xBA, 0x2F, 0x17, 0x0A, 0x1F, 0x6D, 0x00, 0x12, + 0x8D, 0x27, 0xE4, 0x7E, 0x27, 0x37, 0x8D, 0x7A, 0x29, 0xB0, 0x2D, 0x3C, + 0x1A, 0x2E, 0xBD, 0x23, 0x08, 0x0D, 0x4C, 0xEE, 0x68, 0x09, 0x74, 0x01, + 0x7E, 0x27, 0x37, 0x8D, 0x7A, 0x29, 0xB0, 0x7E, 0xB3, 0x37, 0x8C, 0x1A, + 0xCB, 0x7E, 0x27, 0x37, 0x89, 0x9D, 0x2C, 0xBD, 0x23, 0x58, 0x0B, 0x60, + 0x09, 0x74, 0x01, 0x7E, 0x27, 0x37, 0x8D, 0x7A, 0x29, 0xB0, 0x1A, 0x2C, + 0x2D, 0x32, 0xBE, 0x34, 0x00, 0x00, 0x58, 0x02, 0x6D, 0x33, 0x1B, 0xD4, + 0xBD, 0xD3, 0x58, 0x02, 0x7D, 0x3D, 0xDA, 0x3B, 0x22, 0xCA, 0x3B, 0x7E, + 0x64, 0xC1, 0x5C, 0x6C, 0xFF, 0x6C, 0xEE, 0x1A, 0x3E, 0x09, 0xB3, 0x07, + 0x27, 0x60, 0x07, 0xBE, 0xB0, 0x05, 0x68, 0x02, 0x7C, 0xFE, 0x0B, 0xE0, + 0xBE, 0xE0, 0x0A, 0x48, 0xEA, 0x0B, 0xF0, 0xBE, 0xF3, 0x03, 0xB6, 0x50, + 0x04, 0x7E, 0xF3, 0x03, 0xB6, 0x6C, 0xEE, 0x02, 0x86, 0x70, 0x1A, 0x3E, + 0x09, 0xB3, 0x07, 0x27, 0x70, 0x03, 0x02, 0x86, 0x53, 0xBE, 0xB0, 0x05, + 0x78, 0x03, 0x02, 0x86, 0x53, 0x7C, 0xBE, 0x7E, 0x34, 0x37, 0x4A, 0x7E, + 0x24, 0x37, 0x4C, 0x12, 0xC8, 0x00, 0x7E, 0x34, 0x03, 0x52, 0x7A, 0x37, + 0x37, 0x50, 0xE4, 0x80, 0x4D, 0x7E, 0x27, 0x37, 0x50, 0x0B, 0x28, 0x30, + 0x0B, 0x25, 0x7A, 0x27, 0x37, 0x50, 0x7A, 0x37, 0x37, 0x46, 0x7E, 0x27, + 0x37, 0x50, 0x0B, 0x28, 0x30, 0x0B, 0x25, 0x7A, 0x27, 0x37, 0x50, 0x7A, + 0x37, 0x37, 0x48, 0x7E, 0x37, 0x37, 0x50, 0x0B, 0x35, 0x7A, 0x37, 0x37, + 0x50, 0x7E, 0x37, 0x37, 0x46, 0x7E, 0x27, 0x37, 0x48, 0x7E, 0x17, 0x37, + 0x4A, 0x7E, 0x07, 0x37, 0x4C, 0x12, 0xF1, 0x4D, 0x7A, 0x37, 0x37, 0x4E, + 0x1B, 0x68, 0x30, 0x0B, 0x65, 0x7E, 0xB3, 0x37, 0x45, 0x04, 0x7A, 0xB3, + 0x37, 0x45, 0x7E, 0x73, 0x03, 0xB6, 0xBE, 0x73, 0x37, 0x45, 0x38, 0xA5, + 0x80, 0x21, 0x1A, 0x3E, 0x09, 0xB3, 0x07, 0x27, 0xB4, 0x01, 0x06, 0x7E, + 0x34, 0x1F, 0x40, 0x80, 0x04, 0x7E, 0x34, 0x20, 0x00, 0x1B, 0x68, 0x30, + 0x0B, 0x65, 0x7E, 0xB3, 0x37, 0x45, 0x04, 0x7A, 0xB3, 0x37, 0x45, 0xBE, + 0xF3, 0x37, 0x45, 0x18, 0xD9, 0x80, 0x1B, 0xE4, 0x80, 0x0E, 0x7E, 0x34, + 0x20, 0x00, 0x1B, 0x68, 0x30, 0x0B, 0x65, 0x7E, 0xB3, 0x37, 0x45, 0x04, + 0x7A, 0xB3, 0x37, 0x45, 0xBE, 0xF3, 0x37, 0x45, 0x18, 0xE8, 0x0B, 0xE0, + 0xBC, 0xFE, 0x08, 0x03, 0x02, 0x85, 0xA2, 0x7C, 0xBF, 0xDA, 0x3B, 0x22, + 0xCA, 0xF8, 0xE5, 0xEF, 0x7A, 0xB3, 0x2C, 0x5A, 0x7E, 0xB3, 0x2C, 0x5A, + 0x64, 0xFF, 0xF5, 0xEF, 0x75, 0xBB, 0x00, 0x74, 0xFF, 0x7A, 0xB3, 0x12, + 0xEC, 0x7E, 0xB3, 0x28, 0x1D, 0x60, 0x08, 0x74, 0x01, 0x7A, 0xB3, 0x12, + 0xEC, 0x80, 0x55, 0x7E, 0xA3, 0x2C, 0x5A, 0x7C, 0xBA, 0x30, 0xE3, 0x0A, + 0xD2, 0x04, 0x74, 0x01, 0x7A, 0xB3, 0x12, 0xEC, 0x80, 0x42, 0x0A, 0x3A, + 0x5E, 0x34, 0x00, 0x03, 0x68, 0x3A, 0xD2, 0x37, 0x30, 0x17, 0x26, 0x30, + 0x01, 0x23, 0x7E, 0x37, 0x2D, 0xE3, 0x2E, 0x34, 0x00, 0x0B, 0x7E, 0x39, + 0xB0, 0x54, 0x1F, 0x68, 0x14, 0x7E, 0x37, 0x2D, 0xE3, 0x2E, 0x34, 0x00, + 0x0C, 0x7E, 0x39, 0xB0, 0x6C, 0x77, 0x12, 0xEE, 0xC6, 0xD2, 0x33, 0xD2, + 0x34, 0x74, 0x02, 0x7A, 0xB3, 0x12, 0xEC, 0x20, 0x0E, 0x03, 0x12, 0xCC, + 0x84, 0x12, 0xF5, 0xC6, 0x7E, 0xB3, 0x12, 0xEC, 0xB4, 0x02, 0x45, 0x12, + 0x93, 0x0F, 0xD2, 0x2B, 0xB4, 0x01, 0x37, 0x74, 0x01, 0x12, 0xDC, 0x9B, + 0xD2, 0x22, 0xE5, 0x5B, 0x60, 0x05, 0xE5, 0x5B, 0xB4, 0x01, 0x2D, 0x6C, + 0xFF, 0x30, 0x0E, 0x04, 0x7E, 0xF3, 0x2C, 0x3F, 0x7E, 0xB3, 0x12, 0xE7, + 0x7C, 0x7F, 0x12, 0x8B, 0x8C, 0x7C, 0xFB, 0x12, 0xEF, 0xEB, 0x4C, 0xFF, + 0x68, 0x12, 0x7E, 0xB3, 0x12, 0xE7, 0x12, 0x68, 0xF6, 0x12, 0x6C, 0x19, + 0x80, 0x06, 0x74, 0x01, 0x7A, 0xB3, 0x12, 0xEC, 0x7E, 0xB3, 0x12, 0xEC, + 0xB4, 0x01, 0x38, 0x7E, 0x27, 0x2D, 0xED, 0x0B, 0x26, 0x0B, 0x28, 0x30, + 0x4E, 0x60, 0x02, 0x1B, 0x28, 0x30, 0x7E, 0x37, 0x2D, 0xED, 0x0B, 0x36, + 0x0B, 0x38, 0x30, 0x7A, 0x37, 0xF0, 0x04, 0x7E, 0x27, 0x2D, 0xED, 0x0B, + 0x26, 0x0B, 0x28, 0x30, 0x5E, 0x60, 0xFD, 0x1B, 0x28, 0x30, 0x7E, 0x37, + 0x2D, 0xED, 0x0B, 0x36, 0x0B, 0x38, 0x30, 0x7A, 0x37, 0xF0, 0x04, 0xDA, + 0xF8, 0x22, 0xCA, 0x3B, 0x7A, 0x27, 0x37, 0x32, 0x7A, 0x37, 0x37, 0x30, + 0x7C, 0x5B, 0x7F, 0x30, 0x7E, 0x17, 0x3B, 0x52, 0x7E, 0x07, 0x3B, 0x50, + 0x7A, 0x07, 0x37, 0x34, 0x4C, 0x55, 0x78, 0x03, 0x02, 0x88, 0x32, 0x7E, + 0x3B, 0xA0, 0x4C, 0xAA, 0x78, 0x26, 0x7E, 0x37, 0x37, 0x30, 0x79, 0x33, + 0x00, 0x05, 0x79, 0x33, 0x00, 0x01, 0x7E, 0x37, 0x37, 0x32, 0x79, 0x33, + 0x00, 0x07, 0x79, 0x33, 0x00, 0x03, 0x74, 0x08, 0x39, 0xB3, 0x00, 0x09, + 0x74, 0x10, 0x7A, 0x3B, 0xB0, 0x02, 0x88, 0x8B, 0xBE, 0xA0, 0x10, 0x68, + 0x03, 0x02, 0x88, 0x8B, 0x69, 0x03, 0x00, 0x05, 0x7A, 0x07, 0x37, 0x3C, + 0x69, 0x03, 0x00, 0x07, 0x7A, 0x07, 0x37, 0x3E, 0x74, 0x01, 0x7D, 0x31, + 0x7D, 0x21, 0x7E, 0x17, 0x37, 0x30, 0x7E, 0x07, 0x37, 0x32, 0x12, 0xA8, + 0x5E, 0x7C, 0x6B, 0xBE, 0x60, 0x08, 0x78, 0x03, 0x02, 0x88, 0x8B, 0x29, + 0x73, 0x00, 0x09, 0xA5, 0xBF, 0x08, 0x06, 0x39, 0x63, 0x00, 0x09, 0x80, + 0x0B, 0xBC, 0x76, 0x68, 0x07, 0x74, 0x34, 0x7A, 0x3B, 0xB0, 0x80, 0x6B, + 0x7E, 0x37, 0x37, 0x30, 0x79, 0x33, 0x00, 0x05, 0x7E, 0x37, 0x37, 0x32, + 0x79, 0x33, 0x00, 0x07, 0x80, 0x59, 0x7E, 0x3B, 0xB0, 0xB4, 0x10, 0x43, + 0x29, 0xA3, 0x00, 0x09, 0x7C, 0xBA, 0x54, 0x09, 0x68, 0x12, 0xBE, 0xA0, + 0x08, 0x78, 0x05, 0x7E, 0x70, 0x32, 0x80, 0x03, 0x7E, 0x70, 0x34, 0x7A, + 0x3B, 0x70, 0x80, 0x37, 0x69, 0x33, 0x00, 0x01, 0x69, 0x23, 0x00, 0x03, + 0x69, 0x13, 0x00, 0x05, 0x69, 0x03, 0x00, 0x07, 0x12, 0xF2, 0xCE, 0xBE, + 0x37, 0x37, 0x34, 0x50, 0x07, 0x74, 0x33, 0x7A, 0x3B, 0xB0, 0x80, 0x17, + 0x74, 0x20, 0x7A, 0x3B, 0xB0, 0x80, 0x10, 0x7E, 0xB3, 0x3B, 0x80, 0x70, + 0x0A, 0x7E, 0xB3, 0x3B, 0x7F, 0x70, 0x04, 0xE4, 0x7A, 0x3B, 0xB0, 0xDA, + 0x3B, 0x22, 0x7C, 0xA6, 0x7C, 0x27, 0x7C, 0x3B, 0x7E, 0x44, 0xE0, 0x00, + 0x4C, 0xAA, 0x78, 0x0F, 0xBE, 0x33, 0x12, 0xE4, 0x78, 0x09, 0xBE, 0x23, + 0x12, 0xDE, 0x78, 0x03, 0x02, 0x89, 0x8E, 0x7A, 0x33, 0x12, 0xE4, 0x7A, + 0x23, 0x12, 0xDE, 0x7C, 0x02, 0x6C, 0x11, 0x0A, 0x53, 0xC4, 0x54, 0xF0, + 0x7C, 0xAB, 0xE4, 0x4D, 0x05, 0x7A, 0x07, 0xF5, 0x0A, 0x7E, 0x10, 0x20, + 0xAC, 0x13, 0x2D, 0x04, 0x49, 0x30, 0x00, 0x04, 0x5E, 0x34, 0x00, 0x03, + 0x3E, 0x34, 0x3E, 0x34, 0x3E, 0x34, 0x3E, 0x34, 0x3E, 0x34, 0x3E, 0x34, + 0x7E, 0x27, 0x2D, 0xE9, 0x2E, 0x24, 0x00, 0x10, 0x0B, 0x28, 0x50, 0x5E, + 0x54, 0x7F, 0x00, 0x2D, 0x53, 0x49, 0x00, 0x00, 0x02, 0x5E, 0x04, 0x00, + 0x3F, 0x2D, 0x05, 0x7A, 0x07, 0xF2, 0x66, 0x7E, 0x10, 0x20, 0xAC, 0x13, + 0x2D, 0x04, 0x49, 0x00, 0x00, 0x06, 0x5E, 0x00, 0x0F, 0x7D, 0x50, 0x7C, + 0xAB, 0xE4, 0x7A, 0x57, 0xF2, 0x08, 0x30, 0x03, 0x03, 0x4E, 0x00, 0x01, + 0x7A, 0x07, 0xF2, 0x06, 0x7E, 0x10, 0x20, 0xAC, 0x13, 0x2D, 0x04, 0x49, + 0x50, 0x00, 0x06, 0x0A, 0x5A, 0xC4, 0x03, 0x7D, 0x05, 0x5E, 0x04, 0x00, + 0x07, 0x3E, 0x04, 0x3E, 0x04, 0x3E, 0x04, 0x3E, 0x04, 0x3E, 0x04, 0x2E, + 0x04, 0x00, 0xE0, 0x7A, 0x07, 0xF5, 0x18, 0x7E, 0x10, 0x20, 0xAC, 0x13, + 0x2D, 0x04, 0x49, 0x00, 0x00, 0x0E, 0x7A, 0x07, 0xF5, 0x12, 0x7E, 0x10, + 0x20, 0xAC, 0x13, 0x2D, 0x04, 0x49, 0x00, 0x00, 0x16, 0x7A, 0x07, 0xF2, + 0x28, 0x7E, 0x10, 0x20, 0xAC, 0x13, 0x2D, 0x04, 0x49, 0x00, 0x00, 0x16, + 0x7A, 0x07, 0xF2, 0x2A, 0x30, 0x0F, 0x03, 0x30, 0x01, 0x00, 0xE4, 0x7C, + 0x73, 0x7C, 0x62, 0x12, 0xE7, 0xF8, 0x12, 0xE5, 0xD1, 0x74, 0x01, 0x12, + 0xEE, 0xA5, 0xE4, 0x12, 0xEE, 0xA5, 0x22, 0xCA, 0x3B, 0x7C, 0xFB, 0x7E, + 0x37, 0x2D, 0xE3, 0x2E, 0x34, 0x00, 0x0B, 0x7E, 0x39, 0xB0, 0x54, 0x1F, + 0x0A, 0x3B, 0x0B, 0x34, 0x7C, 0xE7, 0x7E, 0x67, 0x2D, 0xE3, 0x2E, 0x64, + 0x00, 0x0B, 0x02, 0x8A, 0x83, 0x0A, 0x3E, 0x2D, 0x36, 0x7E, 0x39, 0xA0, + 0x7C, 0xBA, 0xC4, 0x03, 0x54, 0x07, 0x7A, 0xB3, 0x39, 0x0D, 0x7C, 0xBA, + 0x54, 0x1F, 0x7A, 0xB3, 0x39, 0x0E, 0x78, 0x03, 0x02, 0x8A, 0x8B, 0x0B, + 0xE0, 0xE4, 0x7A, 0xB3, 0x39, 0x0F, 0x02, 0x8A, 0x76, 0x0A, 0x3E, 0x2D, + 0x36, 0x7E, 0x39, 0x40, 0x6C, 0x55, 0x09, 0x73, 0x00, 0x01, 0x0A, 0x37, + 0x2D, 0x32, 0x7A, 0x37, 0x39, 0x12, 0x0B, 0xE1, 0x0A, 0x3E, 0x2D, 0x36, + 0x7E, 0x39, 0x70, 0x7A, 0x73, 0x39, 0x10, 0x0B, 0xE0, 0xBE, 0xF3, 0x39, + 0x0D, 0x78, 0x64, 0x7E, 0x57, 0x39, 0x12, 0xBE, 0x54, 0xF0, 0x00, 0x50, + 0x15, 0x0A, 0x1E, 0x2D, 0x16, 0x6D, 0x00, 0x7E, 0xA3, 0x39, 0x10, 0x0A, + 0x3A, 0x0B, 0x34, 0x0E, 0x34, 0x12, 0xE1, 0xC7, 0x80, 0x45, 0xE4, 0x7A, + 0xB3, 0x39, 0x11, 0x80, 0x34, 0x0A, 0x3E, 0x7E, 0x53, 0x39, 0x11, 0x0A, + 0x25, 0x2D, 0x23, 0x2D, 0x26, 0x7E, 0x29, 0x60, 0x6C, 0x77, 0x09, 0x52, + 0x00, 0x01, 0x0A, 0x25, 0x2D, 0x23, 0x7A, 0x27, 0x39, 0x14, 0x7E, 0x73, + 0x39, 0x11, 0x0A, 0x37, 0x2E, 0x37, 0x39, 0x12, 0x1B, 0x38, 0x20, 0x7E, + 0xB3, 0x39, 0x11, 0x0B, 0xB1, 0x7A, 0xB3, 0x39, 0x11, 0x7E, 0x73, 0x39, + 0x10, 0xBE, 0x73, 0x39, 0x11, 0x38, 0xC2, 0x7E, 0x73, 0x39, 0x10, 0x2C, + 0xE7, 0x7E, 0xB3, 0x39, 0x0F, 0x04, 0x7A, 0xB3, 0x39, 0x0F, 0x7E, 0x73, + 0x39, 0x0E, 0xBE, 0x73, 0x39, 0x0F, 0x28, 0x03, 0x02, 0x89, 0xD9, 0xBE, + 0xE0, 0x40, 0x50, 0x03, 0x02, 0x89, 0xB1, 0xDA, 0x3B, 0x22, 0xCA, 0xD8, + 0xCA, 0x79, 0xC2, 0x42, 0x7E, 0x73, 0x0A, 0x9E, 0x7A, 0x73, 0x37, 0x3F, + 0x7E, 0x73, 0x0A, 0x9F, 0x7A, 0x73, 0x37, 0x40, 0x7E, 0x73, 0x0A, 0xA0, + 0x7A, 0x73, 0x37, 0x41, 0x7E, 0x34, 0x37, 0x2F, 0x12, 0x3D, 0x5E, 0x7E, + 0x34, 0x37, 0x2F, 0x12, 0xEB, 0xD3, 0x7E, 0x08, 0x37, 0x2F, 0x12, 0xD9, + 0x2F, 0xE5, 0x52, 0x30, 0xE4, 0x10, 0x74, 0x10, 0x6C, 0x77, 0x12, 0xB8, + 0xCC, 0x7D, 0x73, 0x12, 0x46, 0x1F, 0x7A, 0xB3, 0x0D, 0xBB, 0xE5, 0x52, + 0x30, 0xE1, 0x57, 0x74, 0x02, 0x6C, 0x77, 0x12, 0xB8, 0xCC, 0x7D, 0x73, + 0x7E, 0xD1, 0x60, 0x7D, 0x37, 0x74, 0x01, 0x7C, 0x5D, 0x12, 0x59, 0x91, + 0x12, 0x4D, 0xCE, 0xE5, 0x50, 0x60, 0x14, 0xE5, 0x46, 0x7E, 0x34, 0x0D, + 0xE1, 0x7E, 0x27, 0x2D, 0xD9, 0x2E, 0x24, 0x00, 0x17, 0x7E, 0x29, 0x50, + 0x12, 0xB0, 0x9C, 0x7D, 0x37, 0x74, 0x01, 0x7C, 0x5D, 0x6C, 0x44, 0x12, + 0xB4, 0x7C, 0x24, 0xFF, 0x92, 0x42, 0xE5, 0x50, 0x60, 0x14, 0xE5, 0x46, + 0x7E, 0x34, 0x0D, 0xE1, 0x7E, 0x27, 0x2D, 0xD9, 0x2E, 0x24, 0x00, 0x17, + 0x7E, 0x29, 0x50, 0x12, 0xD4, 0x57, 0x6C, 0xDD, 0xA2, 0x15, 0xE4, 0x33, + 0x68, 0x0E, 0xA2, 0x16, 0xE4, 0x33, 0x78, 0x05, 0x7E, 0xD0, 0x01, 0x80, + 0x03, 0x7E, 0xD0, 0x02, 0x74, 0x20, 0x6C, 0x77, 0x12, 0xB8, 0xCC, 0x7D, + 0x13, 0x6D, 0x00, 0xCA, 0x0B, 0x74, 0x20, 0x7E, 0x70, 0x01, 0x12, 0xB8, + 0xCC, 0x6D, 0x22, 0xCA, 0x1B, 0x74, 0x02, 0x6C, 0x77, 0x12, 0xB8, 0xCC, + 0x6D, 0x22, 0x7A, 0xD3, 0x37, 0x45, 0x74, 0x01, 0x7A, 0xB3, 0x37, 0x4A, + 0xE5, 0x60, 0x7A, 0xB3, 0x37, 0x4B, 0xE5, 0x46, 0x7A, 0x1F, 0x37, 0x46, + 0xDA, 0x1B, 0xDA, 0x0B, 0x12, 0x11, 0x19, 0xDA, 0x79, 0xDA, 0xD8, 0x22, + 0xCA, 0x3B, 0x7C, 0xA7, 0x7C, 0xFB, 0x7E, 0x64, 0x3A, 0x7C, 0x09, 0xB6, + 0x00, 0x06, 0x70, 0x13, 0x4C, 0xAA, 0x68, 0x0F, 0x19, 0xA6, 0x00, 0x06, + 0x09, 0xB6, 0x00, 0x01, 0x60, 0x05, 0x74, 0x01, 0x7A, 0x69, 0xB0, 0x09, + 0xB6, 0x00, 0x09, 0x70, 0x04, 0xE4, 0x02, 0x8C, 0x85, 0x7C, 0xBF, 0x09, + 0x76, 0x00, 0x11, 0x12, 0xF3, 0x80, 0x7C, 0xEB, 0x7C, 0xBF, 0x09, 0x76, + 0x00, 0x12, 0x12, 0xF3, 0x80, 0x7C, 0x6B, 0x6C, 0x77, 0x09, 0xB6, 0x00, + 0x0B, 0x70, 0x05, 0xBE, 0x60, 0x01, 0x68, 0x0A, 0xE4, 0x19, 0xB6, 0x00, + 0x0C, 0x7E, 0x70, 0x01, 0x80, 0x30, 0x09, 0x66, 0x00, 0x01, 0xBC, 0x6E, + 0x78, 0x05, 0x7E, 0x70, 0x01, 0x80, 0x23, 0x09, 0x36, 0x00, 0x0D, 0x09, + 0xB6, 0x00, 0x02, 0x70, 0x02, 0x0B, 0x30, 0xAC, 0x36, 0x09, 0x66, 0x00, + 0x53, 0x1A, 0x26, 0x3E, 0x24, 0x3E, 0x24, 0x3E, 0x24, 0x3E, 0x24, 0xBD, + 0x21, 0x08, 0x03, 0x7E, 0x70, 0x01, 0x4C, 0x77, 0x68, 0x13, 0xE4, 0x19, + 0xB6, 0x00, 0x0D, 0xE4, 0x19, 0xB6, 0x00, 0x0E, 0xE4, 0x19, 0xB6, 0x00, + 0x04, 0x19, 0xF6, 0x00, 0x11, 0x19, 0xF6, 0x00, 0x12, 0x74, 0x01, 0x19, + 0xB6, 0x00, 0x03, 0x09, 0x66, 0x00, 0x01, 0x7D, 0x26, 0x0B, 0x26, 0x7E, + 0x29, 0x70, 0x2C, 0x76, 0x7A, 0x29, 0x70, 0x7D, 0x36, 0x0B, 0x36, 0x7E, + 0x39, 0xB0, 0x54, 0x0F, 0x7A, 0x39, 0xB0, 0x09, 0xB6, 0x00, 0x04, 0x70, + 0x0E, 0x09, 0x76, 0x00, 0x01, 0x19, 0x76, 0x00, 0x04, 0x74, 0x01, 0x19, + 0xB6, 0x00, 0x07, 0x09, 0xB6, 0x00, 0x04, 0x09, 0x76, 0x00, 0x06, 0xAC, + 0xB7, 0x2E, 0x54, 0x00, 0x08, 0x1E, 0x54, 0x1E, 0x54, 0x1E, 0x54, 0x1E, + 0x54, 0x19, 0xB6, 0x00, 0x05, 0x0A, 0x5B, 0x1B, 0x55, 0xDA, 0x3B, 0x22, + 0xC2, 0xD5, 0x7C, 0xB4, 0x30, 0xE7, 0x08, 0xB2, 0xD5, 0x6E, 0x24, 0xFF, + 0xFF, 0x0B, 0x24, 0x7C, 0xB6, 0x30, 0xE7, 0x12, 0xB2, 0xD5, 0x6E, 0x34, + 0xFF, 0xFF, 0x0B, 0x34, 0x8D, 0x32, 0x6E, 0x24, 0xFF, 0xFF, 0x0B, 0x24, + 0x80, 0x02, 0x8D, 0x32, 0x30, 0xD5, 0x06, 0x6E, 0x34, 0xFF, 0xFF, 0x0B, + 0x34, 0x22, 0x7D, 0x51, 0xAD, 0x03, 0x7D, 0x02, 0x7D, 0x21, 0xAD, 0x05, + 0x2D, 0x12, 0xAD, 0x35, 0x2D, 0x21, 0x22, 0x7D, 0x02, 0xAD, 0x31, 0xAD, + 0x10, 0x2D, 0x21, 0x22, 0x6D, 0x00, 0x74, 0x10, 0x4D, 0x00, 0x78, 0x0B, + 0x4D, 0x22, 0x78, 0x27, 0x8D, 0x31, 0x7D, 0x12, 0x6D, 0x22, 0x22, 0x7D, + 0x43, 0x7D, 0x32, 0x6D, 0x22, 0x2F, 0x11, 0x2D, 0x44, 0x50, 0x02, 0xA5, + 0x0F, 0xBF, 0x10, 0x40, 0x04, 0x9F, 0x10, 0x0B, 0x90, 0x14, 0x78, 0xED, + 0x7F, 0x01, 0x6D, 0x22, 0x7D, 0x34, 0x22, 0x7D, 0x41, 0x7D, 0x13, 0x8D, + 0x24, 0x7D, 0x02, 0x2F, 0x00, 0x40, 0x04, 0xBD, 0x04, 0x40, 0x04, 0x9D, + 0x04, 0x0B, 0x14, 0x14, 0x78, 0xF1, 0x7D, 0x23, 0x7D, 0x31, 0x7D, 0x10, + 0x6D, 0x00, 0x22, 0xC2, 0xD5, 0x7C, 0xB0, 0x30, 0xE7, 0x08, 0xB2, 0xD5, + 0x9F, 0x22, 0x9F, 0x20, 0x7F, 0x02, 0x7C, 0xB4, 0x30, 0xE7, 0x13, 0xB2, + 0xD5, 0x9F, 0x22, 0x9F, 0x21, 0x7F, 0x12, 0x12, 0x8C, 0xD6, 0x9F, 0x22, + 0x9F, 0x20, 0x7F, 0x02, 0x80, 0x03, 0x12, 0x8C, 0xD6, 0x30, 0xD5, 0x06, + 0x9F, 0x22, 0x9F, 0x21, 0x7F, 0x12, 0x22, 0x6C, 0xAA, 0x4D, 0x11, 0x68, + 0x1E, 0x1E, 0x54, 0x50, 0x0C, 0x7E, 0x1B, 0x00, 0x7A, 0x19, 0x00, 0x68, + 0x12, 0x0B, 0x1C, 0x0B, 0x14, 0x0B, 0x1A, 0x00, 0x1B, 0x18, 0x00, 0x0B, + 0x1D, 0x0B, 0x15, 0x1B, 0x54, 0x78, 0xF2, 0x22, 0x6D, 0xE0, 0x9D, 0xC9, + 0xE4, 0x0E, 0x5D, 0x23, 0xBB, 0x70, 0x5C, 0xB2, 0x82, 0x6A, 0x69, 0xCD, + 0xB3, 0xE3, 0x9D, 0x91, 0x05, 0xD3, 0xEC, 0xBF, 0x98, 0x56, 0x56, 0x3C, + 0x64, 0xF2, 0x40, 0x0A, 0xFA, 0xD3, 0x3D, 0x8B, 0x23, 0x9D, 0x3F, 0x77, + 0x4A, 0x16, 0x04, 0x2F, 0xCE, 0xDF, 0xAF, 0x6E, 0x38, 0x5D, 0x67, 0x93, + 0xC4, 0x9B, 0x6E, 0x5A, 0x71, 0xCE, 0x7E, 0xDC, 0x58, 0x2F, 0x71, 0x30, + 0x9E, 0x64, 0x6A, 0x6A, 0x37, 0x2E, 0x18, 0xF5, 0xBB, 0xF8, 0xC6, 0xEB, + 0xA9, 0x30, 0x49, 0x67, 0xB8, 0x51, 0x7C, 0x8B, 0x1E, 0xAA, 0x69, 0xA2, + 0xF0, 0xC2, 0x51, 0x20, 0x07, 0x56, 0x94, 0x62, 0x71, 0xE4, 0xD4, 0x78, + 0x85, 0xB1, 0xB3, 0xD5, 0x07, 0x52, 0x18, 0xAE, 0xE5, 0x85, 0x59, 0xF2, + 0x29, 0x02, 0x35, 0x8E, 0x6F, 0x01, 0xF5, 0x70, 0x2B, 0xA0, 0xA9, 0x8C, + 0x7B, 0xE5, 0xD6, 0x3E, 0x43, 0x86, 0xFE, 0x4E, 0x66, 0x3E, 0xF3, 0x12, + 0x59, 0x3F, 0xBD, 0xBF, 0x4A, 0x2E, 0x95, 0x0D, 0xB3, 0x95, 0x3E, 0xB5, + 0x8B, 0x48, 0xBF, 0x64, 0xE4, 0xB4, 0x3C, 0xAC, 0xB5, 0x7B, 0x77, 0x9F, + 0x14, 0xE4, 0x3F, 0x88, 0xA7, 0x8A, 0x4E, 0x6C, 0x10, 0xC1, 0x55, 0x6B, + 0x10, 0x9A, 0xC6, 0x77, 0x32, 0x15, 0x19, 0x21, 0x3A, 0xC9, 0x85, 0x5E, + 0x16, 0x35, 0x8D, 0x90, 0x2A, 0xDB, 0x4A, 0xAB, 0x1D, 0x7A, 0xC1, 0xC4, + 0x8A, 0xF4, 0x4B, 0xE8, 0x40, 0xBD, 0x4E, 0x83, 0xE5, 0x61, 0x4E, 0x38, + 0x37, 0xEF, 0x9A, 0x70, 0x36, 0x75, 0x99, 0x86, 0x6E, 0x38, 0xF6, 0xC9, + 0xC0, 0x70, 0xB8, 0xC9, 0x47, 0x27, 0x04, 0xA8, 0xC2, 0x7E, 0x89, 0xCE, + 0xB0, 0x7D, 0x6C, 0xDA, 0x6C, 0xBD, 0x1C, 0x96, 0x12, 0xBE, 0x09, 0xCA, + 0x3B, 0x7C, 0x92, 0x7C, 0x83, 0x7D, 0xF2, 0x7C, 0xFB, 0x7D, 0xE3, 0x7A, + 0x83, 0x37, 0x55, 0x7D, 0xD3, 0x1A, 0xCF, 0x2E, 0xC4, 0x04, 0x90, 0x7D, + 0xB3, 0x6C, 0xEE, 0xBC, 0x9E, 0x18, 0x33, 0x7E, 0xC9, 0x70, 0x7A, 0x73, + 0x37, 0x56, 0xBE, 0x70, 0x00, 0x08, 0x25, 0x0B, 0xB8, 0x60, 0x7D, 0x36, + 0x1A, 0x2C, 0x1A, 0x24, 0x7E, 0x33, 0x37, 0x56, 0x0A, 0x13, 0x6D, 0x00, + 0x12, 0x8C, 0xBA, 0x74, 0x06, 0x1E, 0x34, 0x0E, 0x24, 0x50, 0x03, 0x4E, + 0x60, 0x80, 0x14, 0x78, 0xF4, 0x1B, 0xB8, 0x30, 0x0B, 0xB5, 0x2E, 0xC4, + 0x00, 0x12, 0x0B, 0xE0, 0xBE, 0xE0, 0x02, 0x48, 0xBE, 0x1A, 0xCF, 0x2E, + 0xC4, 0xC0, 0x20, 0x7E, 0x73, 0x05, 0x1A, 0x0A, 0x77, 0x1B, 0x75, 0x7C, + 0xEF, 0x9C, 0xE9, 0x1A, 0xBE, 0x3E, 0xB4, 0x2D, 0xBD, 0x80, 0x39, 0x7E, + 0xC9, 0x90, 0x7A, 0x93, 0x37, 0x56, 0xBE, 0x90, 0x00, 0x08, 0x25, 0x0B, + 0xB8, 0x60, 0x7D, 0x36, 0x1A, 0x2C, 0x1A, 0x24, 0x7E, 0x93, 0x37, 0x56, + 0x0A, 0x19, 0x6D, 0x00, 0x12, 0x8C, 0xBA, 0x74, 0x06, 0x1E, 0x34, 0x0E, + 0x24, 0x50, 0x03, 0x4E, 0x60, 0x80, 0x14, 0x78, 0xF4, 0x1B, 0xB8, 0x30, + 0x0B, 0xB5, 0x2E, 0xC4, 0x00, 0x12, 0x0B, 0xE0, 0xBC, 0x8E, 0x18, 0xC3, + 0x4D, 0xFF, 0x68, 0x2C, 0x7A, 0xD7, 0xFF, 0x40, 0x7E, 0x73, 0x37, 0x55, + 0x1A, 0xC7, 0x4E, 0xC4, 0x01, 0x00, 0x7A, 0xC7, 0xFF, 0x44, 0x7E, 0xC4, + 0xFF, 0xFE, 0x7A, 0xC7, 0xFF, 0x46, 0x7A, 0xF7, 0xFF, 0x48, 0x7A, 0xD7, + 0xFF, 0x42, 0x7E, 0xF7, 0xFF, 0x00, 0x5E, 0xF4, 0x00, 0x20, 0x78, 0xF6, + 0x7D, 0x3E, 0x7E, 0xB3, 0x37, 0x55, 0x12, 0xB9, 0x65, 0xDA, 0x3B, 0x22, + 0xCA, 0x79, 0x7E, 0x37, 0x39, 0x41, 0x7A, 0x37, 0x37, 0x3C, 0x7E, 0x37, + 0x39, 0x43, 0x7A, 0x37, 0x37, 0x3E, 0x74, 0x01, 0x7E, 0xA3, 0x39, 0x2E, + 0x0A, 0x2A, 0x7D, 0x32, 0x7E, 0x17, 0x39, 0x35, 0x7E, 0x07, 0x39, 0x37, + 0x12, 0xA8, 0x5E, 0x7C, 0xFB, 0xBE, 0xF0, 0x08, 0x68, 0x10, 0x7E, 0x37, + 0x39, 0x35, 0x7A, 0x37, 0x39, 0x41, 0x7E, 0x37, 0x39, 0x37, 0x7A, 0x37, + 0x39, 0x43, 0x74, 0x01, 0x7E, 0xA3, 0x39, 0x46, 0xBE, 0xA0, 0x00, 0x28, + 0x14, 0xBE, 0xF0, 0x08, 0x68, 0x0F, 0x0A, 0x3A, 0x09, 0xA3, 0x39, 0x5A, + 0xBC, 0xAF, 0x68, 0x05, 0x74, 0x01, 0x12, 0xEC, 0x53, 0x7E, 0xE3, 0x39, + 0x46, 0xBE, 0xE0, 0x00, 0x28, 0x6E, 0xBE, 0xF0, 0x08, 0x68, 0x19, 0x0A, + 0x3E, 0x09, 0xA3, 0x39, 0x5A, 0xBC, 0xAF, 0x68, 0x0F, 0x7C, 0x7F, 0x7E, + 0x27, 0x39, 0x35, 0x7E, 0x17, 0x39, 0x37, 0x12, 0xD6, 0x23, 0x80, 0x6A, + 0x7E, 0x70, 0x02, 0x7C, 0xBE, 0xAC, 0xB7, 0x49, 0x35, 0x39, 0x95, 0x49, + 0x25, 0x39, 0xBF, 0x12, 0xF5, 0x02, 0x7E, 0xB3, 0x39, 0x46, 0x7E, 0x50, + 0x02, 0xAC, 0xB5, 0x59, 0x35, 0x39, 0xE9, 0x7E, 0x37, 0x39, 0x31, 0x7E, + 0x27, 0x39, 0x33, 0x12, 0xF5, 0x02, 0x7A, 0x37, 0x3A, 0x19, 0x7E, 0x73, + 0x39, 0x46, 0x0A, 0x27, 0x1B, 0x24, 0x5E, 0x24, 0x00, 0x01, 0x3E, 0x24, + 0x49, 0x32, 0x3A, 0x15, 0xBE, 0x37, 0x3A, 0x19, 0x28, 0x24, 0x7E, 0x37, + 0x3A, 0x19, 0x59, 0x32, 0x3A, 0x15, 0x80, 0x1A, 0x7E, 0xB3, 0x39, 0x46, + 0x70, 0x14, 0xBE, 0xF0, 0x08, 0x68, 0x0F, 0x74, 0x01, 0x7C, 0x7F, 0x7E, + 0x27, 0x39, 0x31, 0x7E, 0x17, 0x39, 0x33, 0x12, 0xD6, 0x23, 0xDA, 0x79, + 0x22, 0xCA, 0x69, 0xCA, 0xF8, 0x7E, 0xF3, 0x03, 0xB6, 0x6D, 0x22, 0x4C, + 0xFF, 0x68, 0x61, 0x7E, 0x08, 0x03, 0x52, 0x9F, 0x66, 0x9F, 0x77, 0x6C, + 0x77, 0x80, 0x26, 0x0B, 0x0A, 0x50, 0x0B, 0x15, 0x7A, 0x57, 0x37, 0x45, + 0x0B, 0x0A, 0x60, 0x0B, 0x15, 0x7E, 0xB7, 0x37, 0x45, 0x7D, 0x5B, 0x1A, + 0x5A, 0x1A, 0xAA, 0x2F, 0x75, 0x7D, 0xB6, 0x1A, 0x5C, 0x1A, 0xAA, 0x2F, + 0x65, 0x0B, 0x15, 0x0B, 0x70, 0xBC, 0xF7, 0x38, 0xD6, 0x0A, 0x1F, 0x6D, + 0x00, 0x7F, 0x17, 0x12, 0x8D, 0x27, 0x7D, 0xF3, 0x7A, 0x37, 0x37, 0x45, + 0x0A, 0x1F, 0x6D, 0x00, 0x7F, 0x16, 0x12, 0x8D, 0x27, 0x7D, 0x63, 0x7E, + 0x37, 0x04, 0x03, 0x7E, 0x27, 0x04, 0x05, 0x7D, 0x1F, 0x7D, 0x06, 0x12, + 0xF1, 0x4D, 0x7D, 0x23, 0x7E, 0xA3, 0x04, 0x01, 0xE4, 0xBE, 0xA0, 0x00, + 0x58, 0x0C, 0x7E, 0xA3, 0x03, 0xB6, 0xBE, 0xA3, 0x03, 0xB7, 0x68, 0x02, + 0x74, 0x01, 0x7E, 0x73, 0x04, 0x02, 0x7C, 0xA7, 0x60, 0x3B, 0x7E, 0xB3, + 0x04, 0x86, 0x30, 0xE7, 0x34, 0x4C, 0xAA, 0x78, 0x05, 0x7E, 0xA0, 0x01, + 0x80, 0x2D, 0xBE, 0xA0, 0x00, 0x08, 0x28, 0xBE, 0xA0, 0x7F, 0x58, 0x02, + 0x0B, 0xA0, 0x7E, 0x63, 0x04, 0x2B, 0x0A, 0x16, 0x1B, 0x14, 0x7C, 0x63, + 0x7E, 0xB3, 0x05, 0x30, 0x2C, 0x6B, 0xBE, 0x24, 0x00, 0x50, 0x50, 0x04, + 0xBC, 0x6A, 0x50, 0x07, 0x7E, 0xA0, 0xFF, 0x80, 0x02, 0x6C, 0xAA, 0x7E, + 0xB3, 0x03, 0xB6, 0x60, 0x15, 0x4C, 0x77, 0x68, 0x05, 0xBE, 0xA0, 0x00, + 0x18, 0x0C, 0x7E, 0x37, 0x37, 0x45, 0x7A, 0x37, 0x04, 0x03, 0x7A, 0x67, + 0x04, 0x05, 0x7A, 0xA3, 0x04, 0x02, 0xDA, 0xF8, 0xDA, 0x69, 0x22, 0xCA, + 0x79, 0x7C, 0xE1, 0x7C, 0xFB, 0x7D, 0xE1, 0x7D, 0xF3, 0x7A, 0x27, 0xFF, + 0x02, 0x7E, 0x34, 0xFF, 0xFE, 0x7A, 0x37, 0xFF, 0x06, 0x7A, 0x37, 0xFF, + 0x08, 0x7E, 0x63, 0x05, 0x21, 0x7E, 0x70, 0x01, 0x7A, 0x37, 0xFF, 0x0A, + 0x7E, 0x34, 0x90, 0x00, 0x7A, 0x37, 0xFF, 0x0C, 0x1A, 0x3F, 0x7A, 0x37, + 0xFF, 0x0E, 0x7A, 0xF7, 0xFF, 0x04, 0x7E, 0x37, 0xFF, 0x00, 0x5E, 0x34, + 0x00, 0x01, 0x78, 0xF6, 0x7E, 0x37, 0xFF, 0x2E, 0x1A, 0x26, 0x1A, 0x24, + 0x7A, 0x1F, 0x37, 0x59, 0x7E, 0x1F, 0x37, 0x59, 0x7D, 0x13, 0x5E, 0x14, + 0x00, 0x20, 0x68, 0x08, 0x4E, 0x34, 0xFF, 0xC0, 0x7A, 0x1F, 0x37, 0x59, + 0x7E, 0x1F, 0x37, 0x59, 0x7D, 0x03, 0x7E, 0x37, 0xFF, 0x2C, 0x7D, 0x20, + 0x7A, 0x1F, 0x37, 0x59, 0x7E, 0x37, 0xFF, 0x20, 0x1A, 0x36, 0x7A, 0x73, + 0x37, 0x5D, 0x6D, 0x33, 0x7E, 0x53, 0x37, 0x5D, 0x4C, 0x55, 0x68, 0x0B, + 0x0A, 0x15, 0x6D, 0x00, 0x7E, 0x1F, 0x37, 0x59, 0x12, 0x8D, 0x27, 0x0A, + 0x2E, 0x4D, 0x22, 0x68, 0x12, 0x6D, 0x11, 0x9D, 0x12, 0xBD, 0x13, 0x08, + 0x04, 0x7D, 0x31, 0x80, 0x06, 0xBD, 0x23, 0x58, 0x02, 0x7D, 0x32, 0x4D, + 0x33, 0x68, 0x38, 0x7A, 0xF7, 0xFF, 0x40, 0x7E, 0x53, 0x05, 0x21, 0x0A, + 0xF5, 0x7D, 0x2F, 0x7C, 0x45, 0x6C, 0x55, 0x7D, 0xF2, 0x1A, 0x2F, 0x4D, + 0x2F, 0x7A, 0x27, 0xFF, 0x44, 0x7E, 0x24, 0xFF, 0xFE, 0x7A, 0x27, 0xFF, + 0x46, 0x7A, 0x37, 0xFF, 0x48, 0x7A, 0xE7, 0xFF, 0x42, 0x7E, 0x37, 0xFF, + 0x00, 0x5E, 0x34, 0x00, 0x20, 0x78, 0xF6, 0x74, 0x01, 0x80, 0x01, 0xE4, + 0xDA, 0x79, 0x22, 0xCA, 0x3B, 0x7E, 0x73, 0x03, 0xB6, 0x7A, 0x73, 0x37, + 0x47, 0xBE, 0x70, 0x05, 0x40, 0x03, 0x02, 0x93, 0x06, 0x7E, 0x73, 0x37, + 0x47, 0xBE, 0x70, 0x01, 0x38, 0x03, 0x02, 0x93, 0x06, 0x7E, 0x64, 0x03, + 0x52, 0x6D, 0x77, 0xE4, 0x02, 0x92, 0xEF, 0x0B, 0x68, 0x30, 0x7A, 0x37, + 0x37, 0x4C, 0x49, 0x36, 0x00, 0x02, 0x7A, 0x37, 0x37, 0x4E, 0x2E, 0x64, + 0x00, 0x06, 0x7E, 0x34, 0x03, 0x52, 0x7A, 0x37, 0x37, 0x54, 0x7E, 0x34, + 0xFF, 0xFF, 0x7A, 0x37, 0x37, 0x48, 0xE4, 0x80, 0x59, 0x7E, 0x37, 0x37, + 0x54, 0x0B, 0x38, 0x20, 0x7A, 0x27, 0x37, 0x50, 0x49, 0x23, 0x00, 0x02, + 0x7A, 0x27, 0x37, 0x52, 0x2E, 0x34, 0x00, 0x06, 0x7A, 0x37, 0x37, 0x54, + 0x7E, 0x73, 0x37, 0x46, 0xBE, 0x73, 0x37, 0x45, 0x68, 0x2F, 0x7E, 0x37, + 0x37, 0x4C, 0x7E, 0x27, 0x37, 0x4E, 0x7E, 0x17, 0x37, 0x50, 0x7E, 0x07, + 0x37, 0x52, 0x12, 0xF1, 0x4D, 0x7A, 0x37, 0x37, 0x4A, 0x1E, 0x34, 0x7A, + 0x37, 0x37, 0x4A, 0x7E, 0x37, 0x37, 0x48, 0xBE, 0x37, 0x37, 0x4A, 0x28, + 0x08, 0x7E, 0x37, 0x37, 0x4A, 0x7A, 0x37, 0x37, 0x48, 0x7E, 0xB3, 0x37, + 0x46, 0x04, 0x7A, 0xB3, 0x37, 0x46, 0x7E, 0x73, 0x37, 0x47, 0xBE, 0x73, + 0x37, 0x46, 0x38, 0x99, 0x7E, 0x37, 0x37, 0x48, 0xBD, 0x37, 0x28, 0x02, + 0x7D, 0x73, 0x7E, 0xB3, 0x37, 0x45, 0x04, 0x7A, 0xB3, 0x37, 0x45, 0x7E, + 0x73, 0x37, 0x47, 0xBE, 0x73, 0x37, 0x45, 0x28, 0x03, 0x02, 0x92, 0x53, + 0xBE, 0x74, 0x00, 0xFF, 0x28, 0x04, 0x7E, 0x74, 0x00, 0xFF, 0x7C, 0xBF, + 0xDA, 0x3B, 0x22, 0x7E, 0x34, 0xF7, 0xD3, 0x7E, 0x24, 0x00, 0xFF, 0x0B, + 0x1A, 0x30, 0x74, 0x01, 0x12, 0xED, 0xAD, 0x7E, 0x08, 0xF1, 0x80, 0x7E, + 0x34, 0x38, 0xFB, 0x7E, 0x24, 0x00, 0x09, 0x12, 0xEE, 0x3D, 0x7E, 0x37, + 0x38, 0xFB, 0x5E, 0x60, 0x00, 0x7A, 0x73, 0x12, 0xE7, 0x30, 0x2E, 0x7C, + 0x7E, 0x37, 0x38, 0xFD, 0x0A, 0x36, 0x1E, 0x34, 0x1E, 0x34, 0x1E, 0x34, + 0x5E, 0x34, 0x00, 0x01, 0x78, 0x03, 0x02, 0x93, 0xEF, 0x7E, 0xB3, 0x2C, + 0x59, 0x04, 0x7A, 0xB3, 0x2C, 0x59, 0xB4, 0x05, 0x02, 0x80, 0x03, 0x02, + 0x93, 0xEF, 0xE4, 0x12, 0xCB, 0xA2, 0x7E, 0x37, 0x28, 0x1B, 0x7A, 0x37, + 0xF0, 0x24, 0x7E, 0x37, 0xF0, 0x54, 0x5E, 0x60, 0x03, 0x3E, 0x34, 0x7D, + 0x13, 0x2E, 0x14, 0xE0, 0x00, 0x6D, 0x00, 0x2E, 0x34, 0xE1, 0xE0, 0x7E, + 0x24, 0x00, 0x18, 0x12, 0xEE, 0x3D, 0x7E, 0x37, 0x2B, 0xB1, 0x5E, 0x70, + 0xFE, 0x7A, 0x37, 0x2B, 0xB1, 0x7E, 0x37, 0x2B, 0xB5, 0x5E, 0x60, 0xF7, + 0x7A, 0x37, 0x2B, 0xB5, 0xC2, 0x2E, 0x74, 0x01, 0x12, 0xEE, 0xA5, 0x12, + 0xE5, 0xD1, 0xE4, 0x12, 0xEE, 0xA5, 0x20, 0x01, 0x3E, 0x74, 0x01, 0x12, + 0xCB, 0xA2, 0x80, 0x37, 0xE5, 0x5B, 0x0A, 0x2B, 0x7E, 0x37, 0x38, 0xFD, + 0x0A, 0x36, 0x5E, 0x34, 0x00, 0x07, 0xBD, 0x23, 0x78, 0x25, 0x30, 0x01, + 0x0F, 0x7E, 0x57, 0x38, 0xFF, 0x0A, 0x5A, 0xC4, 0x7D, 0x35, 0x5E, 0x34, + 0x00, 0x01, 0x68, 0x13, 0x7E, 0x08, 0x38, 0xFB, 0x7E, 0x34, 0x2C, 0x65, + 0x7E, 0x24, 0x00, 0x09, 0x12, 0xEE, 0x3D, 0x74, 0x01, 0x80, 0x01, 0xE4, + 0x22, 0x6C, 0x77, 0xA2, 0x22, 0xE4, 0x33, 0xB4, 0x01, 0x02, 0x80, 0x03, + 0x02, 0x94, 0xD2, 0xA2, 0x23, 0xE4, 0x33, 0x68, 0x03, 0x02, 0x94, 0xD2, + 0x85, 0x54, 0x51, 0x7E, 0x27, 0x2C, 0x65, 0x7D, 0x52, 0x0A, 0x5A, 0x54, + 0x23, 0xF5, 0x54, 0xBE, 0xB1, 0x51, 0x68, 0x03, 0x7E, 0x70, 0x01, 0x7E, + 0x57, 0x2C, 0x73, 0x5E, 0x54, 0x00, 0x07, 0xF5, 0x46, 0x85, 0x59, 0x58, + 0x7E, 0x27, 0x2C, 0x67, 0x7D, 0x12, 0x0A, 0x12, 0x5E, 0x14, 0x00, 0x07, + 0x7C, 0x63, 0x7A, 0x61, 0x59, 0xBE, 0x61, 0x58, 0x68, 0x03, 0x7E, 0x70, + 0x01, 0xA2, 0x0F, 0xE4, 0x33, 0x0A, 0x4B, 0x0A, 0x54, 0xC4, 0x7D, 0x25, + 0x5E, 0x24, 0x00, 0x01, 0xBD, 0x42, 0x68, 0x09, 0x7E, 0x70, 0x01, 0x2E, + 0x24, 0xFF, 0xFF, 0x92, 0x0F, 0x4C, 0x77, 0x68, 0x11, 0xA2, 0x01, 0xE4, + 0x33, 0x78, 0x03, 0x12, 0xE2, 0xC6, 0xE5, 0x59, 0x12, 0xAE, 0x9D, 0x12, + 0xF3, 0xDB, 0x12, 0xEF, 0x8B, 0x20, 0x00, 0x0E, 0xE5, 0x59, 0x60, 0x05, + 0xE5, 0x59, 0xB4, 0x02, 0x1C, 0x53, 0x52, 0xFB, 0x80, 0x17, 0xE5, 0x59, + 0xB4, 0x02, 0x12, 0x7E, 0x08, 0xD0, 0x00, 0x7E, 0x34, 0x03, 0x00, 0x7E, + 0x24, 0x03, 0xBA, 0x12, 0xEE, 0x3D, 0x12, 0xDB, 0x16, 0x12, 0xF5, 0x43, + 0xE5, 0x59, 0xBE, 0xB0, 0x01, 0x68, 0x05, 0xE5, 0x59, 0xB4, 0x03, 0x20, + 0xE4, 0x7A, 0xB3, 0x2D, 0xF2, 0x12, 0xB1, 0x44, 0x70, 0x05, 0x12, 0xF1, + 0x9F, 0x80, 0x13, 0x30, 0x00, 0x08, 0xE5, 0x59, 0xB4, 0x03, 0x03, 0x12, + 0xDB, 0x16, 0x74, 0x01, 0x7A, 0xB3, 0x2D, 0xF2, 0xD2, 0x23, 0x22, 0xCA, + 0x3B, 0x7C, 0xD4, 0x7A, 0x0F, 0x37, 0x3C, 0x7C, 0xC5, 0x7C, 0xE7, 0x7C, + 0xFB, 0xE4, 0x7A, 0xB3, 0x37, 0x40, 0x4C, 0xFF, 0x78, 0x2E, 0x7C, 0xB6, + 0x7E, 0x1F, 0x37, 0x3C, 0x7E, 0x1B, 0x70, 0x12, 0xE5, 0x97, 0xBE, 0xB0, + 0x02, 0x40, 0x03, 0x02, 0x95, 0xB2, 0x7C, 0xBC, 0x0A, 0x1D, 0x7E, 0x1F, + 0x37, 0x3C, 0x2D, 0x31, 0x1B, 0x34, 0x7E, 0x1B, 0x70, 0x12, 0xE5, 0x97, + 0xBE, 0xB0, 0x02, 0x40, 0x03, 0x02, 0x95, 0xB2, 0x0A, 0x3F, 0x09, 0x73, + 0x39, 0x45, 0x7A, 0x73, 0x37, 0x46, 0x7E, 0x70, 0x14, 0xAC, 0x7F, 0x7D, + 0x13, 0x2E, 0x14, 0x39, 0x6F, 0x6D, 0x00, 0x7A, 0x0F, 0x37, 0x47, 0x7E, + 0x0F, 0x37, 0x3C, 0x7C, 0xBD, 0x2E, 0x34, 0x39, 0x47, 0x6D, 0x22, 0x12, + 0x54, 0x2D, 0x7A, 0xB3, 0x37, 0x40, 0xBE, 0xE0, 0x03, 0x78, 0x15, 0x4C, + 0xFF, 0x78, 0x11, 0x7E, 0x73, 0x37, 0x40, 0x0A, 0x37, 0x7E, 0x24, 0x00, + 0x7F, 0x12, 0xF4, 0x7C, 0x7A, 0x73, 0x37, 0x40, 0x7E, 0x70, 0x02, 0xAC, + 0x7E, 0x0A, 0x2F, 0x2D, 0x32, 0x09, 0x73, 0x3A, 0x5A, 0x0A, 0x37, 0x7E, + 0x53, 0x37, 0x40, 0x0A, 0x25, 0x12, 0xF4, 0x7C, 0x7C, 0x57, 0x7E, 0x70, + 0x02, 0xAC, 0x7E, 0x0A, 0x1F, 0x2D, 0x31, 0x19, 0x53, 0x3A, 0x5A, 0x09, + 0x73, 0x3A, 0x5A, 0xBE, 0x70, 0x80, 0x50, 0x22, 0x4C, 0xFF, 0x78, 0x10, + 0x0A, 0x3E, 0x2E, 0x34, 0x3A, 0x49, 0x7E, 0x39, 0xB0, 0x44, 0x02, 0x7A, + 0x39, 0xB0, 0x80, 0x0E, 0x0A, 0x3E, 0x2E, 0x34, 0x3A, 0x49, 0x7E, 0x39, + 0xB0, 0x44, 0x04, 0x7A, 0x39, 0xB0, 0xDA, 0x3B, 0x22, 0xCA, 0x3B, 0x7C, + 0xFB, 0x7D, 0x01, 0x7D, 0x12, 0x7D, 0x43, 0x7E, 0xA3, 0x04, 0x2A, 0x7E, + 0x18, 0x0A, 0x4C, 0x6C, 0xEE, 0x02, 0x96, 0x8C, 0x7E, 0x49, 0xD0, 0x4C, + 0xDD, 0x78, 0x14, 0x7E, 0x09, 0xB0, 0xB4, 0x01, 0x02, 0x80, 0x03, 0x02, + 0x96, 0x82, 0xE4, 0x7A, 0x19, 0xB0, 0x74, 0x01, 0x02, 0x96, 0x7F, 0xBE, + 0xD0, 0x01, 0x78, 0x4E, 0x7E, 0x09, 0xB0, 0xB4, 0x01, 0x45, 0x7E, 0x19, + 0xB0, 0x04, 0x7A, 0x19, 0xB0, 0x1A, 0xFE, 0x09, 0xBF, 0x0A, 0xB5, 0xB4, + 0x10, 0x05, 0x74, 0x01, 0x7A, 0x19, 0xB0, 0x7E, 0x1B, 0xB0, 0x0A, 0xFB, + 0x0A, 0xEA, 0x2D, 0xEF, 0x7E, 0x19, 0xC0, 0x0A, 0xFC, 0xBD, 0xFE, 0x48, + 0x69, 0x7E, 0xB3, 0x04, 0x07, 0x30, 0xE7, 0x08, 0x7C, 0xBC, 0x14, 0x7A, + 0x19, 0xB0, 0x80, 0x5A, 0x74, 0x02, 0x7A, 0x49, 0xB0, 0x74, 0xFF, 0x1A, + 0xFE, 0x19, 0xBF, 0x07, 0x81, 0x80, 0x4B, 0xE4, 0x80, 0x45, 0xBE, 0xD0, + 0x02, 0x78, 0x0D, 0xE4, 0x7A, 0x19, 0xB0, 0x7E, 0x09, 0xB0, 0x70, 0x3A, + 0x74, 0x03, 0x80, 0x33, 0xBE, 0xD0, 0x03, 0x68, 0x05, 0xBE, 0xD0, 0x04, + 0x78, 0x2C, 0x7E, 0x09, 0xB0, 0xB4, 0x01, 0x04, 0x74, 0x02, 0x80, 0x1F, + 0x7E, 0xD3, 0x04, 0x2B, 0x7E, 0xB3, 0x05, 0x30, 0x2C, 0xDB, 0x7E, 0x19, + 0xB0, 0x04, 0x7A, 0x19, 0xB0, 0xBC, 0xBD, 0x40, 0x0D, 0x74, 0x01, 0x1A, + 0xFE, 0x19, 0xBF, 0x07, 0x3B, 0x74, 0x05, 0x7A, 0x49, 0xB0, 0x0B, 0x44, + 0x0B, 0x14, 0x0B, 0x04, 0x0B, 0x34, 0x0B, 0xE0, 0xBC, 0xFE, 0x08, 0x03, + 0x02, 0x95, 0xCC, 0xDA, 0x3B, 0x22, 0x7C, 0x82, 0x7C, 0xA3, 0x7C, 0x9B, + 0x7D, 0x12, 0x7D, 0x03, 0xBE, 0x80, 0x01, 0x78, 0x25, 0x7E, 0x73, 0x04, + 0x2F, 0x1E, 0x70, 0x6C, 0x66, 0x80, 0x16, 0x0B, 0x08, 0x20, 0x0A, 0xE7, + 0x7D, 0xF2, 0x9D, 0xFE, 0x1B, 0x18, 0xF0, 0x1A, 0xFA, 0x3E, 0xF4, 0x2D, + 0x0F, 0x0B, 0x15, 0x0B, 0x60, 0xBC, 0x96, 0x18, 0xE6, 0x22, 0x7C, 0xB8, + 0x30, 0xE7, 0x0B, 0x7D, 0x30, 0x7D, 0x21, 0x7C, 0xB9, 0x7C, 0x3A, 0x02, + 0xD4, 0xB4, 0x7E, 0x43, 0x03, 0xFF, 0x7E, 0x53, 0x04, 0x70, 0x7C, 0xB5, + 0x30, 0xE3, 0x02, 0x6C, 0x44, 0x4C, 0x88, 0x78, 0x45, 0x7A, 0x07, 0xFF, + 0xB0, 0x1A, 0x39, 0x7A, 0x37, 0xFF, 0xB4, 0x1A, 0x3A, 0x4E, 0x60, 0x01, + 0x7A, 0x37, 0xFF, 0xB6, 0x7E, 0x34, 0x00, 0x40, 0x7A, 0x37, 0xFF, 0xB8, + 0x0A, 0xF4, 0x3E, 0xF4, 0x7C, 0xB5, 0x20, 0xE7, 0x06, 0x7E, 0x34, 0x00, + 0x01, 0x80, 0x02, 0x6D, 0x33, 0x5E, 0x34, 0x00, 0x01, 0x4D, 0x3F, 0x7A, + 0x37, 0xFF, 0xBA, 0x7A, 0x17, 0xFF, 0xB2, 0x7E, 0x37, 0xFF, 0x00, 0x5E, + 0x34, 0x00, 0x10, 0x78, 0xF6, 0x22, 0x7A, 0x07, 0xFF, 0xB0, 0x1A, 0x39, + 0x7A, 0x37, 0xFF, 0xB4, 0x1A, 0x3A, 0x4E, 0x60, 0x01, 0x7A, 0x37, 0xFF, + 0xB6, 0x7E, 0x34, 0x00, 0x30, 0x7A, 0x37, 0xFF, 0xB8, 0x0A, 0x34, 0x3E, + 0x34, 0x7C, 0xB5, 0x20, 0xE7, 0x06, 0x7E, 0x04, 0x00, 0x01, 0x80, 0x02, + 0x6D, 0x00, 0x5E, 0x04, 0x00, 0x01, 0x4D, 0x03, 0x7A, 0x07, 0xFF, 0xBA, + 0x7A, 0x17, 0xFF, 0xB2, 0x7E, 0x37, 0xFF, 0x00, 0x5E, 0x34, 0x00, 0x10, + 0x78, 0xF6, 0x22, 0x6C, 0xAA, 0x7E, 0x34, 0x00, 0x61, 0x7E, 0x24, 0x00, + 0x00, 0x7E, 0x1B, 0x70, 0x7C, 0xB7, 0x1E, 0xB0, 0x1E, 0xB0, 0x54, 0x03, + 0xBE, 0xB1, 0x46, 0x78, 0x25, 0x7E, 0x78, 0x1A, 0x7E, 0x7E, 0x14, 0x00, + 0x61, 0x7E, 0x04, 0x00, 0x00, 0x7E, 0x0B, 0x60, 0x7C, 0xA6, 0x5E, 0xA0, + 0x03, 0x3E, 0xA0, 0x3E, 0xA0, 0x5E, 0x60, 0xF3, 0x4C, 0x6A, 0x7A, 0x0B, + 0x60, 0x7E, 0xA0, 0x01, 0x80, 0x64, 0x7C, 0xB7, 0xC4, 0x54, 0x03, 0xBE, + 0xB1, 0x46, 0x78, 0x28, 0x7E, 0x78, 0x1E, 0xFE, 0x7E, 0x14, 0x00, 0x61, + 0x7E, 0x04, 0x00, 0x00, 0x7E, 0x0B, 0x60, 0x7C, 0xA6, 0x5E, 0xA0, 0x03, + 0x7C, 0xBA, 0xC4, 0x54, 0xF0, 0x7C, 0xAB, 0x5E, 0x60, 0xCF, 0x4C, 0x6A, + 0x7A, 0x0B, 0x60, 0x7E, 0xA0, 0x01, 0x80, 0x32, 0x7C, 0xB7, 0x23, 0x23, + 0x54, 0x03, 0xBE, 0xB1, 0x46, 0x78, 0x27, 0x7E, 0x78, 0x23, 0x7E, 0x7E, + 0x14, 0x00, 0x61, 0x7E, 0x04, 0x00, 0x00, 0x7E, 0x0B, 0x70, 0x7C, 0x67, + 0x5E, 0x60, 0x03, 0x7C, 0xB6, 0x03, 0x03, 0x54, 0xC0, 0x7C, 0x6B, 0x5E, + 0x70, 0x3F, 0x4C, 0x76, 0x7A, 0x0B, 0x70, 0x7E, 0xA0, 0x01, 0x4C, 0xAA, + 0x68, 0x37, 0x7E, 0x61, 0x46, 0x5E, 0x60, 0x03, 0x7E, 0x14, 0x00, 0x61, + 0x7E, 0x04, 0x00, 0x00, 0x7E, 0x0B, 0x70, 0x5E, 0x70, 0xFC, 0x4C, 0x76, + 0x7A, 0x0B, 0x70, 0x7E, 0x18, 0xA0, 0x00, 0x6D, 0x11, 0x0B, 0x7A, 0x00, + 0x0B, 0x1A, 0x50, 0x1B, 0x7A, 0x50, 0x1B, 0x1A, 0x00, 0x0B, 0x35, 0x0B, + 0xF5, 0x0B, 0x14, 0xBE, 0x14, 0x02, 0x40, 0x78, 0xE8, 0x22, 0xE4, 0x7A, + 0xB3, 0x37, 0x2E, 0xC2, 0x44, 0xE5, 0x59, 0xB4, 0x01, 0x38, 0x7E, 0x37, + 0x2D, 0xD9, 0x2E, 0x34, 0x00, 0x10, 0x7E, 0x39, 0xB0, 0x7E, 0x37, 0x2D, + 0xD9, 0x2E, 0x34, 0x00, 0x11, 0x7E, 0x39, 0x70, 0x7E, 0x27, 0x2D, 0xD9, + 0x2E, 0x24, 0x00, 0x0B, 0x7E, 0x29, 0x60, 0x5E, 0x60, 0x03, 0x12, 0xAD, + 0x45, 0x7E, 0x08, 0x37, 0x2E, 0x12, 0xDA, 0x26, 0x70, 0x03, 0x02, 0x99, + 0x16, 0x12, 0xF4, 0xC6, 0x80, 0x7C, 0xE5, 0x59, 0xB4, 0x03, 0x33, 0x7E, + 0x37, 0x2D, 0xE3, 0x2E, 0x34, 0x00, 0x09, 0x7E, 0x39, 0xB0, 0x7E, 0x37, + 0x2D, 0xE3, 0x2E, 0x34, 0x00, 0x0A, 0x7E, 0x39, 0x70, 0x7E, 0x27, 0x2D, + 0xE3, 0x0B, 0x24, 0x7E, 0x29, 0x60, 0x5E, 0x60, 0x03, 0x12, 0xAD, 0x45, + 0x7E, 0x08, 0x37, 0x2E, 0x12, 0xDA, 0x26, 0x60, 0x49, 0x12, 0xF4, 0xC6, + 0x80, 0x44, 0x7E, 0x37, 0x2D, 0xE1, 0x7E, 0x39, 0xB0, 0x30, 0xE0, 0x30, + 0x12, 0x6D, 0x95, 0x70, 0x1F, 0x12, 0x27, 0x9A, 0x70, 0x0E, 0x7E, 0x08, + 0x37, 0x2E, 0x12, 0xDA, 0x26, 0x60, 0x27, 0x12, 0xC2, 0xEA, 0x80, 0x22, + 0x7E, 0x37, 0x2D, 0x74, 0x0B, 0x34, 0x7A, 0x37, 0x2D, 0x74, 0x80, 0x16, + 0x7E, 0x37, 0x2D, 0x74, 0x0B, 0x34, 0x7A, 0x37, 0x2D, 0x74, 0x80, 0x0A, + 0x12, 0xF5, 0xCB, 0x7E, 0x08, 0x37, 0x2E, 0x12, 0xDA, 0x26, 0x12, 0x7E, + 0xCE, 0x30, 0x44, 0x0B, 0xC2, 0xAE, 0x7E, 0xB3, 0x37, 0x2E, 0x12, 0x6C, + 0x19, 0xD2, 0xAE, 0x12, 0xC3, 0xF4, 0x30, 0x01, 0x03, 0x12, 0xDB, 0x16, + 0x12, 0xE7, 0xC4, 0x22, 0xCA, 0x79, 0x7C, 0xAB, 0x4C, 0xAB, 0x78, 0x03, + 0x02, 0x9A, 0x0F, 0x7E, 0xB3, 0x05, 0x1A, 0x0A, 0x3B, 0x1B, 0x34, 0x7E, + 0x63, 0x05, 0x1B, 0x0A, 0xE6, 0x1B, 0xE4, 0x7D, 0x2E, 0x7C, 0x65, 0x7E, + 0x24, 0xC1, 0x50, 0x6C, 0x33, 0x02, 0x9A, 0x08, 0xE4, 0x19, 0xB2, 0x00, + 0x0A, 0x09, 0xB2, 0x00, 0x09, 0x60, 0x03, 0x02, 0x9A, 0x02, 0x09, 0x22, + 0x00, 0x04, 0x09, 0x12, 0x00, 0x05, 0x6D, 0xFF, 0x4C, 0x22, 0x68, 0x04, + 0xBC, 0x71, 0x78, 0x04, 0x7E, 0xF4, 0x00, 0x03, 0xBE, 0x20, 0x00, 0x08, + 0x02, 0x1B, 0x20, 0xBC, 0x71, 0x08, 0x02, 0x0B, 0x10, 0x09, 0x02, 0x00, + 0x06, 0x09, 0x92, 0x00, 0x07, 0x4C, 0x00, 0x68, 0x04, 0xBC, 0x69, 0x78, + 0x04, 0x7E, 0xF4, 0x00, 0x03, 0xBE, 0x00, 0x00, 0x08, 0x02, 0x1B, 0x00, + 0xBC, 0x69, 0x08, 0x02, 0x0B, 0x90, 0x7A, 0x03, 0x37, 0x45, 0x80, 0x38, + 0x7E, 0xB3, 0x05, 0x1A, 0x0A, 0xDB, 0x7E, 0xF3, 0x37, 0x45, 0x1A, 0xCF, + 0xAD, 0xDC, 0x7D, 0xED, 0x3E, 0xE4, 0x2E, 0xE7, 0x03, 0x10, 0x7C, 0x82, + 0x80, 0x13, 0x1A, 0xD8, 0x3E, 0xD4, 0x2D, 0xDE, 0x0B, 0xD8, 0xD0, 0xBE, + 0xD4, 0x00, 0x00, 0x08, 0x02, 0x0B, 0xF4, 0x0B, 0x80, 0xBC, 0x18, 0x58, + 0xE9, 0x7C, 0xBF, 0x04, 0x7A, 0xB3, 0x37, 0x45, 0xBE, 0x93, 0x37, 0x45, + 0x58, 0xC2, 0xBE, 0xF4, 0x00, 0xFF, 0x08, 0x04, 0x7E, 0xF4, 0x00, 0xFF, + 0x7D, 0x7F, 0x19, 0xF2, 0x00, 0x0A, 0x2E, 0x24, 0x00, 0x10, 0x0B, 0x30, + 0xBC, 0xA3, 0x08, 0x03, 0x02, 0x99, 0x5C, 0xDA, 0x79, 0x22, 0xCA, 0x3B, + 0x7D, 0x73, 0x6D, 0x66, 0xE4, 0x7A, 0xB3, 0x37, 0x45, 0x7E, 0x73, 0x37, + 0x45, 0x0A, 0x37, 0x09, 0xB3, 0x07, 0x27, 0x70, 0x03, 0x02, 0x9A, 0xAD, + 0xBE, 0xB0, 0x05, 0x68, 0x7C, 0x2D, 0x37, 0x7E, 0x39, 0x70, 0x7A, 0x73, + 0x37, 0x46, 0x7E, 0x73, 0x03, 0xB6, 0xBE, 0x73, 0x37, 0x46, 0x28, 0x69, + 0x7E, 0x73, 0x37, 0x46, 0x0A, 0x37, 0x09, 0xB3, 0xC1, 0x2A, 0xBE, 0xB0, + 0x02, 0x68, 0x5A, 0x74, 0x02, 0x19, 0xB3, 0xC1, 0x2A, 0x74, 0x01, 0x7E, + 0x13, 0x37, 0x45, 0x0A, 0x31, 0x19, 0xB3, 0x07, 0x31, 0x7E, 0xB3, 0x37, + 0x46, 0x7E, 0x00, 0x03, 0xAC, 0xB0, 0x7A, 0xB3, 0x37, 0x46, 0x7E, 0x00, + 0x02, 0xAC, 0xB0, 0x49, 0x35, 0x03, 0x52, 0x7A, 0x37, 0x37, 0x49, 0x49, + 0x25, 0x03, 0x54, 0x7A, 0x27, 0x37, 0x4B, 0x49, 0x15, 0x03, 0x56, 0x7A, + 0x17, 0x37, 0x4D, 0x7C, 0xB1, 0x12, 0x30, 0x14, 0x7E, 0xB3, 0x37, 0x45, + 0x7E, 0x70, 0x08, 0xAC, 0xB7, 0x49, 0x35, 0x05, 0xA1, 0x7A, 0x37, 0x37, + 0x47, 0xBD, 0x36, 0x28, 0x04, 0x7E, 0x67, 0x37, 0x47, 0x7E, 0xB3, 0x37, + 0x45, 0x04, 0x7A, 0xB3, 0x37, 0x45, 0xB4, 0x0A, 0x02, 0x80, 0x03, 0x02, + 0x9A, 0x1D, 0xBE, 0x64, 0x04, 0x00, 0x28, 0x04, 0x7E, 0x64, 0x04, 0x00, + 0xBE, 0x67, 0x03, 0xC4, 0x28, 0x06, 0x7A, 0x67, 0x03, 0xC4, 0x80, 0x14, + 0x7E, 0x27, 0x03, 0xC4, 0x7E, 0x34, 0x00, 0x03, 0xAD, 0x32, 0x2D, 0x36, + 0x1E, 0x34, 0x1E, 0x34, 0x7A, 0x37, 0x03, 0xC4, 0xDA, 0x3B, 0x22, 0x22, + 0x2A, 0x6C, 0xD7, 0xEC, 0x2D, 0xAA, 0x04, 0x22, 0xBC, 0xF0, 0x60, 0x60, + 0x4D, 0xFD, 0x11, 0xED, 0xBF, 0xD5, 0xEE, 0x52, 0x07, 0x46, 0x4E, 0x9A, + 0x26, 0x8F, 0x52, 0x66, 0x54, 0x06, 0x5D, 0x34, 0xED, 0x40, 0x55, 0x17, + 0xA8, 0x23, 0xCE, 0xCD, 0x90, 0x61, 0xD5, 0xF4, 0x4F, 0x4B, 0x61, 0x3E, + 0xCC, 0xEF, 0x30, 0x69, 0x17, 0x76, 0x94, 0x6E, 0x36, 0x34, 0xF5, 0x0E, + 0x4D, 0xE7, 0x06, 0x3A, 0x22, 0x11, 0x74, 0x12, 0x8C, 0xD1, 0xA2, 0x5B, + 0x51, 0x64, 0x92, 0x33, 0xD9, 0xF7, 0xA9, 0xEA, 0xFA, 0x81, 0x73, 0x41, + 0x8E, 0x6F, 0x7A, 0xED, 0xA2, 0x2C, 0x73, 0x37, 0x93, 0x68, 0xB7, 0x77, + 0x36, 0x2B, 0xEB, 0xDE, 0xF4, 0x06, 0x32, 0x4F, 0x0A, 0xF1, 0xD0, 0x0C, + 0x36, 0xCA, 0xB1, 0xBA, 0x96, 0xCB, 0x97, 0xDC, 0x03, 0x13, 0xFD, 0xC1, + 0x11, 0x1F, 0xED, 0x16, 0xAB, 0x21, 0xC4, 0x14, 0xCF, 0x44, 0x42, 0x83, + 0x70, 0x32, 0xC5, 0x74, 0xFD, 0x66, 0x9E, 0x76, 0x9E, 0x30, 0xD6, 0xB8, + 0x9C, 0xF0, 0x50, 0x45, 0xFC, 0xE5, 0x30, 0xD4, 0xDE, 0x1A, 0x5E, 0x63, + 0x88, 0xCF, 0x94, 0x7E, 0x47, 0xF0, 0x55, 0x8A, 0x81, 0x6D, 0x38, 0xD9, + 0x21, 0x7E, 0x5C, 0xED, 0xC3, 0x38, 0x07, 0x34, 0x40, 0xFA, 0x22, 0x05, + 0x7A, 0x91, 0x36, 0xD7, 0x9A, 0x90, 0x10, 0xDB, 0x17, 0xD5, 0x9F, 0x68, + 0xA9, 0x2C, 0xD5, 0x7F, 0x1F, 0xF3, 0x77, 0x50, 0x1E, 0xDE, 0x42, 0x70, + 0xC9, 0x96, 0xC8, 0xC0, 0x12, 0xBC, 0xE3, 0x7E, 0xB3, 0x2C, 0x5E, 0x60, + 0x03, 0x02, 0x9C, 0x91, 0x7E, 0x37, 0x2D, 0xE9, 0x0B, 0x38, 0x30, 0x7D, + 0x53, 0x0A, 0x5A, 0x5E, 0x54, 0x00, 0x7F, 0xF5, 0x5E, 0x7E, 0x37, 0x2D, + 0xE9, 0x0B, 0x38, 0x50, 0x5E, 0xA0, 0x00, 0xF5, 0x5F, 0x7E, 0x37, 0x2D, + 0xEB, 0x7E, 0x39, 0xB0, 0xF5, 0x47, 0xE4, 0x7A, 0xB3, 0x12, 0xEF, 0x7E, + 0x37, 0x2D, 0xE9, 0x49, 0x53, 0x00, 0x0E, 0x5E, 0x54, 0xC0, 0x00, 0x0A, + 0x5A, 0xC4, 0x03, 0x54, 0x07, 0x7C, 0x7B, 0x7A, 0x73, 0x12, 0xF0, 0x7E, + 0x37, 0x2D, 0xE9, 0x49, 0x33, 0x00, 0x0E, 0x5E, 0x34, 0x07, 0x00, 0x0A, + 0x36, 0x7A, 0x73, 0x2C, 0x63, 0x74, 0x04, 0x7A, 0xB3, 0x18, 0xF6, 0x7E, + 0x37, 0x2D, 0xE9, 0x49, 0x33, 0x00, 0x0C, 0x7D, 0x53, 0x0A, 0x5A, 0x54, + 0x0F, 0x7A, 0xB3, 0x12, 0xD8, 0xE4, 0x7A, 0xB3, 0x12, 0xE1, 0x74, 0x02, + 0x7A, 0xB3, 0x12, 0xE6, 0xE4, 0x7A, 0xB3, 0x18, 0xF7, 0x30, 0x03, 0x0B, + 0x74, 0x10, 0x7A, 0xB3, 0x18, 0xF6, 0xE4, 0x7A, 0xB3, 0x12, 0xE1, 0xE5, + 0x5E, 0x0A, 0x4B, 0x7E, 0x73, 0x18, 0xF6, 0x0A, 0x57, 0x2D, 0x54, 0xF5, + 0x5A, 0x85, 0x5F, 0x60, 0x30, 0x05, 0x02, 0x05, 0x60, 0x7E, 0x71, 0x60, + 0x74, 0x02, 0xAC, 0xB7, 0x7A, 0x55, 0x55, 0xA2, 0x01, 0xE4, 0x33, 0x7C, + 0xAB, 0x4C, 0xAA, 0x78, 0x0D, 0x7E, 0x37, 0x2D, 0xD9, 0x09, 0xB3, 0x00, + 0x0B, 0x30, 0xE7, 0x02, 0xD2, 0x20, 0xBE, 0xA0, 0x01, 0x78, 0x02, 0xD2, + 0x20, 0x22, 0x72, 0x57, 0xA7, 0x74, 0xD3, 0x93, 0x6E, 0x3E, 0xE1, 0x51, + 0x73, 0x8A, 0xAB, 0x40, 0x4E, 0x57, 0x13, 0x53, 0x1B, 0x48, 0xA4, 0xCD, + 0x14, 0x4C, 0xE3, 0xE9, 0xFB, 0x04, 0xF6, 0xE3, 0xCA, 0x48, 0xD7, 0x82, + 0x61, 0x17, 0xDE, 0xEF, 0x53, 0x51, 0x6A, 0x70, 0x7E, 0xF7, 0x5B, 0xE3, + 0xFD, 0x6B, 0x38, 0x79, 0x35, 0xD7, 0xB8, 0x9A, 0xFC, 0xC1, 0xEF, 0x7B, + 0x31, 0x64, 0xEF, 0x3C, 0x27, 0xE8, 0x95, 0xA0, 0x4E, 0x86, 0x50, 0x3B, + 0x83, 0xAB, 0x9A, 0x1D, 0x51, 0xBA, 0xFC, 0xDC, 0xAE, 0x6B, 0x40, 0x87, + 0x71, 0xF7, 0xB9, 0xD6, 0x08, 0x8B, 0x4B, 0xB5, 0x30, 0x27, 0x07, 0xF5, + 0x36, 0x73, 0x8B, 0xB4, 0x02, 0xA9, 0x10, 0x5C, 0xF0, 0x99, 0x2E, 0x45, + 0x45, 0xEB, 0xE4, 0x4A, 0xA8, 0x24, 0x61, 0x73, 0x0E, 0x11, 0x87, 0x77, + 0xF1, 0x19, 0xCB, 0x37, 0x3B, 0xA6, 0xCA, 0xFF, 0x49, 0x97, 0x4C, 0xA6, + 0xE2, 0xEB, 0x7B, 0xDB, 0x21, 0xAA, 0x15, 0x38, 0x05, 0x28, 0xDD, 0xEC, + 0xC5, 0xA7, 0x0B, 0x96, 0x1A, 0x90, 0x7C, 0x18, 0x08, 0x1C, 0x7A, 0x82, + 0x68, 0x40, 0xC0, 0xEC, 0xC2, 0xC7, 0x1D, 0xC3, 0x2C, 0x3D, 0xE3, 0x65, + 0x2D, 0x34, 0x72, 0xAD, 0x90, 0x10, 0x27, 0xAB, 0xF2, 0x4B, 0x5B, 0x31, + 0xFA, 0x68, 0x61, 0xF6, 0xAC, 0x0A, 0x94, 0xFE, 0xA0, 0xD7, 0x61, 0xF6, + 0x9D, 0xBB, 0x7A, 0xBB, 0x6B, 0x12, 0x8E, 0x4B, 0x42, 0x4D, 0x9D, 0xBC, + 0xBB, 0xC8, 0xF0, 0x10, 0x35, 0x27, 0x12, 0xBD, 0x76, 0xCA, 0x3B, 0x7D, + 0x71, 0x7D, 0x62, 0x7A, 0x37, 0x37, 0x61, 0x7E, 0x18, 0x37, 0x66, 0x7A, + 0x1F, 0x37, 0x71, 0x7E, 0x70, 0x01, 0x7E, 0x08, 0x37, 0x64, 0x12, 0xE9, + 0x84, 0x7E, 0x44, 0x00, 0x80, 0x9D, 0x47, 0xE4, 0x7A, 0xB3, 0x37, 0x63, + 0x7E, 0xD7, 0x37, 0x64, 0x0B, 0xD8, 0xF0, 0x7E, 0x57, 0x37, 0x66, 0x0B, + 0x58, 0xE0, 0x7E, 0x17, 0x37, 0x61, 0x1A, 0x02, 0x1A, 0x00, 0x7D, 0xB7, + 0x1A, 0x3E, 0x1A, 0xA6, 0x7F, 0x15, 0x12, 0x8C, 0xBA, 0x7F, 0x41, 0x7D, + 0x1F, 0x1A, 0x02, 0x1A, 0x00, 0x7D, 0x34, 0x1A, 0x26, 0x1A, 0x24, 0x12, + 0x8C, 0xBA, 0x2F, 0x14, 0x74, 0x07, 0x1E, 0x34, 0x0E, 0x24, 0x50, 0x03, + 0x4E, 0x60, 0x80, 0x14, 0x78, 0xF4, 0x7D, 0xF3, 0x7D, 0x16, 0x1A, 0x02, + 0x1A, 0x00, 0x7F, 0x15, 0x12, 0x8C, 0xBA, 0x7F, 0x51, 0x7D, 0x1E, 0x1A, + 0x02, 0x1A, 0x00, 0x7D, 0x34, 0x1A, 0x26, 0x1A, 0x24, 0x12, 0x8C, 0xBA, + 0x2F, 0x15, 0x74, 0x07, 0x1E, 0x34, 0x0E, 0x24, 0x50, 0x03, 0x4E, 0x60, + 0x80, 0x14, 0x78, 0xF4, 0x7A, 0xF7, 0x37, 0x61, 0x7D, 0x63, 0x1B, 0xD8, + 0xF0, 0x7E, 0x57, 0x37, 0x64, 0x1B, 0x55, 0x7A, 0x57, 0x37, 0x64, 0x7E, + 0x57, 0x37, 0x66, 0x1B, 0x58, 0x30, 0x7E, 0x57, 0x37, 0x66, 0x1B, 0x55, + 0x7A, 0x57, 0x37, 0x66, 0x7E, 0xB3, 0x37, 0x63, 0x04, 0x7A, 0xB3, 0x37, + 0x63, 0x7E, 0x73, 0x37, 0x63, 0xBE, 0x70, 0x02, 0x58, 0x03, 0x02, 0x9D, + 0x8C, 0xDA, 0x3B, 0x22, 0xCA, 0xF8, 0x7C, 0xFB, 0x74, 0x15, 0x12, 0xD5, + 0x11, 0x92, 0x46, 0x74, 0x16, 0x12, 0xD5, 0x11, 0x92, 0x47, 0x7E, 0xA3, + 0x3B, 0x80, 0x7E, 0x37, 0x3B, 0x82, 0x7E, 0x27, 0x3B, 0x84, 0xA2, 0x47, + 0x72, 0x46, 0xE4, 0x33, 0x78, 0x05, 0x74, 0x3F, 0x02, 0x9F, 0x07, 0xBE, + 0xA0, 0x02, 0x40, 0x05, 0x74, 0x31, 0x02, 0x9F, 0x07, 0xBE, 0xA0, 0x01, + 0x78, 0x29, 0x4C, 0xFF, 0x78, 0x13, 0x6D, 0x11, 0x7A, 0x17, 0x3B, 0x78, + 0x7A, 0x37, 0x3B, 0x73, 0x7A, 0x27, 0x3B, 0x75, 0x7E, 0xF0, 0x11, 0x80, + 0x40, 0xBE, 0xF0, 0x12, 0x78, 0x3B, 0x7A, 0x37, 0x3B, 0x6F, 0x7A, 0x27, + 0x3B, 0x71, 0x7E, 0xF0, 0x13, 0x80, 0x2E, 0xBE, 0xF0, 0x11, 0x78, 0x12, + 0x30, 0x46, 0x0A, 0x74, 0x15, 0x7A, 0xB3, 0x3B, 0x7D, 0x74, 0x20, 0x80, + 0x5A, 0x7E, 0xF0, 0x12, 0x80, 0x17, 0xBE, 0xF0, 0x13, 0x78, 0x0A, 0x74, + 0x16, 0x7A, 0xB3, 0x3B, 0x7D, 0x74, 0x20, 0x80, 0x46, 0xBE, 0xF0, 0x20, + 0x40, 0x03, 0xE4, 0x80, 0x3E, 0xBE, 0xF0, 0x11, 0x40, 0x37, 0xBE, 0xF0, + 0x13, 0x38, 0x32, 0x7E, 0x17, 0x3B, 0x78, 0x0B, 0x14, 0x7A, 0x17, 0x3B, + 0x78, 0x7E, 0x17, 0x3B, 0x6D, 0xBE, 0x17, 0x3B, 0x78, 0x38, 0x04, 0x74, + 0x32, 0x80, 0x1C, 0xBE, 0xF0, 0x12, 0x68, 0x15, 0x7E, 0x17, 0x3B, 0x73, + 0x7E, 0x07, 0x3B, 0x75, 0x12, 0xF2, 0xCE, 0xBE, 0x37, 0x3B, 0x6B, 0x40, + 0x04, 0x74, 0x33, 0x80, 0x02, 0x7C, 0xBF, 0xDA, 0xF8, 0x22, 0xCA, 0x79, + 0x7E, 0x37, 0x2D, 0xD9, 0x2E, 0x34, 0x00, 0x03, 0x0B, 0x38, 0x30, 0xE5, + 0x5E, 0x0A, 0x2B, 0x8D, 0x32, 0x7D, 0x23, 0x7E, 0x37, 0x2D, 0xD9, 0x2E, + 0x34, 0x00, 0x05, 0x0B, 0x38, 0x10, 0xE5, 0x5F, 0x0A, 0x0B, 0x8D, 0x10, + 0x7D, 0x31, 0xBD, 0x32, 0x28, 0x04, 0x7D, 0x72, 0x80, 0x02, 0x7D, 0x73, + 0x7E, 0x34, 0x37, 0x2E, 0x7E, 0x24, 0x00, 0x04, 0x12, 0xF2, 0x4B, 0x30, + 0x01, 0x3C, 0x7E, 0x37, 0x2D, 0xE3, 0x7E, 0x39, 0xB0, 0x30, 0xE0, 0x08, + 0x74, 0x06, 0x7A, 0xB3, 0x37, 0x2E, 0x80, 0x06, 0x74, 0x05, 0x7A, 0xB3, + 0x37, 0x2E, 0x74, 0x8F, 0x7A, 0xB3, 0x37, 0x2F, 0x7E, 0x37, 0x2D, 0xE3, + 0x7E, 0x39, 0xB0, 0x30, 0xE1, 0x08, 0x74, 0xFF, 0x7A, 0xB3, 0x37, 0x30, + 0x80, 0x06, 0x74, 0xDF, 0x7A, 0xB3, 0x37, 0x30, 0x74, 0x0F, 0x7A, 0xB3, + 0x37, 0x31, 0xE4, 0x7A, 0xB3, 0x2C, 0x5F, 0xE4, 0x7A, 0xB3, 0x2C, 0x7B, + 0x7E, 0x37, 0x2D, 0xE3, 0x2E, 0x34, 0x00, 0x06, 0x7E, 0x39, 0x70, 0x0A, + 0x27, 0x7D, 0x32, 0xAD, 0x37, 0x7A, 0x37, 0x37, 0x32, 0x7E, 0x34, 0xF5, + 0x55, 0x7A, 0x37, 0x37, 0x34, 0x7E, 0x34, 0x37, 0x2E, 0x7D, 0x27, 0x7E, + 0x17, 0x2D, 0xE3, 0x2E, 0x14, 0x00, 0x08, 0x7E, 0x19, 0x30, 0x0A, 0x13, + 0x7E, 0x07, 0x2D, 0xE3, 0x09, 0x10, 0x00, 0x07, 0x0A, 0x41, 0x7D, 0x54, + 0xAD, 0x57, 0x7D, 0x05, 0x1E, 0x04, 0x12, 0xBE, 0x9C, 0xDA, 0x79, 0x22, + 0x75, 0xC3, 0xFE, 0xE5, 0xDB, 0xF5, 0x63, 0xE5, 0x63, 0x30, 0xE5, 0x10, + 0x20, 0x40, 0x0D, 0xA9, 0x31, 0xDD, 0x09, 0x12, 0xDB, 0x64, 0x75, 0xDC, + 0x02, 0x75, 0xDB, 0xDF, 0xE5, 0x63, 0x30, 0xE4, 0x10, 0x30, 0x40, 0x0D, + 0xA9, 0x30, 0xDD, 0x09, 0x12, 0xB8, 0x32, 0x75, 0xDC, 0x01, 0x75, 0xDB, + 0xEF, 0xE5, 0x63, 0x30, 0xE3, 0x4B, 0x30, 0x40, 0x05, 0x12, 0xB8, 0x32, + 0x80, 0x3E, 0x30, 0x30, 0x26, 0x7E, 0x35, 0x4A, 0xE5, 0x4E, 0x0A, 0x2B, + 0x2E, 0x25, 0x4A, 0xE5, 0xDD, 0xC4, 0x54, 0x0F, 0x0A, 0x1B, 0x9D, 0x21, + 0x1B, 0x24, 0x12, 0xCF, 0x10, 0x7E, 0xB3, 0x18, 0xF2, 0x70, 0x08, 0xC2, + 0x30, 0xC2, 0x26, 0xE4, 0x12, 0xF0, 0x67, 0x7E, 0x35, 0x4A, 0xBE, 0x34, + 0x00, 0x10, 0x40, 0x09, 0xBE, 0x34, 0x00, 0x13, 0x38, 0x03, 0x12, 0xC9, + 0xDA, 0x75, 0xDD, 0x04, 0xC2, 0x45, 0x75, 0xDB, 0xF7, 0xE5, 0x63, 0x30, + 0xE6, 0x1C, 0xD2, 0x45, 0x30, 0x40, 0x03, 0x12, 0xB8, 0x32, 0xC2, 0x40, + 0x75, 0x4E, 0x00, 0x7E, 0x35, 0x4A, 0x12, 0xCB, 0x31, 0x12, 0xDB, 0x64, + 0x75, 0xDC, 0x02, 0x75, 0xDB, 0xBF, 0xE5, 0x63, 0x30, 0xE7, 0x0F, 0xD2, + 0x40, 0xD2, 0x45, 0xD2, 0x43, 0x75, 0x4E, 0x00, 0x75, 0xDC, 0x01, 0x75, + 0xDB, 0x7F, 0xE5, 0x63, 0x30, 0xE1, 0x06, 0x75, 0xDB, 0xFD, 0x75, 0xDD, + 0x04, 0xE5, 0x63, 0x30, 0xE0, 0x06, 0x75, 0xDB, 0xFE, 0x75, 0xDD, 0x04, + 0x22, 0xCA, 0x3B, 0x7E, 0xB3, 0x2D, 0x00, 0x70, 0x03, 0x02, 0xA1, 0x6E, + 0x7E, 0xB3, 0x2D, 0x06, 0x70, 0x03, 0x02, 0xA1, 0x6E, 0x12, 0xF5, 0xB7, + 0x70, 0x03, 0x02, 0xA1, 0x6E, 0x7E, 0x73, 0x2D, 0x06, 0x7E, 0xF0, 0x10, + 0xAC, 0xF7, 0x6D, 0x33, 0x9D, 0x37, 0x7A, 0x37, 0x37, 0x3A, 0x12, 0xF5, + 0x96, 0x7D, 0x63, 0xE4, 0x7A, 0xB3, 0x37, 0x34, 0x80, 0x67, 0x74, 0x02, + 0x7E, 0x73, 0x37, 0x34, 0x12, 0xB8, 0xCC, 0x7A, 0x37, 0x37, 0x36, 0xE4, + 0x7A, 0xB3, 0x37, 0x35, 0x80, 0x41, 0x0B, 0x68, 0x20, 0x0B, 0x65, 0x7E, + 0x17, 0x37, 0x36, 0x0B, 0x18, 0x30, 0x0B, 0x15, 0x7A, 0x17, 0x37, 0x36, + 0x9D, 0x32, 0x7A, 0x37, 0x37, 0x38, 0xBE, 0x77, 0x37, 0x38, 0x48, 0x0A, + 0x7E, 0x37, 0x37, 0x3A, 0xBE, 0x37, 0x37, 0x38, 0x08, 0x10, 0x74, 0x03, + 0x7A, 0xB3, 0x2D, 0x71, 0x7E, 0x73, 0x2D, 0x0B, 0x7A, 0x73, 0x2D, 0x72, + 0x80, 0x24, 0x7E, 0xB3, 0x37, 0x35, 0x04, 0x7A, 0xB3, 0x37, 0x35, 0x7E, + 0x73, 0x37, 0x35, 0xBE, 0x71, 0x5F, 0x40, 0xB6, 0x7E, 0xB3, 0x37, 0x34, + 0x04, 0x7A, 0xB3, 0x37, 0x34, 0x7E, 0x73, 0x37, 0x34, 0xBE, 0x71, 0x5E, + 0x40, 0x90, 0x7E, 0xB3, 0x2D, 0x71, 0x60, 0x1A, 0x14, 0x7A, 0xB3, 0x2D, + 0x71, 0x60, 0x0F, 0x7E, 0xA3, 0x2D, 0x0B, 0xBE, 0xA3, 0x2D, 0x72, 0x68, + 0x05, 0x14, 0x7A, 0xB3, 0x2D, 0x71, 0x74, 0x01, 0x80, 0x01, 0xE4, 0xDA, + 0x3B, 0x22, 0xCA, 0xF8, 0x6C, 0xFF, 0x75, 0xC3, 0xBF, 0x20, 0x33, 0x03, + 0x02, 0xA2, 0x0B, 0xC2, 0x34, 0x30, 0x36, 0x05, 0xC2, 0x36, 0x12, 0xDB, + 0x16, 0x7E, 0x37, 0x2D, 0xE3, 0x09, 0xB3, 0x00, 0x0B, 0x54, 0x1F, 0x0A, + 0x1B, 0x7E, 0x73, 0x18, 0xF3, 0x0A, 0x37, 0x7D, 0x23, 0x1B, 0x24, 0xBD, + 0x21, 0x58, 0x0D, 0x2E, 0x37, 0x2D, 0xE3, 0x2E, 0x34, 0x00, 0x0B, 0x7E, + 0x39, 0xF0, 0x80, 0x02, 0xC2, 0x33, 0x30, 0x33, 0x30, 0x7E, 0x73, 0x18, + 0xF3, 0xBE, 0x70, 0x02, 0x28, 0x1E, 0x7E, 0x37, 0x2D, 0xED, 0x0B, 0x38, + 0x30, 0x1E, 0x34, 0x5E, 0x34, 0x00, 0x01, 0xBE, 0x34, 0x00, 0x00, 0x28, + 0x0B, 0x74, 0xFF, 0x6C, 0x77, 0x12, 0xEE, 0xC6, 0xD2, 0x35, 0x80, 0x0C, + 0x7C, 0xBF, 0x6C, 0x77, 0x12, 0xEE, 0xC6, 0x80, 0x03, 0x12, 0xE6, 0x43, + 0xA2, 0x35, 0xE4, 0x33, 0x78, 0x10, 0x7E, 0xA3, 0x18, 0xF3, 0x7C, 0xBA, + 0x04, 0x7A, 0xB3, 0x18, 0xF3, 0x7C, 0xBA, 0x12, 0x89, 0x8F, 0xA2, 0x33, + 0xE4, 0x33, 0x78, 0x36, 0xE4, 0x7A, 0xB3, 0x18, 0xF3, 0x80, 0x2F, 0x30, + 0x01, 0x12, 0x30, 0x00, 0x0A, 0x30, 0x25, 0x03, 0x12, 0xE1, 0x45, 0xC2, + 0x25, 0x80, 0x1C, 0x12, 0xE1, 0x45, 0x80, 0x17, 0xE5, 0x59, 0x70, 0x13, + 0x12, 0xE7, 0x22, 0x60, 0x0E, 0x12, 0xDE, 0x57, 0x12, 0xEF, 0xEB, 0x12, + 0xD0, 0x39, 0x7C, 0xFB, 0x12, 0x6C, 0x19, 0x12, 0xF5, 0xCA, 0xDA, 0xF8, + 0x22, 0xCA, 0x79, 0x6C, 0xFF, 0x6C, 0xAA, 0x7E, 0xB3, 0x3B, 0x4F, 0x70, + 0x03, 0x02, 0xA3, 0x04, 0x7E, 0x73, 0x3B, 0x80, 0xBE, 0x70, 0x03, 0x40, + 0x09, 0x74, 0x31, 0x7A, 0xB3, 0x3B, 0x54, 0x02, 0xA3, 0x04, 0x7E, 0x08, + 0x3B, 0x55, 0x7E, 0xB3, 0x3B, 0x81, 0x7E, 0x37, 0x3B, 0x82, 0x7E, 0x27, + 0x3B, 0x84, 0x12, 0x87, 0x86, 0x7E, 0xF3, 0x3B, 0x55, 0x7E, 0x08, 0x3B, + 0x5F, 0x7E, 0xB3, 0x3B, 0x86, 0x7E, 0x37, 0x3B, 0x87, 0x7E, 0x27, 0x3B, + 0x89, 0x12, 0x87, 0x86, 0x7E, 0xA3, 0x3B, 0x5F, 0xBE, 0xF0, 0x30, 0x50, + 0x05, 0xBE, 0xA0, 0x30, 0x40, 0x10, 0xBC, 0xAF, 0x50, 0x04, 0x7C, 0x7F, + 0x80, 0x02, 0x7C, 0x7A, 0x7A, 0x73, 0x3B, 0x54, 0x80, 0x5E, 0x4C, 0xFF, + 0x78, 0x0B, 0x4C, 0xAA, 0x78, 0x07, 0xE4, 0x7A, 0xB3, 0x3B, 0x54, 0x80, + 0x4F, 0x74, 0x10, 0x7A, 0xB3, 0x3B, 0x54, 0xBE, 0xF0, 0x20, 0x78, 0x44, + 0xBE, 0xA0, 0x20, 0x78, 0x17, 0x7E, 0x73, 0x3B, 0x68, 0xBE, 0x73, 0x3B, + 0x5E, 0x68, 0x08, 0x74, 0x34, 0x7A, 0xB3, 0x3B, 0x54, 0x80, 0x2D, 0x7E, + 0xE0, 0x11, 0x80, 0x07, 0x4C, 0xAA, 0x78, 0x24, 0x7E, 0xE0, 0x0D, 0x7E, + 0x73, 0x3B, 0x5E, 0x1E, 0x70, 0x2C, 0xE7, 0x7C, 0xBE, 0x12, 0xD5, 0x11, + 0x50, 0x0C, 0x74, 0x20, 0x7A, 0xB3, 0x3B, 0x54, 0x7A, 0xE3, 0x3B, 0x7D, + 0x80, 0x06, 0x74, 0x3F, 0x7A, 0xB3, 0x3B, 0x54, 0xDA, 0x79, 0x22, 0x7E, + 0x34, 0x0D, 0xCC, 0xE4, 0x7E, 0x24, 0x00, 0x1D, 0x12, 0xF2, 0xF7, 0x74, + 0xFF, 0x7A, 0xB3, 0x0D, 0xBB, 0x7E, 0x37, 0x2C, 0x82, 0x7A, 0x37, 0x37, + 0x32, 0xE5, 0x5E, 0x7E, 0x71, 0x5F, 0x7E, 0x61, 0x47, 0x7E, 0x50, 0x01, + 0x7E, 0x17, 0x2C, 0x7C, 0x7E, 0x07, 0x2C, 0x61, 0x12, 0xA9, 0x17, 0x7E, + 0x37, 0x2D, 0xD9, 0x2E, 0x34, 0x00, 0x03, 0x0B, 0x38, 0x30, 0x7E, 0x27, + 0x2D, 0xD9, 0x2E, 0x24, 0x00, 0x05, 0x0B, 0x28, 0x20, 0x7E, 0x17, 0x2D, + 0xDB, 0x6D, 0x00, 0x12, 0xE8, 0x5E, 0x7E, 0x37, 0x2D, 0xE5, 0x12, 0xF2, + 0x1B, 0x12, 0xF5, 0xA0, 0x6C, 0xAA, 0x80, 0x0A, 0xE4, 0x0A, 0x2A, 0x2D, + 0x23, 0x7A, 0x29, 0xB0, 0x0B, 0xA0, 0xBE, 0xA1, 0x5F, 0x40, 0xF1, 0x74, + 0x03, 0x7A, 0xB3, 0x0D, 0xCC, 0x7E, 0x34, 0x0D, 0xE1, 0xE5, 0x50, 0x12, + 0xF0, 0xBE, 0x7E, 0x37, 0x2D, 0xD9, 0x2E, 0x34, 0x00, 0x14, 0x7E, 0x39, + 0xB0, 0x7E, 0x37, 0x2D, 0xD9, 0x2E, 0x34, 0x00, 0x15, 0x7E, 0x39, 0x70, + 0x12, 0xC8, 0xF0, 0x20, 0x01, 0x1B, 0xE4, 0x7A, 0xB3, 0x0E, 0x32, 0xE4, + 0x7A, 0xB3, 0x0D, 0xBA, 0xE5, 0x5F, 0x7E, 0x71, 0x5E, 0x7E, 0x61, 0x50, + 0x7E, 0x17, 0x2D, 0xDF, 0x6D, 0x00, 0x12, 0xC7, 0x04, 0x6D, 0x33, 0x7A, + 0x37, 0x0D, 0xE9, 0x7A, 0x37, 0x0D, 0xF5, 0x7E, 0x34, 0x0D, 0xBC, 0xE4, + 0x7E, 0x24, 0x00, 0x10, 0x12, 0xF2, 0xF7, 0x22, 0xCA, 0x79, 0x7E, 0x73, + 0x04, 0x4C, 0x5E, 0x70, 0x0F, 0x7E, 0x63, 0x04, 0x4D, 0x4C, 0x66, 0x78, + 0x03, 0x02, 0xA4, 0x96, 0x6C, 0x55, 0x0A, 0x15, 0x09, 0xB1, 0x07, 0x27, + 0xBE, 0xB0, 0x01, 0x68, 0x07, 0xE4, 0x0A, 0x15, 0x19, 0xB1, 0x08, 0x3F, + 0x0A, 0x15, 0x09, 0xB1, 0x07, 0x31, 0x70, 0x03, 0x02, 0xA4, 0x8B, 0x0A, + 0x15, 0x09, 0x11, 0x07, 0x27, 0xBE, 0x10, 0x01, 0x68, 0x04, 0xA5, 0xB9, + 0x02, 0x79, 0x0A, 0x15, 0x09, 0x41, 0x07, 0x95, 0x7E, 0x90, 0x10, 0xAC, + 0x94, 0x2E, 0x44, 0x07, 0x9F, 0x0B, 0x48, 0x10, 0x0A, 0x56, 0xBD, 0x51, + 0x08, 0x61, 0xA5, 0xB9, 0x01, 0x5D, 0x0A, 0x05, 0x09, 0x10, 0x07, 0x1D, + 0xBE, 0x13, 0x04, 0x2A, 0x50, 0x51, 0x09, 0x14, 0x00, 0x04, 0x0A, 0x01, + 0x7E, 0xF3, 0x04, 0x12, 0x0A, 0x5F, 0xBD, 0x51, 0x08, 0x02, 0x0B, 0x04, + 0x0A, 0x55, 0x09, 0xE5, 0x08, 0x3F, 0x0A, 0x57, 0xBD, 0x50, 0x48, 0x05, + 0xBE, 0xE0, 0x00, 0x28, 0x28, 0xE4, 0x0A, 0xF5, 0x19, 0xBF, 0x07, 0x1D, + 0x0A, 0x57, 0xBD, 0x50, 0x48, 0x09, 0xBE, 0xE0, 0x00, 0x28, 0x16, 0x1B, + 0xE0, 0x80, 0x12, 0x7E, 0xB3, 0x04, 0x2A, 0x0A, 0xFB, 0x2E, 0xF4, 0x00, + 0x0A, 0x0A, 0x5E, 0xBD, 0x5F, 0x58, 0x02, 0x0B, 0xE0, 0x0A, 0x55, 0x19, + 0xE5, 0x08, 0x3F, 0x0B, 0x50, 0xA5, 0xBD, 0x0A, 0x02, 0x80, 0x03, 0x02, + 0xA3, 0xE6, 0xDA, 0x79, 0x22, 0x7E, 0x34, 0x2C, 0x87, 0x7E, 0x24, 0x01, + 0x02, 0x12, 0xF2, 0x4B, 0x7E, 0xB3, 0x2D, 0x0D, 0x7E, 0x73, 0x2D, 0x0E, + 0x6C, 0x66, 0x12, 0x88, 0x8E, 0x7E, 0x37, 0x2D, 0xE1, 0x0B, 0x35, 0x7E, + 0x39, 0x70, 0x7A, 0x73, 0x2D, 0x02, 0x7E, 0x37, 0x2D, 0xE1, 0x0B, 0x36, + 0x7E, 0x39, 0x70, 0x7A, 0x73, 0x2D, 0x03, 0x7E, 0x37, 0x2D, 0xE1, 0x2E, + 0x34, 0x00, 0x05, 0x7E, 0x39, 0x70, 0x7A, 0x73, 0x2D, 0x04, 0x7E, 0x37, + 0x2D, 0xE1, 0x2E, 0x34, 0x00, 0x09, 0x7E, 0x39, 0x70, 0x7A, 0x73, 0x2D, + 0x05, 0x7E, 0x37, 0x2D, 0xE1, 0x2E, 0x34, 0x00, 0x0A, 0x7E, 0x39, 0x70, + 0x7A, 0x73, 0x2D, 0x06, 0x7E, 0x37, 0x2D, 0xE1, 0x2E, 0x34, 0x00, 0x0B, + 0x7E, 0x39, 0x70, 0x7A, 0x73, 0x2D, 0x07, 0x7E, 0x37, 0x2D, 0xE1, 0x0B, + 0x34, 0x7E, 0x39, 0x70, 0x7A, 0x73, 0x2D, 0x0A, 0xE5, 0x50, 0x7A, 0xB3, + 0x2C, 0x87, 0x7E, 0x37, 0x2D, 0xE1, 0x7E, 0x39, 0xB0, 0x30, 0xE1, 0x0E, + 0x74, 0x01, 0x7A, 0xB3, 0x2C, 0x89, 0x74, 0x01, 0x7A, 0xB3, 0x2C, 0x8A, + 0x80, 0x21, 0x74, 0x03, 0x7A, 0xB3, 0x2C, 0x8B, 0xE4, 0x7A, 0xB3, 0x2C, + 0x89, 0xE4, 0x7A, 0xB3, 0x2C, 0x8A, 0x6C, 0xAA, 0x74, 0xFF, 0x0A, 0x4A, + 0x19, 0xB4, 0x2C, 0xC4, 0x0B, 0xA0, 0xBE, 0xA0, 0x0E, 0x78, 0xF1, 0x74, + 0xFF, 0x7A, 0xB3, 0x2D, 0x82, 0x74, 0x0F, 0x7A, 0xB3, 0x2D, 0x83, 0x22, + 0xCA, 0x3B, 0xE4, 0x7A, 0xB3, 0x04, 0x07, 0x7E, 0xB3, 0x03, 0xC8, 0x60, + 0x03, 0x02, 0xA6, 0x21, 0x7E, 0xF3, 0x04, 0x4B, 0x4C, 0xFF, 0x78, 0x03, + 0x02, 0xA6, 0x21, 0x7E, 0xB3, 0x03, 0xB7, 0x60, 0x03, 0x02, 0xA6, 0x21, + 0x7E, 0xB3, 0x03, 0xB6, 0x70, 0x03, 0x02, 0xA6, 0x21, 0x7E, 0x04, 0x07, + 0x27, 0x7E, 0x44, 0x0A, 0x42, 0x7E, 0x34, 0x05, 0xA1, 0x7E, 0x24, 0x07, + 0x45, 0x7C, 0xAF, 0x5E, 0xA0, 0x0F, 0x78, 0x03, 0x7E, 0xA0, 0x7F, 0x7E, + 0x14, 0xFF, 0xFF, 0x6C, 0xDD, 0x7E, 0xE0, 0xFF, 0x7E, 0xF0, 0x0A, 0x7E, + 0x09, 0xB0, 0xB4, 0x01, 0x25, 0x7E, 0x49, 0xB0, 0xBC, 0xBA, 0x08, 0x06, + 0x74, 0x80, 0x7A, 0xB3, 0x04, 0x07, 0x0B, 0x38, 0xF0, 0xBD, 0xF1, 0x50, + 0x02, 0x7D, 0x1F, 0x7E, 0x29, 0xC0, 0xBC, 0xEC, 0x28, 0x02, 0x7C, 0xEC, + 0xBC, 0xDC, 0x50, 0x02, 0x7C, 0xDC, 0x0B, 0x04, 0x0B, 0x44, 0x2E, 0x34, + 0x00, 0x08, 0x0B, 0x24, 0x1B, 0xF0, 0x78, 0xC7, 0x7E, 0xB3, 0x03, 0xB6, + 0xBE, 0xB0, 0x01, 0x28, 0x2C, 0xBE, 0x14, 0x00, 0x30, 0x38, 0x26, 0x7E, + 0xB3, 0x04, 0x4B, 0x54, 0xF0, 0xC4, 0x23, 0x54, 0x1F, 0x7C, 0xAB, 0x4C, + 0xAB, 0x68, 0x16, 0x0A, 0x2E, 0x0A, 0x3D, 0x9D, 0x32, 0x1A, 0x0A, 0xBD, + 0x30, 0x08, 0x0A, 0x7E, 0xB3, 0x04, 0x07, 0x44, 0x01, 0x7A, 0xB3, 0x04, + 0x07, 0xDA, 0x3B, 0x22, 0xCA, 0x3B, 0x7D, 0x60, 0x7D, 0x71, 0x7A, 0x27, + 0x37, 0x36, 0x7A, 0x37, 0x37, 0x34, 0xBE, 0x74, 0x00, 0x20, 0x08, 0x03, + 0x02, 0xA6, 0xE2, 0xE4, 0x7A, 0xB3, 0x37, 0x39, 0x7E, 0x37, 0x2D, 0xD9, + 0x2E, 0x34, 0x00, 0x0B, 0x7E, 0x39, 0xB0, 0x30, 0xE2, 0x5D, 0x7E, 0x37, + 0x2D, 0xD9, 0x2E, 0x34, 0x00, 0x13, 0x7E, 0x39, 0xB0, 0x12, 0xE5, 0x22, + 0x7E, 0x27, 0x2C, 0x61, 0xE4, 0x7A, 0xB3, 0x37, 0x38, 0x80, 0x20, 0x7E, + 0x63, 0x37, 0x38, 0x7E, 0x70, 0x02, 0xAC, 0x67, 0x7D, 0x13, 0x2E, 0x17, + 0x37, 0x36, 0x0B, 0x18, 0x10, 0x2D, 0x32, 0x1B, 0x38, 0x10, 0x7E, 0xB3, + 0x37, 0x38, 0x04, 0x7A, 0xB3, 0x37, 0x38, 0x7E, 0x73, 0x37, 0x38, 0x0A, + 0x37, 0xBD, 0x37, 0x48, 0xD6, 0x7E, 0x37, 0x37, 0x34, 0x7D, 0x16, 0x7C, + 0xBF, 0x7E, 0x07, 0x2D, 0xD9, 0x2E, 0x04, 0x00, 0x12, 0x7E, 0x09, 0x10, + 0x12, 0x91, 0x43, 0x7A, 0xB3, 0x37, 0x39, 0x7E, 0xB3, 0x37, 0x39, 0x70, + 0x31, 0xE4, 0x7A, 0xB3, 0x37, 0x38, 0x80, 0x20, 0x7E, 0x63, 0x37, 0x38, + 0x7E, 0x70, 0x02, 0xAC, 0x67, 0x7D, 0x23, 0x2E, 0x27, 0x37, 0x34, 0x0B, + 0x28, 0x20, 0x2D, 0x36, 0x1B, 0x38, 0x20, 0x7E, 0xB3, 0x37, 0x38, 0x04, + 0x7A, 0xB3, 0x37, 0x38, 0x7E, 0x73, 0x37, 0x38, 0x0A, 0x37, 0xBD, 0x37, + 0x48, 0xD6, 0xDA, 0x3B, 0x22, 0xCA, 0xF8, 0x7E, 0xA3, 0x3B, 0x80, 0x7E, + 0x37, 0x3B, 0x82, 0x7E, 0x27, 0x3B, 0x84, 0x7E, 0xB3, 0x39, 0x2C, 0x70, + 0x09, 0x7E, 0xB3, 0x39, 0x2D, 0x70, 0x03, 0x02, 0xA7, 0xA2, 0xBE, 0xA0, + 0x02, 0x40, 0x09, 0x74, 0x31, 0x7A, 0xB3, 0x39, 0x2B, 0x02, 0xA7, 0xA2, + 0xBE, 0xA0, 0x01, 0x78, 0x1E, 0x7E, 0xF3, 0x39, 0x2B, 0x4C, 0xFF, 0x78, + 0x0C, 0x12, 0xD3, 0x9C, 0x74, 0x10, 0x7A, 0xB3, 0x39, 0x2B, 0x02, 0xA7, + 0xA2, 0xBE, 0xF0, 0x10, 0x78, 0x74, 0x12, 0xDE, 0x0F, 0x80, 0x6F, 0x7E, + 0xB3, 0x39, 0x2B, 0xB4, 0x10, 0x63, 0x12, 0xDF, 0xB2, 0x7E, 0xB3, 0x39, + 0x2B, 0xB4, 0x10, 0x5E, 0x7E, 0xB3, 0x3A, 0x44, 0xB4, 0x02, 0x1C, 0x7E, + 0xB3, 0x39, 0x30, 0xB4, 0x05, 0x15, 0x74, 0x01, 0x7A, 0xB3, 0x3A, 0x44, + 0x74, 0x06, 0x12, 0xD5, 0x11, 0xE4, 0x33, 0x78, 0x06, 0x74, 0x0B, 0x7A, + 0xB3, 0x39, 0x30, 0x7E, 0x73, 0x3A, 0x44, 0xBE, 0x70, 0x01, 0x38, 0x09, + 0x7E, 0xA3, 0x39, 0x30, 0xBE, 0xA0, 0xFF, 0x78, 0x08, 0x74, 0x3E, 0x7A, + 0xB3, 0x39, 0x2B, 0x80, 0x21, 0x7C, 0xBA, 0x04, 0x12, 0xD5, 0x11, 0x50, + 0x19, 0x74, 0x20, 0x7A, 0xB3, 0x39, 0x2B, 0x7E, 0x73, 0x39, 0x30, 0x0A, + 0x37, 0x0B, 0x34, 0x7A, 0x73, 0x3B, 0x7D, 0x80, 0x05, 0xE4, 0x7A, 0xB3, + 0x39, 0x2B, 0xDA, 0xF8, 0x22, 0xCA, 0x3B, 0x7F, 0x30, 0x7C, 0xAB, 0xE4, + 0x7A, 0xB3, 0x39, 0x21, 0xE4, 0x7A, 0xB3, 0x39, 0x26, 0x7C, 0xBA, 0x7E, + 0x34, 0x39, 0x21, 0x12, 0x76, 0x16, 0x7C, 0xAB, 0x7E, 0xB3, 0x39, 0x21, + 0x60, 0x04, 0x74, 0x80, 0x80, 0x01, 0xE4, 0x7E, 0x47, 0x39, 0x22, 0x7D, + 0x24, 0x1A, 0x24, 0x5E, 0x24, 0x00, 0x3F, 0x0A, 0x3B, 0x2D, 0x32, 0x7C, + 0xB7, 0x7A, 0x3B, 0xB0, 0x0B, 0x74, 0x7E, 0x37, 0x39, 0x22, 0x7C, 0xB7, + 0x7A, 0x3B, 0xB0, 0x0B, 0x74, 0x7E, 0x37, 0x39, 0x24, 0x1A, 0x36, 0x7C, + 0xB7, 0x54, 0x3F, 0x7A, 0x3B, 0xB0, 0x0B, 0x74, 0x7E, 0x37, 0x39, 0x24, + 0x7C, 0xB7, 0x7A, 0x3B, 0xB0, 0x0B, 0x74, 0x0B, 0x74, 0x0B, 0x74, 0x0B, + 0x74, 0x7E, 0xB3, 0x39, 0x26, 0x60, 0x04, 0x74, 0x80, 0x80, 0x01, 0xE4, + 0x7E, 0x47, 0x39, 0x27, 0x7D, 0x24, 0x1A, 0x24, 0x5E, 0x24, 0x00, 0x3F, + 0x0A, 0x3B, 0x2D, 0x32, 0x7C, 0xB7, 0x7A, 0x3B, 0xB0, 0x0B, 0x74, 0x7E, + 0x37, 0x39, 0x27, 0x7C, 0xB7, 0x7A, 0x3B, 0xB0, 0x0B, 0x74, 0x7E, 0x37, + 0x39, 0x29, 0x1A, 0x36, 0x7C, 0xB7, 0x54, 0x3F, 0x7A, 0x3B, 0xB0, 0x0B, + 0x74, 0x7E, 0x37, 0x39, 0x29, 0x7C, 0xB7, 0x7A, 0x3B, 0xB0, 0xBE, 0xA0, + 0x01, 0x78, 0x02, 0x0B, 0xA0, 0x7C, 0xBA, 0xDA, 0x3B, 0x22, 0xCA, 0x3B, + 0x7D, 0x40, 0x7D, 0xF1, 0x7D, 0x12, 0x7D, 0x03, 0x7C, 0xAB, 0x74, 0x08, + 0x7D, 0x3F, 0x9E, 0x37, 0x37, 0x3C, 0x9E, 0x47, 0x37, 0x3E, 0xBE, 0x34, + 0x00, 0x00, 0x58, 0x06, 0x6D, 0xEE, 0x9D, 0xE3, 0x80, 0x02, 0x7D, 0xE3, + 0xBE, 0x44, 0x00, 0x00, 0x58, 0x06, 0x6D, 0xFF, 0x9D, 0xF4, 0x80, 0x02, + 0x7D, 0xF4, 0xBD, 0x0E, 0x28, 0x04, 0xBD, 0x1F, 0x38, 0x7A, 0x4C, 0xAA, + 0x78, 0x1C, 0x7D, 0xDE, 0x3E, 0xD4, 0x3E, 0xD4, 0x3E, 0xD4, 0x3E, 0xD4, + 0x8D, 0xD0, 0x7D, 0xED, 0x7D, 0x0F, 0x3E, 0x04, 0x3E, 0x04, 0x3E, 0x04, + 0x3E, 0x04, 0x8D, 0x01, 0x7D, 0xF1, 0x7E, 0x14, 0x00, 0x6A, 0x7D, 0xDE, + 0xAD, 0xD1, 0x7D, 0x7D, 0x7D, 0x6C, 0x7C, 0xFE, 0x7C, 0xED, 0x0A, 0x6C, + 0x7D, 0x27, 0xAD, 0x1F, 0x7C, 0x32, 0x7C, 0x21, 0x0A, 0x00, 0x7D, 0x51, + 0xBD, 0x5E, 0x28, 0x04, 0x74, 0x02, 0x80, 0x09, 0xBD, 0x2F, 0x28, 0x03, + 0xE4, 0x80, 0x02, 0x74, 0x01, 0xBE, 0x34, 0x00, 0x00, 0x58, 0x08, 0x0A, + 0x3B, 0x7E, 0x54, 0x00, 0x04, 0x9D, 0x53, 0xBE, 0x44, 0x00, 0x00, 0x58, + 0x08, 0x0A, 0x4B, 0x7E, 0x54, 0x00, 0x08, 0x9D, 0x54, 0x0A, 0x1B, 0x7E, + 0x24, 0x00, 0x08, 0x7D, 0x32, 0x9D, 0x31, 0x12, 0x8C, 0x88, 0x7C, 0xB5, + 0xDA, 0x3B, 0x22, 0xCA, 0x3B, 0x7D, 0x70, 0x7D, 0x61, 0x7A, 0x53, 0x37, + 0x31, 0x7A, 0x63, 0x37, 0x30, 0x7A, 0x73, 0x37, 0x2F, 0x7A, 0xB3, 0x37, + 0x2E, 0x7E, 0x34, 0x03, 0x00, 0x7E, 0x24, 0x01, 0x10, 0x12, 0xF2, 0xA4, + 0x7E, 0x34, 0x05, 0xA1, 0x7E, 0x24, 0x05, 0x1E, 0x12, 0xF2, 0xA4, 0x7E, + 0x34, 0x05, 0x16, 0x7E, 0x24, 0x00, 0x8B, 0x12, 0xF2, 0xA4, 0x7E, 0x73, + 0x37, 0x31, 0x7A, 0x73, 0x05, 0x16, 0x7E, 0x73, 0x37, 0x2E, 0x7A, 0x73, + 0x05, 0x17, 0x7E, 0x73, 0x37, 0x2F, 0x7A, 0x73, 0x05, 0x18, 0x7E, 0x73, + 0x37, 0x30, 0x7A, 0x73, 0x05, 0x19, 0x7A, 0x67, 0x03, 0x0E, 0x7E, 0x34, + 0xB0, 0x00, 0x7A, 0x37, 0x03, 0x10, 0x7A, 0x77, 0x05, 0x14, 0x7E, 0x37, + 0x37, 0x32, 0x7A, 0x37, 0x03, 0x00, 0x7E, 0xB3, 0x05, 0x16, 0x60, 0x0E, + 0x7E, 0x73, 0x05, 0x18, 0x7A, 0x73, 0x05, 0x1A, 0x7E, 0x73, 0x05, 0x17, + 0x80, 0x0C, 0x7E, 0x73, 0x05, 0x17, 0x7A, 0x73, 0x05, 0x1A, 0x7E, 0x73, + 0x05, 0x18, 0x7A, 0x73, 0x05, 0x1B, 0x7E, 0x34, 0x80, 0x00, 0x7A, 0x37, + 0x08, 0xDF, 0x7A, 0x37, 0x08, 0xE1, 0x74, 0x01, 0x12, 0xBB, 0xBB, 0x74, + 0x01, 0x12, 0xE2, 0x07, 0xE4, 0x12, 0xEF, 0xCB, 0x74, 0x0C, 0x12, 0xED, + 0x3F, 0xDA, 0x3B, 0x22, 0xCA, 0x79, 0x7C, 0xAB, 0x7E, 0x24, 0x3A, 0x7C, + 0xE4, 0x7D, 0x32, 0x2E, 0x34, 0x00, 0x13, 0x7D, 0x72, 0x2E, 0x74, 0x00, + 0x53, 0xBE, 0xA0, 0x00, 0x58, 0x4E, 0x7E, 0x34, 0x0E, 0x07, 0x7D, 0x27, + 0x2E, 0x24, 0x00, 0x0E, 0x7E, 0x14, 0x00, 0x14, 0x12, 0xF3, 0x47, 0x7E, + 0x34, 0x0E, 0x1B, 0x7D, 0x27, 0x2E, 0x24, 0x00, 0x22, 0x7E, 0x14, 0x00, + 0x14, 0x12, 0xF3, 0x47, 0x7E, 0x34, 0x0D, 0xF7, 0x7D, 0x27, 0x0B, 0x26, + 0x7E, 0x14, 0x00, 0x0A, 0x12, 0xF3, 0x47, 0x7E, 0x34, 0x0D, 0xEB, 0x7D, + 0x27, 0x2E, 0x24, 0x00, 0x36, 0x7E, 0x14, 0x00, 0x0A, 0x12, 0xF3, 0x47, + 0x09, 0x77, 0x00, 0x03, 0x7A, 0x73, 0x0E, 0x31, 0x74, 0x01, 0x80, 0x49, + 0x7C, 0x2A, 0x09, 0xB2, 0x00, 0x02, 0x70, 0x02, 0x0B, 0x20, 0x09, 0x32, + 0x00, 0x01, 0xAC, 0x23, 0x7D, 0x51, 0x5E, 0x54, 0x00, 0x0F, 0x7E, 0x39, + 0xA0, 0x1A, 0x0A, 0x3E, 0x04, 0x3E, 0x04, 0x3E, 0x04, 0x3E, 0x04, 0x7E, + 0x79, 0xA0, 0x1A, 0x2A, 0x3E, 0x24, 0x3E, 0x24, 0x3E, 0x24, 0x3E, 0x24, + 0xBD, 0x01, 0x18, 0x13, 0xBD, 0x21, 0x48, 0x0F, 0xBD, 0x21, 0x78, 0x04, + 0x70, 0x02, 0x74, 0x10, 0x7D, 0x27, 0x12, 0x7B, 0x34, 0x80, 0x02, 0x74, + 0xFF, 0xDA, 0x79, 0x22, 0xBB, 0xBC, 0xE3, 0x41, 0xF7, 0x4E, 0xF5, 0x7A, + 0xB5, 0x33, 0xD1, 0x0C, 0x3C, 0xF0, 0x1C, 0xAF, 0xA9, 0x87, 0x91, 0xBA, + 0x9C, 0xFA, 0xB6, 0x9A, 0x8C, 0xE4, 0x81, 0xF9, 0xAD, 0xD8, 0x6D, 0xFC, + 0x03, 0x38, 0xD5, 0x50, 0x87, 0x46, 0x0A, 0x78, 0x94, 0x0F, 0x68, 0x15, + 0x5D, 0xF8, 0x7C, 0x12, 0xB3, 0x8D, 0xEA, 0x77, 0x6C, 0xD8, 0x2B, 0x42, + 0x90, 0xE9, 0xD5, 0x14, 0xB7, 0x4C, 0x0E, 0x8C, 0x3B, 0x8A, 0x39, 0x9D, + 0x95, 0x94, 0xA6, 0x36, 0x1F, 0x1B, 0x4E, 0x8F, 0x8A, 0xB1, 0x3C, 0xFB, + 0x3F, 0xC9, 0xE5, 0x78, 0xF6, 0x65, 0xEC, 0xEA, 0x4D, 0x06, 0x1B, 0x4E, + 0x92, 0x38, 0x8D, 0xB4, 0x92, 0xCD, 0xE1, 0x56, 0x39, 0x14, 0xDB, 0x26, + 0x20, 0x1B, 0x59, 0x9A, 0x89, 0xF0, 0xFE, 0xA0, 0xD2, 0xCB, 0xFB, 0xEE, + 0xCE, 0x8E, 0x56, 0xA8, 0x29, 0xAB, 0x8E, 0x8A, 0x3B, 0x40, 0x19, 0x0A, + 0xE9, 0x02, 0xF1, 0xAD, 0xFD, 0xC3, 0x4C, 0x80, 0x14, 0x36, 0xB3, 0xD8, + 0x12, 0xAD, 0x7C, 0x75, 0xA8, 0x02, 0xFB, 0x8D, 0xF5, 0x65, 0x53, 0xD4, + 0xBA, 0xB6, 0xC5, 0xAC, 0x25, 0x30, 0xF4, 0x65, 0xD3, 0x87, 0x63, 0x59, + 0x60, 0xC5, 0x30, 0x3C, 0x2E, 0x77, 0x59, 0xEF, 0xCE, 0x03, 0x03, 0xB5, + 0x12, 0xB3, 0x36, 0x5F, 0x78, 0xE0, 0xD3, 0xE3, 0x6D, 0xFD, 0x77, 0x2A, + 0x16, 0x69, 0x7F, 0xD5, 0xFD, 0x5F, 0x52, 0x0A, 0xED, 0xAA, 0xDA, 0xF2, + 0x5E, 0xA7, 0x7E, 0xAF, 0x53, 0xF1, 0x2B, 0xED, 0x89, 0x35, 0x75, 0x71, + 0x7E, 0xEA, 0xEB, 0x5B, 0x21, 0x06, 0x24, 0xDB, 0x52, 0x54, 0xA9, 0x31, + 0x74, 0x16, 0x49, 0x97, 0xAB, 0x8D, 0xE6, 0x10, 0x1E, 0x13, 0x60, 0x1E, + 0xC6, 0xE9, 0x94, 0xE3, 0x30, 0xDA, 0x26, 0xBF, 0x2F, 0x5C, 0x94, 0x4C, + 0x69, 0xCA, 0xA4, 0xF2, 0x44, 0xEF, 0xD4, 0x5C, 0x05, 0x64, 0x4E, 0x7F, + 0x48, 0x8D, 0xF4, 0x23, 0x10, 0xB8, 0x30, 0xEF, 0x09, 0x98, 0xF7, 0x0D, + 0xD8, 0xAD, 0xB1, 0x53, 0x0C, 0xD4, 0x11, 0x0C, 0xE7, 0x8A, 0x5F, 0xD6, + 0xD3, 0x9D, 0xF5, 0x19, 0x09, 0x5A, 0x4A, 0x26, 0xB5, 0x72, 0x4A, 0xF9, + 0xE4, 0x9E, 0x79, 0x25, 0xB3, 0x4C, 0x0C, 0xE3, 0xAF, 0xC9, 0x63, 0x6B, + 0x77, 0xC5, 0x29, 0x63, 0xE1, 0x15, 0x81, 0xA2, 0xD0, 0x96, 0x06, 0x1D, + 0x7E, 0x21, 0xEB, 0x25, 0x49, 0xD9, 0x2F, 0x58, 0x74, 0x61, 0x88, 0xF3, + 0xC6, 0xA5, 0x8D, 0xD8, 0x84, 0xE0, 0x4A, 0x7A, 0x3B, 0x77, 0xA7, 0x8E, + 0x3E, 0x52, 0x7B, 0xA6, 0xEB, 0xE6, 0xFE, 0x14, 0x87, 0xF0, 0xA4, 0x12, + 0xB3, 0xD9, 0xC3, 0x13, 0x60, 0x0D, 0x0B, 0x28, 0x10, 0x1B, 0x38, 0x10, + 0x0B, 0x35, 0x0B, 0x25, 0x14, 0x70, 0xF3, 0x50, 0x06, 0x7E, 0x29, 0x20, + 0x7A, 0x39, 0x20, 0x22, 0x6D, 0x00, 0xBD, 0x10, 0x68, 0x17, 0x7E, 0x29, + 0xA0, 0x4D, 0x33, 0x68, 0x05, 0x7A, 0x39, 0xA0, 0x0B, 0x34, 0x2C, 0xBA, + 0x23, 0x0B, 0x24, 0x0B, 0x04, 0xBD, 0x01, 0x78, 0xE9, 0x22, 0x7C, 0x03, + 0xBE, 0x00, 0x00, 0x68, 0x17, 0x0A, 0x42, 0x3E, 0x44, 0x0B, 0x28, 0x10, + 0x1B, 0x38, 0x10, 0xA5, 0x2A, 0x23, 0xA5, 0x2B, 0x23, 0x0B, 0x35, 0x2D, + 0x24, 0xA5, 0xD8, 0xED, 0x22, 0xBE, 0x14, 0x00, 0x00, 0x68, 0x26, 0x6C, + 0x00, 0xBE, 0x40, 0x00, 0x78, 0x14, 0xBE, 0x50, 0x80, 0x40, 0x0F, 0xC2, + 0xAF, 0x00, 0x43, 0xB9, 0x80, 0x0B, 0x28, 0x00, 0x53, 0xB9, 0x7F, 0xD2, + 0xAF, 0x00, 0x7A, 0x39, 0x00, 0x0B, 0x34, 0x0B, 0x24, 0x1B, 0x14, 0x80, + 0xD4, 0x22, 0xBE, 0x14, 0x00, 0x00, 0x68, 0x26, 0xBE, 0x60, 0x00, 0x78, + 0x21, 0xBE, 0x70, 0x80, 0x40, 0x14, 0xC2, 0xAF, 0x00, 0x7E, 0x29, 0x10, + 0x7C, 0x01, 0x43, 0xB9, 0x80, 0x1B, 0x38, 0x00, 0x53, 0xB9, 0x7F, 0xD2, + 0xAF, 0x00, 0x0B, 0x34, 0x0B, 0x24, 0x1B, 0x14, 0x80, 0xD4, 0x22, 0x7C, + 0xAB, 0xBE, 0xA0, 0x01, 0x78, 0x03, 0x02, 0xAD, 0x3E, 0xE4, 0x7A, 0xB3, + 0x04, 0x08, 0xBE, 0xA0, 0x02, 0x68, 0x03, 0x02, 0xAD, 0x44, 0x7E, 0xB3, + 0x04, 0x70, 0x20, 0xE2, 0x03, 0x02, 0xAD, 0x44, 0x7E, 0xF4, 0xC1, 0x50, + 0x7D, 0x4F, 0x2E, 0x44, 0x00, 0x10, 0x7E, 0x63, 0x05, 0x1B, 0x7E, 0x73, + 0x05, 0x1A, 0x09, 0x1F, 0x00, 0x04, 0xBE, 0x10, 0x00, 0x28, 0x02, 0x1B, + 0x10, 0x09, 0x3F, 0x00, 0x05, 0x0A, 0xE7, 0x1B, 0xE4, 0x0A, 0x53, 0xBD, + 0x5E, 0x58, 0x02, 0x0B, 0x30, 0x09, 0x44, 0x00, 0x04, 0xBE, 0x40, 0x00, + 0x28, 0x02, 0x1B, 0x40, 0x09, 0x24, 0x00, 0x05, 0x0A, 0x52, 0xBD, 0x5E, + 0x58, 0x02, 0x0B, 0x20, 0x09, 0x5F, 0x00, 0x06, 0xBE, 0x50, 0x00, 0x28, + 0x02, 0x1B, 0x50, 0x09, 0x7F, 0x00, 0x07, 0x0A, 0xF6, 0x1B, 0xF4, 0x0A, + 0x57, 0xBD, 0x5F, 0x58, 0x02, 0x0B, 0x70, 0x09, 0xA4, 0x00, 0x06, 0xBE, + 0xA0, 0x00, 0x28, 0x02, 0x1B, 0xA0, 0x09, 0x64, 0x00, 0x07, 0x0A, 0x46, + 0xBD, 0x4F, 0x58, 0x02, 0x0B, 0x60, 0xBC, 0x21, 0x40, 0x0C, 0xBC, 0x43, + 0x38, 0x08, 0xBC, 0x65, 0x40, 0x04, 0xBC, 0xA7, 0x28, 0x06, 0x74, 0x01, + 0x7A, 0xB3, 0x04, 0x08, 0x22, 0xCA, 0xD8, 0xCA, 0x79, 0x7C, 0xD6, 0x7C, + 0xF7, 0x7C, 0xEB, 0xE5, 0x52, 0x20, 0xE2, 0x03, 0x02, 0xAD, 0xEC, 0x12, + 0xD6, 0x7D, 0x12, 0xE3, 0x7F, 0xBE, 0xE0, 0x00, 0x28, 0x08, 0x0A, 0x3E, + 0xBE, 0x37, 0x28, 0x1F, 0x48, 0x21, 0xBE, 0xF0, 0x00, 0x28, 0x60, 0x7E, + 0x37, 0x28, 0x19, 0xBE, 0x34, 0x00, 0x00, 0x58, 0x08, 0x6D, 0x22, 0x9E, + 0x27, 0x28, 0x19, 0x80, 0x04, 0x7E, 0x27, 0x28, 0x19, 0x0A, 0x3F, 0xBD, + 0x23, 0x08, 0x44, 0x74, 0x01, 0x7A, 0xB3, 0x18, 0xF9, 0x7E, 0xB3, 0x2C, + 0x84, 0x04, 0x7A, 0xB3, 0x2C, 0x84, 0x12, 0xD6, 0xD6, 0xB4, 0x01, 0x38, + 0x7E, 0xB3, 0x2C, 0x60, 0xBE, 0xB0, 0xFF, 0x50, 0x05, 0x04, 0x7A, 0xB3, + 0x2C, 0x60, 0x7E, 0x37, 0x2D, 0xD9, 0x09, 0x73, 0x00, 0x18, 0xBE, 0x73, + 0x2C, 0x60, 0x78, 0x1C, 0xE4, 0x7A, 0xB3, 0x2C, 0x60, 0xE4, 0x7E, 0x34, + 0x2E, 0x53, 0x7E, 0x24, 0x00, 0x00, 0x7A, 0x1B, 0xB0, 0x80, 0x09, 0x7E, + 0xB3, 0x2B, 0xB0, 0x04, 0x7A, 0xB3, 0x2B, 0xB0, 0xE4, 0x12, 0xDC, 0x00, + 0x7E, 0xB3, 0x18, 0xF9, 0x70, 0x0A, 0x7C, 0xBD, 0x12, 0x83, 0x5A, 0x74, + 0x01, 0x12, 0xDB, 0xB2, 0xDA, 0x79, 0xDA, 0xD8, 0x22, 0x7D, 0x02, 0x7D, + 0x13, 0x74, 0x01, 0x19, 0xB0, 0x00, 0x09, 0x09, 0x60, 0x00, 0x08, 0x7D, + 0x21, 0x2E, 0x24, 0x00, 0x08, 0x7E, 0x29, 0x70, 0x2C, 0x76, 0x7A, 0x29, + 0x70, 0x09, 0x60, 0x00, 0x0A, 0x7D, 0x21, 0x2E, 0x24, 0x00, 0x0A, 0x7E, + 0x29, 0x70, 0x2C, 0x76, 0x7A, 0x29, 0x70, 0x09, 0x70, 0x00, 0x04, 0x09, + 0x61, 0x00, 0x04, 0xBC, 0x67, 0x28, 0x04, 0x19, 0x71, 0x00, 0x04, 0x09, + 0x70, 0x00, 0x05, 0x09, 0x61, 0x00, 0x05, 0xBC, 0x67, 0x50, 0x04, 0x19, + 0x71, 0x00, 0x05, 0x09, 0x70, 0x00, 0x06, 0x09, 0x61, 0x00, 0x06, 0xBC, + 0x67, 0x28, 0x04, 0x19, 0x71, 0x00, 0x06, 0x09, 0x70, 0x00, 0x07, 0x09, + 0x61, 0x00, 0x07, 0xBC, 0x67, 0x50, 0x04, 0x19, 0x71, 0x00, 0x07, 0x49, + 0x30, 0x00, 0x02, 0x49, 0x21, 0x00, 0x02, 0xBD, 0x23, 0x58, 0x04, 0x59, + 0x31, 0x00, 0x02, 0x0B, 0x08, 0x00, 0x0B, 0x18, 0x30, 0xBD, 0x30, 0x08, + 0x03, 0x1B, 0x18, 0x00, 0x09, 0x71, 0x00, 0x04, 0x19, 0x71, 0x00, 0x0C, + 0x09, 0x71, 0x00, 0x05, 0x19, 0x71, 0x00, 0x0D, 0x09, 0x71, 0x00, 0x06, + 0x19, 0x71, 0x00, 0x0E, 0x09, 0x71, 0x00, 0x07, 0x19, 0x71, 0x00, 0x0F, + 0x22, 0x7C, 0xAB, 0x54, 0x03, 0x0A, 0x3B, 0x6D, 0x22, 0x2E, 0x24, 0x00, + 0xFF, 0x2E, 0x18, 0xF8, 0x02, 0x7E, 0x1B, 0x30, 0x7E, 0x73, 0x12, 0xEF, + 0x7E, 0x07, 0x2C, 0x65, 0x7D, 0x20, 0x5E, 0x24, 0x08, 0x00, 0x68, 0x1F, + 0x5E, 0x04, 0x01, 0x00, 0x68, 0x06, 0x7E, 0x73, 0x12, 0xF0, 0x80, 0x13, + 0x7C, 0xBA, 0x54, 0x02, 0x0A, 0x5B, 0x6D, 0x44, 0x2E, 0x44, 0x00, 0xFF, + 0x2E, 0x28, 0xF8, 0x02, 0x7E, 0x2B, 0x30, 0x30, 0x0F, 0x09, 0x7E, 0x20, + 0x01, 0x20, 0x00, 0x03, 0x4E, 0x30, 0x20, 0x7C, 0xB3, 0x54, 0x02, 0x0A, + 0x0B, 0x4D, 0x00, 0x68, 0x04, 0xE5, 0x5E, 0x80, 0x01, 0xE4, 0xF5, 0x49, + 0x7C, 0xB3, 0x54, 0x04, 0x0A, 0x0B, 0x4D, 0x00, 0x68, 0x04, 0x7C, 0xB7, + 0x80, 0x01, 0xE4, 0xF5, 0x43, 0x7C, 0xB3, 0x54, 0x08, 0x0A, 0x0B, 0x4D, + 0x00, 0x68, 0x06, 0x7E, 0xB3, 0x18, 0xF6, 0x80, 0x01, 0xE4, 0xF5, 0x48, + 0x7C, 0xB3, 0x54, 0x20, 0x0A, 0x3B, 0x4D, 0x33, 0x68, 0x04, 0x7C, 0xB2, + 0x80, 0x01, 0xE4, 0xF5, 0x40, 0x75, 0x41, 0x00, 0xE5, 0x43, 0x0A, 0x3B, + 0x7C, 0x37, 0x7A, 0x31, 0x45, 0xE5, 0x49, 0x0A, 0x4B, 0x0A, 0x53, 0x2D, + 0x54, 0xF5, 0x44, 0x22, 0xCA, 0xF8, 0x7D, 0x41, 0x7D, 0x12, 0x7C, 0xF7, + 0x7C, 0xAB, 0x7E, 0xF7, 0x39, 0x0D, 0x7E, 0xE4, 0x2D, 0x8F, 0x7E, 0x19, + 0x70, 0xBE, 0x70, 0x20, 0x68, 0x04, 0xA5, 0xBF, 0x00, 0x0A, 0x7E, 0xE9, + 0xB0, 0x54, 0x7F, 0x7A, 0xE9, 0xB0, 0x80, 0x2E, 0xBE, 0x70, 0x10, 0x68, + 0x29, 0xBE, 0x70, 0x08, 0x68, 0x24, 0x0B, 0x48, 0x30, 0x0B, 0x08, 0x20, + 0x7D, 0xD3, 0x5E, 0xD4, 0x3F, 0xFF, 0x4E, 0xD4, 0x80, 0x00, 0x1B, 0xE8, + 0xD0, 0x7D, 0xD2, 0x5E, 0xD4, 0x3F, 0xFF, 0x59, 0xDE, 0x00, 0x02, 0x7E, + 0xF9, 0xB0, 0x19, 0xBE, 0x00, 0x04, 0x0B, 0x14, 0x2E, 0xE4, 0x00, 0x07, + 0x0B, 0x45, 0x0B, 0x05, 0x0B, 0xF4, 0x1B, 0xA0, 0x78, 0xAC, 0x6C, 0xAA, + 0x7E, 0x70, 0x01, 0x6C, 0x66, 0x80, 0x13, 0x7E, 0x19, 0xB0, 0x0A, 0x2B, + 0x5E, 0x24, 0x00, 0x13, 0x68, 0x02, 0x4C, 0xA7, 0x3E, 0x70, 0x0B, 0x14, + 0x0B, 0x60, 0xBC, 0xF6, 0x38, 0xE9, 0x7A, 0xA3, 0x2D, 0x8E, 0x7E, 0xB3, + 0x2D, 0x8B, 0x54, 0x8F, 0x7A, 0xB3, 0x2D, 0x8B, 0x7E, 0xE7, 0x39, 0x0F, + 0x7E, 0xE9, 0xB0, 0xC4, 0x54, 0xF0, 0x7C, 0x7B, 0x4E, 0x73, 0x2D, 0x8B, + 0x7A, 0x73, 0x2D, 0x8B, 0xDA, 0xF8, 0x22, 0xCA, 0x3B, 0x7C, 0xF1, 0x7C, + 0xEB, 0x7D, 0xF1, 0x7D, 0x42, 0x7D, 0xE3, 0x0B, 0x48, 0x50, 0xBE, 0x54, + 0x80, 0x00, 0x78, 0x03, 0x02, 0xB0, 0x99, 0x7D, 0x3F, 0x6C, 0xDD, 0x80, + 0x1A, 0x0B, 0x38, 0x10, 0x7E, 0x50, 0x02, 0xAC, 0x5D, 0x2D, 0x2E, 0x1B, + 0x28, 0x10, 0x6D, 0x22, 0x1B, 0x38, 0x20, 0x1A, 0x2F, 0x3E, 0x24, 0x2D, + 0x32, 0x0B, 0xD0, 0xBC, 0xED, 0x38, 0xE2, 0x6C, 0xDD, 0x80, 0x62, 0x0B, + 0x48, 0xD0, 0x0B, 0x45, 0xBE, 0xD4, 0xFF, 0x00, 0x68, 0x55, 0x74, 0x02, + 0xAC, 0xBD, 0x2D, 0x5E, 0x0B, 0x58, 0xC0, 0x7D, 0x5D, 0x1A, 0x5A, 0x7C, + 0xCB, 0x7D, 0x1D, 0x6C, 0x22, 0x7A, 0x33, 0x37, 0x45, 0x7D, 0x3C, 0x1A, + 0x26, 0x1A, 0x24, 0x6D, 0x00, 0x12, 0x8C, 0xBA, 0x2E, 0x18, 0x00, 0x80, + 0x7C, 0x76, 0x7C, 0x65, 0x7D, 0xB3, 0x1A, 0x3F, 0x1A, 0x2C, 0xAD, 0x32, + 0x3E, 0x34, 0x2D, 0x3F, 0xBE, 0xC0, 0x00, 0x48, 0x0C, 0x7D, 0x5C, 0x9D, + 0x5B, 0x0B, 0x38, 0x20, 0x2D, 0x25, 0x1B, 0x38, 0x20, 0x1A, 0x2F, 0x3E, + 0x24, 0x2D, 0x32, 0x0B, 0x38, 0x20, 0x2D, 0x2B, 0x1B, 0x38, 0x20, 0x0B, + 0xD0, 0xBC, 0xED, 0x38, 0x9A, 0xDA, 0x3B, 0x22, 0xCA, 0x3B, 0x7C, 0xD5, + 0x7D, 0x73, 0x7C, 0xCB, 0x7E, 0xB3, 0x04, 0x0F, 0x60, 0x03, 0x02, 0xB1, + 0x41, 0x7E, 0xB3, 0x04, 0x0E, 0x60, 0x07, 0x7D, 0x37, 0x7C, 0xBD, 0x12, + 0xF0, 0xBE, 0x6C, 0xAA, 0x7E, 0xB3, 0x03, 0xBC, 0xBE, 0xB0, 0x0A, 0x28, + 0x11, 0x7E, 0xB3, 0x03, 0xBA, 0x60, 0x13, 0x74, 0x01, 0x7A, 0xB3, 0x37, + 0x45, 0x7E, 0xA0, 0x01, 0x80, 0x08, 0x7E, 0xA0, 0x01, 0xE4, 0x7A, 0xB3, + 0x37, 0x45, 0x4C, 0xAA, 0x68, 0x2D, 0x6C, 0xAA, 0x80, 0x25, 0x7E, 0xB3, + 0x37, 0x45, 0x60, 0x0E, 0x1A, 0x2A, 0x3E, 0x24, 0x2D, 0x27, 0x0B, 0x28, + 0x30, 0x4E, 0x70, 0x01, 0x80, 0x0C, 0x1A, 0x2A, 0x3E, 0x24, 0x2D, 0x27, + 0x0B, 0x28, 0x30, 0x5E, 0x70, 0xFE, 0x1B, 0x28, 0x30, 0x0B, 0xA0, 0xBC, + 0xDA, 0x18, 0xD7, 0x1A, 0x2C, 0x3E, 0x24, 0x2D, 0x27, 0x0B, 0x28, 0x30, + 0x7C, 0xB7, 0x54, 0x01, 0x7A, 0xB3, 0x37, 0x45, 0x5E, 0x70, 0xFE, 0x1B, + 0x28, 0x30, 0x1A, 0x3C, 0x3E, 0x34, 0x2D, 0x37, 0x0B, 0x38, 0x30, 0x3E, + 0x34, 0x1E, 0x34, 0x1E, 0x34, 0x7A, 0x37, 0x03, 0xAE, 0x7E, 0x73, 0x37, + 0x45, 0x7A, 0x73, 0x03, 0xBA, 0xDA, 0x3B, 0x22, 0xCA, 0x3B, 0xE5, 0x52, + 0x20, 0xE2, 0x04, 0xE4, 0x02, 0xB1, 0xE8, 0x7E, 0x74, 0x18, 0xFE, 0xE4, + 0x7A, 0xB3, 0x37, 0x2F, 0x6C, 0xDD, 0x6C, 0xCC, 0x02, 0xB1, 0xDE, 0x74, + 0x04, 0x7C, 0x7C, 0x12, 0xB8, 0xCC, 0x7A, 0x37, 0x37, 0x30, 0xE4, 0x7A, + 0xB3, 0x37, 0x2E, 0x80, 0x30, 0x7E, 0x63, 0x37, 0x2E, 0x7E, 0x70, 0x02, + 0xAC, 0x67, 0x2E, 0x37, 0x37, 0x30, 0x0B, 0x38, 0x20, 0x7E, 0x63, 0x37, + 0x2F, 0x7E, 0x70, 0x02, 0xAC, 0x67, 0x2D, 0x37, 0x1B, 0x38, 0x20, 0x7E, + 0xB3, 0x37, 0x2F, 0x04, 0x7A, 0xB3, 0x37, 0x2F, 0x7E, 0xB3, 0x37, 0x2E, + 0x04, 0x7A, 0xB3, 0x37, 0x2E, 0x7E, 0x73, 0x37, 0x2E, 0xBE, 0x71, 0x5F, + 0x40, 0xC7, 0x12, 0xD6, 0x7D, 0x60, 0x2D, 0x7E, 0x10, 0x02, 0xAC, 0x1D, + 0xE5, 0x46, 0x0A, 0x2B, 0x7E, 0x34, 0x01, 0x80, 0xAD, 0x32, 0x7D, 0x23, + 0x2D, 0x20, 0x2E, 0x24, 0x12, 0xF1, 0x7A, 0x27, 0x37, 0x32, 0x7E, 0x37, + 0x37, 0x30, 0xE5, 0x5F, 0x0A, 0x1B, 0x2E, 0x04, 0x0E, 0x80, 0x12, 0xA6, + 0x24, 0x2E, 0xD1, 0x5F, 0x0B, 0xC0, 0xBE, 0xC1, 0x43, 0x50, 0x03, 0x02, + 0xB1, 0x5F, 0x74, 0x01, 0xDA, 0x3B, 0x22, 0xCA, 0x69, 0xCA, 0xF8, 0x6C, + 0xFF, 0x7E, 0x70, 0x12, 0xAC, 0x7F, 0x3E, 0x34, 0x49, 0x23, 0x04, 0xBC, + 0xBE, 0x24, 0x80, 0x00, 0x68, 0x22, 0x2E, 0x34, 0x05, 0x39, 0x7A, 0x37, + 0x37, 0x45, 0x7E, 0xD0, 0x02, 0xAC, 0xDF, 0x2E, 0x67, 0x03, 0x10, 0x7D, + 0x36, 0x7E, 0x27, 0x37, 0x45, 0x7E, 0xB3, 0x05, 0x1B, 0x7E, 0x33, 0x05, + 0x1A, 0x12, 0xF0, 0x48, 0x0B, 0xF0, 0xBE, 0xF0, 0x02, 0x78, 0xC6, 0x7E, + 0x37, 0x05, 0x04, 0xBE, 0x34, 0x80, 0x00, 0x68, 0x57, 0x7E, 0xF0, 0x08, + 0x7E, 0x73, 0x05, 0x1A, 0xBE, 0x70, 0x08, 0x50, 0x02, 0x7C, 0xF7, 0x7E, + 0x24, 0x05, 0x81, 0x7A, 0x27, 0x37, 0x45, 0x7E, 0xD0, 0x02, 0xAC, 0xD7, + 0x2E, 0x67, 0x03, 0x10, 0x1B, 0x65, 0x7D, 0x36, 0x7E, 0x27, 0x37, 0x45, + 0x7C, 0xBF, 0x7E, 0x30, 0xFF, 0x12, 0xF0, 0x48, 0x7E, 0x34, 0x05, 0x91, + 0x7A, 0x37, 0x37, 0x45, 0x7E, 0x73, 0x05, 0x1B, 0x7E, 0xD3, 0x05, 0x1A, + 0xAC, 0xD7, 0x3E, 0x64, 0x2E, 0x67, 0x03, 0x10, 0x1B, 0x65, 0x7D, 0x36, + 0x7E, 0x27, 0x37, 0x45, 0x7C, 0xBF, 0x7E, 0x30, 0xFF, 0x12, 0xF0, 0x48, + 0xDA, 0xF8, 0xDA, 0x69, 0x22, 0xCA, 0x7B, 0xCA, 0x6B, 0xCA, 0x5B, 0xCA, + 0x4B, 0xCA, 0x3B, 0xCA, 0x2B, 0xCA, 0x1B, 0xCA, 0x0B, 0xC0, 0xD1, 0x75, + 0xD1, 0x18, 0xC0, 0xD0, 0xC0, 0x83, 0xC0, 0x82, 0x12, 0xF5, 0xCF, 0xD0, + 0x82, 0xD0, 0x83, 0xD0, 0xD0, 0xD0, 0xD1, 0xDA, 0x0B, 0xDA, 0x1B, 0xDA, + 0x2B, 0xDA, 0x3B, 0xDA, 0x4B, 0xDA, 0x5B, 0xDA, 0x6B, 0xDA, 0x7B, 0x32, + 0xCA, 0x7B, 0xCA, 0x6B, 0xCA, 0x5B, 0xCA, 0x4B, 0xCA, 0x3B, 0xCA, 0x2B, + 0xCA, 0x1B, 0xCA, 0x0B, 0xC0, 0xD1, 0x75, 0xD1, 0x18, 0xC0, 0xD0, 0xC0, + 0x83, 0xC0, 0x82, 0x12, 0xF5, 0xCD, 0xD0, 0x82, 0xD0, 0x83, 0xD0, 0xD0, + 0xD0, 0xD1, 0xDA, 0x0B, 0xDA, 0x1B, 0xDA, 0x2B, 0xDA, 0x3B, 0xDA, 0x4B, + 0xDA, 0x5B, 0xDA, 0x6B, 0xDA, 0x7B, 0x32, 0xCA, 0x7B, 0xCA, 0x6B, 0xCA, + 0x5B, 0xCA, 0x4B, 0xCA, 0x3B, 0xCA, 0x2B, 0xCA, 0x1B, 0xCA, 0x0B, 0xC0, + 0xD1, 0x75, 0xD1, 0x18, 0xC0, 0xD0, 0xC0, 0x83, 0xC0, 0x82, 0x12, 0xF5, + 0xCE, 0xD0, 0x82, 0xD0, 0x83, 0xD0, 0xD0, 0xD0, 0xD1, 0xDA, 0x0B, 0xDA, + 0x1B, 0xDA, 0x2B, 0xDA, 0x3B, 0xDA, 0x4B, 0xDA, 0x5B, 0xDA, 0x6B, 0xDA, + 0x7B, 0x32, 0x31, 0x41, 0x09, 0x0B, 0xE9, 0x1E, 0x67, 0x09, 0xCC, 0x62, + 0xA7, 0x9C, 0xB5, 0xF4, 0xF4, 0x64, 0x1A, 0xA6, 0x02, 0x91, 0x56, 0xE3, + 0xD0, 0x1A, 0xD1, 0xCE, 0x9D, 0x0C, 0x61, 0xB2, 0x70, 0x62, 0x0D, 0x43, + 0x9B, 0x25, 0x93, 0x12, 0x26, 0xA8, 0xDF, 0x52, 0x6F, 0x48, 0xC7, 0xA0, + 0x05, 0xE7, 0xB9, 0x08, 0x70, 0x15, 0x45, 0x85, 0x0F, 0x9B, 0x19, 0x8F, + 0x26, 0x5A, 0x5D, 0x9F, 0x3A, 0xBD, 0x93, 0xA1, 0x7B, 0x9A, 0x56, 0xBD, + 0xB8, 0xD5, 0x28, 0x89, 0x2F, 0x1F, 0x28, 0xE7, 0xA2, 0x15, 0x61, 0x3C, + 0xA1, 0xA4, 0x88, 0x3B, 0x5F, 0x07, 0xD1, 0xF0, 0x6C, 0x0F, 0xCA, 0xD1, + 0xE8, 0xCE, 0x4E, 0x5E, 0x48, 0x2E, 0x86, 0x43, 0xDD, 0x79, 0x8A, 0xF3, + 0x48, 0x17, 0x19, 0x27, 0xDF, 0x54, 0xF7, 0xB3, 0x60, 0x86, 0x6F, 0xB7, + 0x45, 0x65, 0xFD, 0x8F, 0x3F, 0x60, 0xA5, 0x75, 0x97, 0xE0, 0x7E, 0xDD, + 0x76, 0x28, 0xEC, 0x65, 0xE5, 0xBE, 0x25, 0xDD, 0x73, 0x27, 0x51, 0x5A, + 0xE4, 0xD3, 0x14, 0xC5, 0xC7, 0x05, 0x3D, 0xD1, 0xDF, 0x85, 0xD2, 0xE8, + 0x3E, 0x08, 0x5D, 0xD9, 0x78, 0x83, 0x12, 0xC4, 0xFC, 0xC6, 0xBF, 0x34, + 0x73, 0xF4, 0x39, 0xAE, 0x71, 0x45, 0xA6, 0x9B, 0x38, 0xCF, 0x4B, 0xB5, + 0x38, 0xA7, 0x04, 0x83, 0xDD, 0x40, 0x0B, 0x39, 0x80, 0xE4, 0xB9, 0xED, + 0xE4, 0x1A, 0xE9, 0x19, 0xA7, 0x0D, 0xB6, 0x45, 0x68, 0xFB, 0x53, 0xCA, + 0x0A, 0xB7, 0x98, 0x77, 0xD0, 0x22, 0x9C, 0x21, 0xC6, 0xCC, 0xE0, 0xD8, + 0x1E, 0x1C, 0x7A, 0x59, 0x0A, 0x17, 0x34, 0x5E, 0x3A, 0x43, 0x8F, 0x7B, + 0x6F, 0x2C, 0xAF, 0x28, 0xE2, 0x0B, 0x84, 0x8C, 0x6B, 0x1C, 0xCA, 0x57, + 0x1D, 0x9A, 0x33, 0x10, 0x4F, 0xF7, 0xC7, 0x3B, 0xC0, 0xBB, 0x5F, 0xD1, + 0xD3, 0xA7, 0xB8, 0x41, 0x09, 0x14, 0x86, 0x8E, 0x38, 0x8D, 0x91, 0x47, + 0x3D, 0xB5, 0x34, 0x60, 0x74, 0xF7, 0x4A, 0x2D, 0xE8, 0xF8, 0xEE, 0x01, + 0xF1, 0xEC, 0x8F, 0xBF, 0x21, 0xAB, 0x34, 0x58, 0x5D, 0x36, 0x88, 0xF1, + 0x5C, 0x86, 0x81, 0x5B, 0x84, 0x4B, 0x27, 0xE4, 0xD3, 0x83, 0x6C, 0xC4, + 0xC6, 0x06, 0x0C, 0x3E, 0x81, 0xF2, 0x54, 0x0B, 0x11, 0xA1, 0xF5, 0x53, + 0x20, 0xEC, 0x94, 0x36, 0xE9, 0x16, 0x49, 0x21, 0x45, 0x09, 0x54, 0x03, + 0x19, 0x12, 0xB5, 0x1F, 0xCA, 0x3B, 0x7C, 0xF5, 0x7D, 0x63, 0x7E, 0xB3, + 0x04, 0x0F, 0x60, 0x04, 0xE4, 0x02, 0xB5, 0x1C, 0x7E, 0xB3, 0x03, 0xBA, + 0x70, 0x04, 0xE4, 0x02, 0xB5, 0x1C, 0x7A, 0x43, 0x03, 0xFF, 0x7E, 0x37, + 0x03, 0xAE, 0x4D, 0x33, 0x78, 0x0D, 0x7D, 0x36, 0x7E, 0xB3, 0x05, 0x21, + 0x7E, 0x53, 0x05, 0x22, 0x12, 0xF5, 0x24, 0x7E, 0x73, 0x05, 0x1B, 0x7A, + 0x73, 0x37, 0x45, 0x6C, 0xEE, 0x80, 0x28, 0x7C, 0xBE, 0x7E, 0x08, 0x37, + 0x46, 0x9F, 0x11, 0x12, 0xE9, 0x55, 0x7D, 0x36, 0x7E, 0x27, 0x37, 0x46, + 0x7E, 0xB3, 0x05, 0x1A, 0x7E, 0x33, 0x05, 0x21, 0x7E, 0x07, 0x03, 0xAE, + 0x12, 0xE6, 0x7B, 0x1A, 0x3F, 0x3E, 0x34, 0x2D, 0x63, 0x0B, 0xE0, 0x7E, + 0x73, 0x37, 0x45, 0xBC, 0x7E, 0x18, 0xD0, 0x7E, 0x37, 0x03, 0xAE, 0xBE, + 0x34, 0x75, 0x30, 0x58, 0x06, 0x0B, 0x34, 0x7A, 0x37, 0x03, 0xAE, 0x7E, + 0x73, 0x04, 0x0C, 0x0A, 0x37, 0xBE, 0x37, 0x03, 0xAE, 0x18, 0x13, 0x7E, + 0xB3, 0x04, 0x0B, 0x70, 0x0D, 0x7E, 0x57, 0x03, 0xAE, 0x12, 0xF5, 0xC5, + 0x74, 0x01, 0x7A, 0xB3, 0x04, 0x0B, 0x74, 0x01, 0xDA, 0x3B, 0x22, 0x38, + 0x1F, 0x15, 0x0A, 0x6E, 0xDD, 0xCC, 0xC9, 0x32, 0xE6, 0x24, 0x39, 0x2F, + 0x0C, 0x53, 0x54, 0x40, 0x9B, 0xB2, 0x9E, 0xF4, 0xC2, 0xC9, 0x05, 0x4F, + 0x05, 0xD1, 0x5A, 0xFD, 0xFA, 0xB4, 0x7E, 0xD8, 0x8A, 0x41, 0x44, 0x66, + 0xD9, 0x9F, 0xA6, 0x1E, 0x15, 0xCC, 0xE7, 0xCA, 0x60, 0x98, 0xA6, 0x27, + 0x82, 0xF1, 0x86, 0x2D, 0xA2, 0x03, 0xF6, 0x1C, 0xA7, 0xDB, 0x31, 0xBA, + 0x91, 0xB8, 0x01, 0xE4, 0x60, 0x25, 0xEC, 0x4E, 0x58, 0x78, 0x4B, 0x20, + 0xB7, 0xF9, 0xE7, 0x53, 0xC2, 0xA9, 0x37, 0xE9, 0x95, 0x77, 0xC3, 0xF2, + 0xBD, 0xE7, 0xD2, 0xED, 0x03, 0xE9, 0xE9, 0x89, 0xDB, 0xE8, 0xB3, 0x48, + 0xFB, 0x52, 0xF1, 0xFB, 0xF1, 0xA7, 0xE9, 0xC1, 0x52, 0x42, 0x97, 0x4F, + 0x45, 0xEB, 0xF8, 0x4F, 0xA0, 0xFD, 0x44, 0x15, 0x40, 0x91, 0x6A, 0xE6, + 0xCD, 0x7D, 0x22, 0x29, 0xBD, 0x32, 0x6B, 0x24, 0x9A, 0xAE, 0xC3, 0x3D, + 0xE8, 0x8F, 0x79, 0xBF, 0xCA, 0x8D, 0x5A, 0x36, 0x22, 0x56, 0xA3, 0x50, + 0xD3, 0x14, 0x7C, 0xDA, 0xFA, 0x2E, 0x58, 0x5E, 0x1F, 0x69, 0x7F, 0xCA, + 0x43, 0x19, 0xBF, 0xCA, 0x3B, 0x7F, 0x60, 0x7C, 0xE5, 0x7C, 0xD6, 0x7C, + 0xF7, 0x7C, 0xCB, 0xE4, 0x02, 0xB6, 0x4F, 0x7C, 0x3C, 0xAC, 0x3E, 0x7E, + 0xB3, 0x38, 0x24, 0x0A, 0x0B, 0x2D, 0x10, 0x3E, 0x14, 0x7E, 0x1F, 0x38, + 0x1C, 0x2D, 0x31, 0x0B, 0x1A, 0x30, 0x7E, 0x50, 0x02, 0xAC, 0xB5, 0x7F, + 0x06, 0x2D, 0x15, 0x0B, 0x0A, 0x40, 0x9D, 0x43, 0x7E, 0xB3, 0x38, 0x24, + 0x7E, 0x70, 0x02, 0xAC, 0xB7, 0x7E, 0x7F, 0x38, 0x20, 0x7F, 0x17, 0x2D, + 0x35, 0x0B, 0x1A, 0x30, 0x0A, 0x9F, 0x6D, 0x88, 0x7E, 0x08, 0x01, 0x00, + 0x9F, 0x04, 0x1A, 0x26, 0x1A, 0x24, 0x12, 0x8C, 0xBA, 0x7F, 0x51, 0x7D, + 0x34, 0x1A, 0x28, 0x1A, 0x24, 0x7F, 0x04, 0x12, 0x8C, 0xBA, 0x2F, 0x15, + 0x7C, 0x76, 0x7C, 0x65, 0xBD, 0x43, 0x08, 0x04, 0x0B, 0x34, 0x80, 0x06, + 0xBD, 0x43, 0x58, 0x02, 0x1B, 0x34, 0x7E, 0xB3, 0x38, 0x24, 0x7E, 0x50, + 0x02, 0xAC, 0xB5, 0x7F, 0x07, 0x2D, 0x15, 0x1B, 0x0A, 0x30, 0x7E, 0xB3, + 0x38, 0x24, 0x04, 0x7A, 0xB3, 0x38, 0x24, 0xBE, 0xD3, 0x38, 0x24, 0x28, + 0x03, 0x02, 0xB5, 0xCF, 0xDA, 0x3B, 0x22, 0xCA, 0x3B, 0x7F, 0x30, 0xC2, + 0xAE, 0x12, 0xCF, 0x73, 0x13, 0x92, 0x25, 0x12, 0xF5, 0xC2, 0x72, 0x25, + 0x92, 0x25, 0xA2, 0x01, 0xE4, 0x33, 0x68, 0x0A, 0xB4, 0x01, 0x0F, 0xA2, + 0x0F, 0xE4, 0x33, 0xB4, 0x01, 0x08, 0x12, 0xC4, 0x78, 0x7A, 0x3B, 0xB0, + 0x80, 0x64, 0xE4, 0x7A, 0xB3, 0x37, 0x2F, 0xA2, 0x26, 0xE4, 0x33, 0x78, + 0x25, 0x7E, 0xB3, 0x2C, 0x7B, 0x70, 0x1F, 0x12, 0xF1, 0x31, 0x7A, 0xB3, + 0x37, 0x2F, 0x12, 0xF5, 0xB3, 0x72, 0x25, 0x92, 0x25, 0x7E, 0xB3, 0x37, + 0x2F, 0x60, 0x0B, 0x74, 0xFF, 0x9F, 0x00, 0x12, 0xA7, 0xA5, 0x7A, 0xB3, + 0x2C, 0x7B, 0x7E, 0xA3, 0x37, 0x2F, 0xBE, 0xA0, 0x00, 0x28, 0x0B, 0x7E, + 0xB3, 0x2C, 0x5F, 0x70, 0x05, 0x7E, 0x70, 0x01, 0x80, 0x02, 0x6C, 0x77, + 0xA5, 0xBF, 0x00, 0x07, 0xA2, 0x26, 0xE4, 0x33, 0xB4, 0x01, 0x0F, 0x4C, + 0x77, 0x68, 0x04, 0x7A, 0xA3, 0x12, 0xE5, 0x74, 0x01, 0x7A, 0x3B, 0xB0, + 0x80, 0x04, 0xE4, 0x7A, 0x3B, 0xB0, 0x7E, 0xB3, 0x12, 0xDF, 0xB4, 0x40, + 0x02, 0xC2, 0x25, 0xD2, 0xAE, 0xDA, 0x3B, 0x22, 0x12, 0xEB, 0xA8, 0x7E, + 0xB3, 0x2C, 0x9D, 0x7E, 0x70, 0x02, 0xAC, 0xB7, 0x49, 0x35, 0x2C, 0xA8, + 0x7E, 0xB3, 0x2C, 0x88, 0x7E, 0x50, 0x02, 0xAC, 0xB5, 0x49, 0x45, 0x2C, + 0x9E, 0x2D, 0x43, 0x9E, 0x47, 0x2C, 0x92, 0x7E, 0x57, 0x2D, 0xE1, 0x2E, + 0x54, 0x00, 0x10, 0x7E, 0x59, 0x70, 0x0A, 0x57, 0xBD, 0x54, 0x58, 0x02, + 0x7D, 0x45, 0x6D, 0x33, 0x9D, 0x35, 0xBD, 0x34, 0x08, 0x02, 0x7D, 0x43, + 0x7E, 0xB3, 0x2D, 0x0B, 0x7E, 0x70, 0x02, 0xAC, 0xB7, 0x59, 0x45, 0x2C, + 0xA8, 0x7E, 0xB3, 0x2C, 0x9D, 0x7E, 0x70, 0x02, 0xAC, 0xB7, 0x49, 0x35, + 0x2C, 0xE4, 0x7E, 0xB3, 0x2C, 0x88, 0x7E, 0x50, 0x02, 0xAC, 0xB5, 0x49, + 0x45, 0x2C, 0xDC, 0x2D, 0x43, 0x9E, 0x47, 0x2C, 0xD2, 0x7E, 0x57, 0x2D, + 0xE1, 0x2E, 0x54, 0x00, 0x12, 0x7E, 0x59, 0x70, 0x0A, 0x57, 0xBD, 0x54, + 0x58, 0x02, 0x7D, 0x45, 0x6E, 0x54, 0xFF, 0xFF, 0x0B, 0x54, 0xBD, 0x54, + 0x08, 0x02, 0x7D, 0x45, 0x7E, 0xB3, 0x2D, 0x0B, 0x7E, 0x70, 0x02, 0xAC, + 0xB7, 0x59, 0x45, 0x2C, 0xE4, 0xE4, 0x22, 0x12, 0x92, 0x2B, 0x7C, 0x7B, + 0xE4, 0x7E, 0xA3, 0x04, 0x87, 0xBC, 0xA7, 0x28, 0x02, 0x74, 0x01, 0x7E, + 0xA3, 0x04, 0x01, 0xBE, 0xA0, 0x00, 0x48, 0x0B, 0x60, 0x05, 0x2E, 0xA0, + 0x08, 0x80, 0x0D, 0x6C, 0xAA, 0x80, 0x09, 0x70, 0x04, 0x0B, 0xA2, 0x80, + 0x03, 0x7E, 0xA0, 0x80, 0x7E, 0xB3, 0x03, 0xB7, 0x60, 0x06, 0x7E, 0xB3, + 0x03, 0xB6, 0x70, 0x02, 0x6C, 0xAA, 0x7A, 0xA3, 0x04, 0x01, 0x6C, 0x77, + 0x7E, 0x63, 0x04, 0x86, 0x5E, 0x60, 0x7F, 0xBE, 0xA0, 0x00, 0x58, 0x47, + 0x4C, 0x66, 0x68, 0x43, 0x7E, 0x17, 0x03, 0xC4, 0xBE, 0x14, 0x00, 0x40, + 0x28, 0x04, 0x7E, 0x14, 0x00, 0x40, 0x7E, 0x04, 0x00, 0x40, 0x9D, 0x01, + 0x7D, 0x10, 0x3E, 0x14, 0x3E, 0x14, 0x0A, 0x36, 0xAD, 0x31, 0x7E, 0x24, + 0x01, 0x00, 0x9D, 0x21, 0x2D, 0x32, 0x2E, 0x34, 0x00, 0x80, 0x0A, 0x36, + 0x7E, 0xB3, 0x04, 0x00, 0xBC, 0xB7, 0x28, 0x0F, 0x7E, 0x60, 0x07, 0xAC, + 0xB6, 0x0A, 0x37, 0x2D, 0x35, 0x1E, 0x34, 0x1E, 0x34, 0x1E, 0x34, 0x7A, + 0x73, 0x04, 0x00, 0x02, 0x90, 0x55, 0x30, 0x43, 0x30, 0xE5, 0xDD, 0xC4, + 0x54, 0x0F, 0xBE, 0xB0, 0x02, 0x40, 0x14, 0x7E, 0x71, 0xDE, 0x7C, 0x47, + 0x6C, 0x55, 0xE5, 0xDE, 0x0A, 0x3B, 0x2D, 0x32, 0x7A, 0x35, 0x4A, 0xC2, + 0x43, 0x80, 0x12, 0x80, 0x04, 0xE5, 0xDE, 0xF5, 0x4C, 0xE5, 0xDD, 0xC4, + 0x54, 0x0F, 0xBE, 0xB0, 0x00, 0x38, 0xF2, 0x80, 0x66, 0xE5, 0xDD, 0xC4, + 0x54, 0x0F, 0xBE, 0xB0, 0x00, 0x28, 0x5C, 0x80, 0x50, 0xE5, 0x4E, 0x0A, + 0x3B, 0x2E, 0x35, 0x4A, 0xBE, 0x34, 0x00, 0xF8, 0x78, 0x08, 0xE5, 0xDE, + 0x7A, 0xB3, 0x12, 0xE0, 0x80, 0x39, 0xBE, 0x34, 0x01, 0x10, 0x40, 0x14, + 0xBE, 0x34, 0x01, 0x2F, 0x38, 0x0E, 0xE5, 0xDE, 0x7D, 0x23, 0x9E, 0x24, + 0x01, 0x10, 0x19, 0xB2, 0x2E, 0x33, 0x80, 0x1F, 0xBE, 0x34, 0x01, 0xBC, + 0x38, 0x15, 0xE5, 0xDE, 0x2E, 0x37, 0x12, 0xE9, 0x7A, 0x39, 0xB0, 0xE5, + 0x4E, 0x0A, 0x3B, 0x2E, 0x35, 0x4A, 0x12, 0xEC, 0x29, 0x80, 0x04, 0xE5, + 0xDE, 0xF5, 0x4C, 0x05, 0x4E, 0xE5, 0xDD, 0xC4, 0x54, 0x0F, 0xBE, 0xB0, + 0x00, 0x38, 0xA6, 0x22, 0x7C, 0xA7, 0x6D, 0x33, 0x7D, 0x43, 0xB4, 0x01, + 0x07, 0x7E, 0x34, 0x2C, 0x65, 0x02, 0xB9, 0x64, 0xB4, 0x02, 0x06, 0xE5, + 0x45, 0x0A, 0x4B, 0x80, 0x5F, 0xB4, 0x04, 0x42, 0xE5, 0x54, 0x0A, 0x3B, + 0x5E, 0x34, 0x00, 0x01, 0x68, 0x32, 0x7E, 0xB3, 0x12, 0xF0, 0x1E, 0xB0, + 0xBC, 0xBA, 0x28, 0x12, 0x7E, 0xB3, 0x2C, 0x63, 0x0A, 0x2B, 0x0A, 0x3A, + 0x2D, 0x32, 0x09, 0x73, 0x28, 0x01, 0x0A, 0x47, 0x80, 0x12, 0x9C, 0xAB, + 0x7E, 0xB3, 0x2C, 0x63, 0x0A, 0x2B, 0x0A, 0x3A, 0x2D, 0x32, 0x09, 0x73, + 0x28, 0x0D, 0x0A, 0x47, 0x6C, 0xAA, 0x80, 0x20, 0xE5, 0x41, 0x0A, 0x4B, + 0x80, 0x1A, 0xB4, 0x08, 0x06, 0xE5, 0x44, 0x0A, 0x4B, 0x80, 0x11, 0xB4, + 0x20, 0x0E, 0xE5, 0x59, 0x70, 0x0A, 0xE5, 0x48, 0x0A, 0x3B, 0xE5, 0x44, + 0x0A, 0x4B, 0x2D, 0x43, 0x0A, 0x2A, 0x2D, 0x24, 0xE5, 0x60, 0x0A, 0x3B, + 0xAD, 0x32, 0x30, 0x00, 0x0D, 0xE5, 0x59, 0xB4, 0x02, 0x08, 0x3E, 0x34, + 0x2E, 0x34, 0x03, 0x00, 0x80, 0x06, 0x3E, 0x34, 0x2E, 0x34, 0xD0, 0x00, + 0x22, 0xCA, 0x3B, 0x7C, 0xFB, 0x7D, 0x43, 0x7E, 0x73, 0x04, 0x12, 0x1E, + 0x70, 0x0A, 0xF7, 0x7D, 0xEF, 0x3E, 0xE4, 0x3E, 0xE4, 0x3E, 0xE4, 0x7E, + 0xE3, 0x04, 0x4A, 0x4C, 0xEE, 0x68, 0x77, 0x7E, 0xD0, 0x01, 0x7E, 0x73, + 0x04, 0x49, 0x7C, 0xA7, 0x5E, 0xA0, 0x7F, 0x9C, 0xFA, 0x7C, 0xB7, 0x30, + 0xE7, 0x0D, 0x7E, 0xD0, 0xFF, 0x1A, 0x3F, 0x1B, 0x34, 0x3E, 0x34, 0x2D, + 0x43, 0x80, 0x06, 0x1A, 0x5A, 0x3E, 0x54, 0x2D, 0x45, 0x6D, 0xDD, 0x6C, + 0xCC, 0x80, 0x47, 0x0B, 0x48, 0xC0, 0xBE, 0xC4, 0xF8, 0x81, 0x08, 0x19, + 0x1A, 0xBC, 0xAD, 0xBD, 0x0E, 0xB4, 0x0E, 0xB4, 0xBE, 0xB4, 0x07, 0x7F, + 0x08, 0x04, 0x7E, 0xB4, 0x07, 0x7F, 0x7D, 0x5C, 0x9D, 0x5B, 0x1B, 0x48, + 0x50, 0xBD, 0xFC, 0x58, 0x19, 0xBD, 0xEC, 0x58, 0x02, 0x7D, 0xCE, 0x7D, + 0x3C, 0x1A, 0x26, 0x1A, 0x24, 0x0A, 0x1E, 0x6D, 0x00, 0x12, 0x8C, 0xBA, + 0x7C, 0x76, 0x7C, 0x65, 0x2D, 0xD3, 0x1A, 0x5D, 0x3E, 0x54, 0x2D, 0x45, + 0x0B, 0xC0, 0xBC, 0xFC, 0x18, 0xB5, 0xDA, 0x3B, 0x22, 0x7D, 0x13, 0x74, + 0x84, 0x7A, 0x19, 0xB0, 0x74, 0x02, 0x19, 0xB1, 0x00, 0x02, 0x74, 0x01, + 0x19, 0xB1, 0x00, 0x03, 0xE5, 0x5E, 0x19, 0xB1, 0x00, 0x04, 0xE5, 0x5F, + 0x19, 0xB1, 0x00, 0x05, 0xE5, 0x47, 0x19, 0xB1, 0x00, 0x06, 0x7E, 0x73, + 0x18, 0xF6, 0x0A, 0x37, 0x3E, 0x34, 0x3E, 0x34, 0x3E, 0x34, 0x2E, 0x34, + 0x00, 0x80, 0x19, 0x71, 0x00, 0x07, 0xE5, 0x5F, 0x19, 0xB1, 0x00, 0x08, + 0xE4, 0x19, 0xB1, 0x00, 0x09, 0x7E, 0x73, 0x12, 0xF0, 0xBE, 0x73, 0x12, + 0xEF, 0x50, 0x06, 0x7E, 0x73, 0x12, 0xEF, 0x80, 0x04, 0x7E, 0x73, 0x12, + 0xF0, 0x19, 0x71, 0x00, 0x0A, 0xA2, 0x05, 0xE4, 0x33, 0x0A, 0x3B, 0x3E, + 0x34, 0x3E, 0x34, 0x3E, 0x34, 0x3E, 0x34, 0x19, 0x71, 0x00, 0x0B, 0x7E, + 0x73, 0x12, 0xE1, 0x0A, 0x27, 0x7E, 0x73, 0x12, 0xD8, 0x0A, 0x37, 0x2D, + 0x32, 0x19, 0x71, 0x00, 0x0C, 0x7E, 0x73, 0x18, 0xF7, 0x0A, 0x37, 0x2E, + 0x34, 0x00, 0x88, 0x19, 0x71, 0x00, 0x0D, 0x74, 0x0D, 0x19, 0xB1, 0x00, + 0x01, 0x22, 0x7D, 0x02, 0x7D, 0x13, 0x7E, 0x50, 0x10, 0xAC, 0x5B, 0x2E, + 0x24, 0x07, 0x9F, 0x49, 0x31, 0x00, 0x02, 0x1B, 0x28, 0x30, 0x59, 0x02, + 0x00, 0x02, 0x09, 0x71, 0x00, 0x0A, 0x19, 0x72, 0x00, 0x04, 0x49, 0x31, + 0x00, 0x02, 0x59, 0x32, 0x00, 0x05, 0x7E, 0xB3, 0x05, 0x16, 0x70, 0x1E, + 0x09, 0x71, 0x00, 0x0C, 0x19, 0x72, 0x00, 0x07, 0x09, 0x71, 0x00, 0x0D, + 0x19, 0x72, 0x00, 0x08, 0x09, 0x71, 0x00, 0x0E, 0x19, 0x72, 0x00, 0x09, + 0x09, 0x71, 0x00, 0x0F, 0x80, 0x1C, 0x09, 0x71, 0x00, 0x0E, 0x19, 0x72, + 0x00, 0x07, 0x09, 0x71, 0x00, 0x0F, 0x19, 0x72, 0x00, 0x08, 0x09, 0x71, + 0x00, 0x0C, 0x19, 0x72, 0x00, 0x09, 0x09, 0x71, 0x00, 0x0D, 0x19, 0x72, + 0x00, 0x0A, 0x09, 0x71, 0x00, 0x04, 0x19, 0x72, 0x00, 0x0B, 0x09, 0x71, + 0x00, 0x05, 0x19, 0x72, 0x00, 0x0C, 0x09, 0x71, 0x00, 0x06, 0x19, 0x72, + 0x00, 0x0D, 0x09, 0x71, 0x00, 0x07, 0x19, 0x72, 0x00, 0x0E, 0x09, 0x71, + 0x00, 0x0B, 0x19, 0x72, 0x00, 0x0F, 0x22, 0xCA, 0xF8, 0x7C, 0x7B, 0xBE, + 0x70, 0xFF, 0x68, 0x04, 0x7C, 0xF7, 0x80, 0x06, 0x7E, 0xF1, 0x59, 0x6E, + 0xF0, 0x01, 0x7C, 0xBF, 0x20, 0xE0, 0x2B, 0x7E, 0x37, 0x2B, 0xB1, 0x5E, + 0x60, 0xFD, 0x7A, 0x37, 0x2B, 0xB1, 0x7E, 0x37, 0x2D, 0xE9, 0x0B, 0x35, + 0x0B, 0x38, 0x30, 0x7D, 0x23, 0x0A, 0x24, 0x5E, 0x24, 0x00, 0x03, 0x7E, + 0x37, 0x2B, 0xBB, 0x5E, 0x70, 0xFC, 0x4D, 0x32, 0x7A, 0x37, 0x2B, 0xBB, + 0x80, 0x41, 0x7E, 0x34, 0x2E, 0x53, 0x7E, 0x24, 0x00, 0x00, 0x7E, 0x1B, + 0xB0, 0x44, 0xF0, 0x7A, 0x1B, 0xB0, 0x7E, 0x37, 0x2B, 0xB1, 0x4E, 0x60, + 0x02, 0x7A, 0x37, 0x2B, 0xB1, 0x7E, 0x37, 0x2D, 0xE9, 0x0B, 0x35, 0x0B, + 0x38, 0x50, 0x0A, 0x5A, 0xC4, 0x7D, 0x25, 0x5E, 0x24, 0x00, 0x03, 0x7E, + 0x37, 0x2B, 0xBB, 0x5E, 0x70, 0xFC, 0x4D, 0x32, 0x7A, 0x37, 0x2B, 0xBB, + 0x7E, 0xB3, 0x2D, 0x0D, 0x12, 0xE3, 0xBC, 0x7C, 0xBF, 0x7E, 0x73, 0x2D, + 0x0D, 0x7E, 0x63, 0x2D, 0x0E, 0x12, 0xD9, 0xD5, 0xDA, 0xF8, 0x22, 0xCA, + 0xF8, 0x7C, 0xFB, 0xE4, 0x7A, 0xB3, 0x03, 0xC2, 0x6D, 0x33, 0x7A, 0x37, + 0x03, 0xD5, 0x7A, 0x37, 0x03, 0xD7, 0x7A, 0x37, 0x03, 0xD3, 0x7A, 0x37, + 0x03, 0xD9, 0x7A, 0x37, 0x03, 0xDB, 0x7A, 0xB3, 0x03, 0xC3, 0x7A, 0x37, + 0x03, 0xB2, 0x7A, 0x37, 0x03, 0xB4, 0x74, 0xC8, 0x7A, 0xB3, 0x03, 0xBC, + 0x74, 0x01, 0x7A, 0xB3, 0x03, 0xBA, 0xE4, 0x7A, 0xB3, 0x03, 0xB9, 0x7A, + 0x37, 0x03, 0xE3, 0x7E, 0x34, 0x00, 0x06, 0x7A, 0x37, 0x03, 0xC4, 0x7A, + 0xB3, 0x03, 0xE5, 0x7A, 0xB3, 0x03, 0xE8, 0x7E, 0x37, 0x03, 0x10, 0x7E, + 0x24, 0x04, 0x80, 0x12, 0xF2, 0xA4, 0x7E, 0x34, 0x03, 0x12, 0x7E, 0x24, + 0x00, 0x20, 0x12, 0xF2, 0xA4, 0x7E, 0x34, 0x03, 0x32, 0x7E, 0x24, 0x00, + 0x20, 0x12, 0xF2, 0xA4, 0x4C, 0xFF, 0x68, 0x1C, 0x6D, 0x33, 0x7A, 0x37, + 0x03, 0xAE, 0xE4, 0x7A, 0xB3, 0x04, 0x0B, 0x74, 0x01, 0x7A, 0xB3, 0x04, + 0x0E, 0x7E, 0x37, 0x03, 0x0E, 0x7E, 0x24, 0x04, 0x80, 0x12, 0xF2, 0xA4, + 0xDA, 0xF8, 0x22, 0xCA, 0x3B, 0x7C, 0xFB, 0x7E, 0xE3, 0x3B, 0x80, 0x7E, + 0x37, 0x3B, 0x82, 0x7A, 0x37, 0x37, 0x30, 0x7E, 0x67, 0x3B, 0x84, 0x74, + 0x17, 0x12, 0xD5, 0x11, 0xE4, 0x33, 0x78, 0x04, 0x74, 0x3F, 0x80, 0x70, + 0xBE, 0xE0, 0x02, 0x40, 0x04, 0x74, 0x31, 0x80, 0x67, 0x4C, 0xEE, 0x78, + 0x03, 0xE4, 0x80, 0x60, 0x4C, 0xFF, 0x78, 0x15, 0x6D, 0x33, 0x7A, 0x37, + 0x3B, 0x7B, 0x7E, 0x37, 0x37, 0x30, 0x7A, 0x37, 0x3B, 0x6F, 0x7A, 0x67, + 0x3B, 0x71, 0x7E, 0xF0, 0x11, 0xBE, 0xF0, 0x11, 0x68, 0x05, 0xBE, 0xF0, + 0x20, 0x78, 0x3B, 0x7E, 0x37, 0x37, 0x30, 0x7D, 0x26, 0x7E, 0x17, 0x3B, + 0x6F, 0x7E, 0x07, 0x3B, 0x71, 0x12, 0xF2, 0xCE, 0xBE, 0x37, 0x3B, 0x6B, + 0x40, 0x04, 0x74, 0x33, 0x80, 0x22, 0x7E, 0x37, 0x3B, 0x6D, 0xBE, 0x37, + 0x3B, 0x7B, 0x28, 0x0C, 0x7E, 0x37, 0x3B, 0x7B, 0x0B, 0x34, 0x7A, 0x37, + 0x3B, 0x7B, 0x80, 0x0A, 0x74, 0x17, 0x7A, 0xB3, 0x3B, 0x7D, 0x74, 0x20, + 0x80, 0x02, 0x7C, 0xBF, 0xDA, 0x3B, 0x22, 0x68, 0xD6, 0x69, 0x2C, 0xEB, + 0xE1, 0xC8, 0x3F, 0x88, 0x56, 0x22, 0x40, 0xB3, 0x3A, 0xF5, 0x45, 0x36, + 0xD3, 0xC7, 0xF4, 0xB5, 0xA2, 0x09, 0xED, 0xD2, 0x90, 0xD7, 0x80, 0x49, + 0xA3, 0xB3, 0x35, 0xAE, 0xD2, 0x56, 0x4E, 0x36, 0x48, 0xB5, 0xC2, 0x20, + 0x25, 0x8A, 0x55, 0x30, 0xA6, 0xB8, 0xCF, 0x62, 0x2A, 0x06, 0x81, 0x23, + 0xFD, 0x82, 0x8E, 0xCF, 0x7C, 0x7B, 0x25, 0x4D, 0x5A, 0xF3, 0xAC, 0x62, + 0xA5, 0xE7, 0x03, 0x33, 0xD8, 0x5E, 0x5F, 0x0C, 0x9A, 0x8E, 0x64, 0xD3, + 0x68, 0x9E, 0x83, 0xD5, 0x56, 0x3B, 0x3E, 0x3A, 0x2B, 0x8F, 0x4E, 0x5A, + 0x73, 0xDE, 0x69, 0x57, 0xDC, 0x4A, 0x85, 0x06, 0x65, 0x78, 0xE6, 0x2F, + 0x4E, 0x38, 0xD3, 0x2C, 0xB8, 0x4B, 0xB8, 0xD7, 0xF2, 0x71, 0x23, 0x6E, + 0x62, 0xE8, 0xC8, 0xC2, 0xF6, 0xEE, 0x11, 0xED, 0x29, 0x09, 0xDA, 0xD8, + 0xEB, 0x0A, 0xE3, 0xCF, 0x11, 0xB1, 0x18, 0xEA, 0x83, 0x4C, 0xA4, 0x94, + 0x63, 0x30, 0x24, 0xEA, 0xD9, 0x11, 0xB3, 0x12, 0xAA, 0x80, 0x28, 0xE3, + 0x6A, 0x8F, 0x77, 0xF7, 0xD9, 0x1D, 0x8B, 0xF8, 0x21, 0x53, 0x16, 0xF8, + 0xE3, 0x6F, 0x91, 0x23, 0x05, 0x61, 0x33, 0x81, 0xA2, 0x53, 0x23, 0x65, + 0xAE, 0xF9, 0x61, 0xC6, 0x20, 0x19, 0x78, 0x36, 0xF3, 0x7D, 0x6F, 0x21, + 0x19, 0x55, 0x86, 0x9F, 0x7C, 0x9D, 0x41, 0x72, 0xB6, 0x20, 0x44, 0x72, + 0xAE, 0x26, 0x7F, 0x21, 0x21, 0x65, 0xC1, 0x86, 0xE4, 0xD0, 0x13, 0x24, + 0xDF, 0x42, 0x8B, 0x91, 0xF8, 0x31, 0x71, 0x1F, 0x0B, 0xF1, 0x5D, 0x85, + 0x98, 0x26, 0x36, 0x08, 0x4A, 0x52, 0x2A, 0x06, 0x73, 0x60, 0x95, 0xE6, + 0x29, 0xE7, 0xEC, 0x67, 0xAD, 0x7E, 0x15, 0x1C, 0xB1, 0x87, 0x4F, 0xC5, + 0x2D, 0xAC, 0x18, 0xBE, 0xE0, 0x7C, 0x1F, 0x24, 0x2F, 0xDD, 0x3D, 0x81, + 0xE6, 0x4C, 0x8D, 0x1E, 0xB2, 0x94, 0x89, 0xB4, 0x37, 0x82, 0x4C, 0x31, + 0x2E, 0x36, 0xE7, 0xC9, 0x67, 0x11, 0xE9, 0x04, 0x9A, 0xF2, 0x73, 0x73, + 0xE3, 0x3C, 0x0B, 0xD3, 0x4E, 0x3C, 0x12, 0x4A, 0x69, 0x1A, 0x12, 0x8D, + 0x80, 0x87, 0x78, 0xEA, 0x49, 0xAD, 0x5D, 0x65, 0x45, 0xCD, 0xB7, 0x27, + 0x6E, 0x56, 0x43, 0xBE, 0x24, 0xB2, 0x31, 0x59, 0xD9, 0xFA, 0x4A, 0x39, + 0xAB, 0xDC, 0x2E, 0xC6, 0x4B, 0xBA, 0x8B, 0xB6, 0xA0, 0x1A, 0xE4, 0x87, + 0x56, 0x45, 0xB8, 0x62, 0x4A, 0xCB, 0x16, 0x1F, 0x19, 0x38, 0x85, 0xEC, + 0xAA, 0xB0, 0xBF, 0xE8, 0x85, 0xCE, 0x23, 0x9F, 0xCD, 0x75, 0x62, 0x4A, + 0x31, 0x5B, 0x4E, 0x39, 0xA7, 0x9C, 0xD0, 0x40, 0xC3, 0x13, 0xE1, 0xA0, + 0x87, 0xAF, 0x94, 0xB5, 0xEA, 0xAD, 0x09, 0x67, 0x90, 0x47, 0xDF, 0xAC, + 0x5A, 0xD0, 0x75, 0x96, 0xCA, 0x5C, 0x8D, 0x36, 0x6D, 0xCA, 0x2B, 0xD0, + 0xC0, 0x6E, 0xB8, 0x3A, 0xC5, 0xA1, 0xD8, 0xC3, 0x32, 0xF7, 0x5B, 0x13, + 0x03, 0x6C, 0xC8, 0x65, 0xCB, 0xB1, 0x01, 0xF2, 0x0D, 0x05, 0xD1, 0x8B, + 0x79, 0x2A, 0x0B, 0x9D, 0xE3, 0x7C, 0xEA, 0x41, 0x45, 0x26, 0x01, 0xEE, + 0x0F, 0x70, 0xBF, 0x81, 0xC5, 0xD6, 0xF5, 0x37, 0x0B, 0x22, 0x5E, 0x35, + 0x18, 0x12, 0xAB, 0x33, 0x7D, 0x40, 0x7D, 0xF1, 0x7D, 0x02, 0x7D, 0x13, + 0x7E, 0x57, 0x37, 0x34, 0x7A, 0x57, 0x3B, 0x8B, 0x09, 0x71, 0x00, 0x02, + 0x7A, 0x73, 0x39, 0x2C, 0x09, 0xB1, 0x00, 0x03, 0x54, 0x0F, 0x7A, 0xB3, + 0x39, 0x2D, 0x7E, 0x24, 0x00, 0x06, 0x7D, 0x30, 0x8D, 0x32, 0x7A, 0x73, + 0x39, 0x2E, 0x3E, 0x70, 0x3E, 0x70, 0x7A, 0x73, 0x39, 0x2F, 0xE4, 0x7A, + 0xB3, 0x39, 0x2B, 0x09, 0xB1, 0x00, 0x01, 0x54, 0x8F, 0x7A, 0xB3, 0x3B, + 0x4F, 0x7E, 0x57, 0x37, 0x32, 0x7A, 0x57, 0x3B, 0x50, 0x1E, 0x04, 0x7A, + 0x07, 0x3B, 0x52, 0xE4, 0x7A, 0xB3, 0x3B, 0x54, 0xE4, 0x7A, 0xB3, 0x3B, + 0x55, 0xE4, 0x7A, 0xB3, 0x3B, 0x5F, 0x7E, 0x19, 0xB0, 0x54, 0x07, 0x7A, + 0xB3, 0x3B, 0x6A, 0x7A, 0x47, 0x3B, 0x6B, 0x7A, 0xF7, 0x3B, 0x6D, 0xE4, + 0x7A, 0xB3, 0x3B, 0x77, 0xE4, 0x7A, 0xB3, 0x3B, 0x7A, 0xE4, 0x7A, 0xB3, + 0x3B, 0x7D, 0xE4, 0x7A, 0xB3, 0x3B, 0x7E, 0xE4, 0x7A, 0xB3, 0x3B, 0x7F, + 0x12, 0xF3, 0x93, 0x22, 0x7E, 0x34, 0x00, 0x20, 0x7E, 0x24, 0x00, 0x04, + 0x12, 0xF2, 0x4B, 0x75, 0x53, 0x00, 0x75, 0x62, 0x00, 0x75, 0x42, 0x00, + 0xC2, 0x00, 0x74, 0x01, 0x7A, 0xB3, 0x12, 0xE2, 0xE4, 0x7A, 0xB3, 0x2C, + 0x5E, 0xE4, 0x7A, 0xB3, 0x18, 0xF1, 0xE4, 0x7A, 0xB3, 0x28, 0x1D, 0xE4, + 0x7A, 0xB3, 0x28, 0x00, 0x12, 0xEA, 0xF5, 0x12, 0xF4, 0x1B, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x53, 0xEE, 0xCF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA9, + 0xD0, 0xEE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xE0, 0xC1, 0xE4, 0x7A, + 0xB3, 0x2C, 0x3F, 0x12, 0xF5, 0x39, 0xE5, 0x8F, 0xBE, 0xB0, 0x83, 0x68, + 0x0C, 0x74, 0x30, 0x7A, 0xB3, 0x2C, 0x5E, 0x74, 0x10, 0x7A, 0xB3, 0x18, + 0xF1, 0xE5, 0xE1, 0xBE, 0xB0, 0x43, 0x40, 0x0C, 0xE5, 0xE1, 0xBE, 0xB0, + 0xFF, 0x68, 0x05, 0xE5, 0xE1, 0xB4, 0x30, 0x0C, 0x74, 0x30, 0x7A, 0xB3, + 0x2C, 0x5E, 0x74, 0x10, 0x7A, 0xB3, 0x18, 0xF1, 0x12, 0xF5, 0xCC, 0x22, + 0xCA, 0xF8, 0x7E, 0x37, 0x39, 0x31, 0x7A, 0x37, 0x37, 0x3C, 0x7E, 0x37, + 0x39, 0x33, 0x7A, 0x37, 0x37, 0x3E, 0x74, 0x01, 0x7E, 0x24, 0x00, 0x01, + 0x7D, 0x32, 0x7E, 0x17, 0x39, 0x35, 0x7E, 0x07, 0x39, 0x37, 0x12, 0xA8, + 0x5E, 0x7A, 0xB3, 0x3A, 0x46, 0x6C, 0xFF, 0xBE, 0xF0, 0x03, 0x78, 0x0C, + 0x7E, 0x37, 0x3A, 0x15, 0xBE, 0x34, 0x00, 0x0C, 0x38, 0x47, 0x80, 0x0A, + 0x7E, 0x37, 0x3A, 0x47, 0xBE, 0x37, 0x3A, 0x19, 0x38, 0x3B, 0xBE, 0xF0, + 0x01, 0x78, 0x15, 0x7C, 0xBF, 0x12, 0xF3, 0xB8, 0x7C, 0x7B, 0x7E, 0xB3, + 0x3A, 0x46, 0x12, 0xE5, 0x97, 0xBE, 0xB0, 0x02, 0x38, 0x23, 0x80, 0x13, + 0x7C, 0xBF, 0x12, 0xF3, 0xB8, 0x7C, 0x7B, 0x7E, 0xB3, 0x3A, 0x46, 0x12, + 0xE5, 0x97, 0xBE, 0xB0, 0x01, 0x38, 0x0E, 0x0A, 0x3F, 0x2E, 0x34, 0x3A, + 0x49, 0x7E, 0x39, 0xB0, 0x44, 0x01, 0x7A, 0x39, 0xB0, 0x0B, 0xF0, 0xBE, + 0xF0, 0x11, 0x40, 0xA3, 0xDA, 0xF8, 0x22, 0xCA, 0xF8, 0x7E, 0xF3, 0x28, + 0x1D, 0x7C, 0xBF, 0x30, 0xE3, 0x66, 0x30, 0x0F, 0x14, 0x7E, 0x37, 0x12, + 0xE9, 0x09, 0xB3, 0x00, 0xF1, 0x30, 0xE7, 0x09, 0xA2, 0x08, 0x92, 0x16, + 0x12, 0xE2, 0xC6, 0x80, 0x41, 0x7E, 0x37, 0x12, 0xE9, 0x09, 0xB3, 0x00, + 0xF1, 0x30, 0xE7, 0x1A, 0xA2, 0x08, 0x30, 0x01, 0x01, 0xB3, 0x50, 0x2E, + 0xA2, 0x01, 0x92, 0x02, 0xA2, 0x08, 0x92, 0x01, 0x7C, 0xBF, 0x44, 0x01, + 0x7A, 0xB3, 0x28, 0x1D, 0x80, 0x1C, 0xA2, 0x08, 0x30, 0x06, 0x01, 0xB3, + 0x50, 0x14, 0xA2, 0x08, 0x92, 0x06, 0xA2, 0x07, 0x30, 0x06, 0x01, 0xB3, + 0x50, 0x08, 0x7C, 0xBF, 0x44, 0x04, 0x7A, 0xB3, 0x28, 0x1D, 0xA2, 0x08, + 0x92, 0x09, 0x7E, 0xB3, 0x28, 0x1D, 0x54, 0xF7, 0x7A, 0xB3, 0x28, 0x1D, + 0x7E, 0x37, 0x12, 0xE9, 0x09, 0xB3, 0x00, 0x02, 0xC4, 0x03, 0x13, 0x92, + 0x15, 0xE4, 0x33, 0x12, 0xD2, 0xE0, 0x12, 0xEA, 0xC8, 0xDA, 0xF8, 0x22, + 0x7C, 0xA7, 0x7A, 0xB3, 0x3B, 0x80, 0x7E, 0x09, 0xB0, 0xBE, 0xB0, 0x00, + 0x28, 0x04, 0x74, 0x01, 0x80, 0x01, 0xE4, 0x7A, 0xB3, 0x3B, 0x81, 0x0B, + 0x28, 0x30, 0x7A, 0x37, 0x3B, 0x82, 0x0B, 0x18, 0x30, 0x7A, 0x37, 0x3B, + 0x84, 0x09, 0xB0, 0x00, 0x01, 0xBE, 0xB0, 0x00, 0x28, 0x04, 0x74, 0x01, + 0x80, 0x01, 0xE4, 0x7A, 0xB3, 0x3B, 0x86, 0x49, 0x02, 0x00, 0x02, 0x7A, + 0x07, 0x3B, 0x87, 0x49, 0x31, 0x00, 0x02, 0x7A, 0x37, 0x3B, 0x89, 0xE4, + 0x7A, 0xB3, 0x3B, 0x7D, 0xE4, 0x7A, 0xB3, 0x3B, 0x7E, 0x4C, 0xAA, 0x68, + 0x06, 0x74, 0xFF, 0x7A, 0xB3, 0x3B, 0x80, 0x12, 0xA6, 0xE5, 0x12, 0xA2, + 0x3D, 0x12, 0xF0, 0xF8, 0x7E, 0xB3, 0x3B, 0x7F, 0x70, 0x0F, 0x7E, 0x73, + 0x3B, 0x80, 0xBE, 0x70, 0x00, 0x28, 0x06, 0x74, 0x01, 0x7A, 0xB3, 0x3B, + 0x7E, 0x7E, 0x73, 0x3B, 0x80, 0x7A, 0x73, 0x3B, 0x7F, 0x12, 0xEB, 0x4F, + 0x7E, 0xB3, 0x3B, 0x7D, 0x22, 0x53, 0xE8, 0xFC, 0x7E, 0x37, 0xF3, 0x04, + 0x4E, 0x70, 0x01, 0x7A, 0x37, 0xF3, 0x04, 0x75, 0xF7, 0x03, 0x75, 0xF8, + 0x03, 0x6D, 0x33, 0x7A, 0x37, 0xFF, 0xE0, 0x7E, 0x34, 0x00, 0x02, 0x7A, + 0x37, 0xFF, 0xEE, 0x7E, 0x34, 0x90, 0x00, 0x7A, 0x37, 0xFF, 0xE4, 0x7E, + 0x24, 0x92, 0x0C, 0x7A, 0x27, 0xFF, 0xE6, 0x7A, 0x37, 0xFF, 0xE2, 0x7A, + 0x37, 0xFF, 0xEA, 0x7A, 0x27, 0xFF, 0xEC, 0x7A, 0x37, 0xFF, 0xE8, 0x43, + 0xE8, 0x03, 0x7E, 0x34, 0x00, 0x23, 0x7A, 0x37, 0xFF, 0xF0, 0x7E, 0x34, + 0x90, 0x00, 0x7A, 0x37, 0x27, 0xFE, 0x7E, 0x34, 0x90, 0x10, 0x7A, 0x37, + 0xFF, 0xD6, 0x7E, 0x34, 0x00, 0xCB, 0x7A, 0x37, 0xFF, 0xDA, 0x43, 0x62, + 0x01, 0x7E, 0x34, 0x80, 0x00, 0x7A, 0x37, 0xFF, 0xF4, 0x7A, 0x37, 0xFF, + 0xF6, 0x7E, 0x34, 0x7F, 0xFF, 0x7A, 0x37, 0xFF, 0xF8, 0x7E, 0x37, 0xFF, + 0xEE, 0x4E, 0x60, 0x87, 0x7A, 0x37, 0xFF, 0xEE, 0x22, 0xCA, 0xF8, 0x53, + 0xA8, 0x7F, 0x00, 0x00, 0x7E, 0x73, 0x28, 0x1D, 0x0A, 0x37, 0x5E, 0x34, + 0xFF, 0xFB, 0x78, 0x6E, 0x7E, 0x37, 0x12, 0xE9, 0x09, 0xB3, 0x00, 0xF8, + 0xBE, 0xB0, 0x01, 0x68, 0x61, 0x20, 0x29, 0x5E, 0x7E, 0xB3, 0x12, 0xE0, + 0xBE, 0xB0, 0x01, 0x68, 0x55, 0x20, 0x45, 0x52, 0xA2, 0x06, 0xE4, 0x33, + 0x7C, 0xFB, 0xBE, 0xF0, 0x01, 0x78, 0x05, 0x12, 0xEC, 0xA4, 0x80, 0x42, + 0x4C, 0xFF, 0x78, 0x0C, 0xA2, 0x07, 0xE4, 0x33, 0xB4, 0x01, 0x05, 0x12, + 0xEF, 0xAB, 0x80, 0x35, 0xA2, 0x22, 0xE4, 0x33, 0x78, 0x2C, 0xA2, 0x23, + 0xE4, 0x33, 0x78, 0x26, 0x7E, 0xB3, 0x28, 0x00, 0xB4, 0x02, 0x0E, 0x43, + 0xA8, 0x80, 0xA9, 0xD1, 0x87, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, + 0x14, 0xB4, 0x01, 0x0E, 0x43, 0xA8, 0x80, 0xA9, 0xD0, 0x87, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x80, 0x03, 0x43, 0xA8, 0x80, 0xDA, 0xF8, 0x22, + 0xCA, 0x3B, 0x7C, 0xDB, 0x7A, 0x17, 0x37, 0x57, 0x7A, 0x27, 0x37, 0x55, + 0x7D, 0x73, 0x7E, 0xB3, 0x04, 0x10, 0x20, 0xE7, 0x07, 0x7E, 0xB3, 0x05, + 0x25, 0x30, 0xE7, 0x28, 0x7E, 0xB3, 0x05, 0x25, 0x30, 0xE7, 0x06, 0x7E, + 0xC3, 0x05, 0x26, 0x80, 0x04, 0x7E, 0xC3, 0x04, 0x6E, 0x7D, 0x37, 0x7E, + 0x27, 0x37, 0x55, 0x7E, 0x17, 0x05, 0x14, 0x7C, 0xBD, 0x7C, 0x1C, 0x12, + 0x91, 0x43, 0x60, 0x04, 0x7E, 0x77, 0x05, 0x14, 0x7E, 0x37, 0x37, 0x55, + 0x7A, 0x37, 0xFF, 0x02, 0x7E, 0x24, 0xFF, 0xFE, 0x7A, 0x27, 0xFF, 0x06, + 0x7E, 0x37, 0x37, 0x57, 0x4D, 0x33, 0x78, 0x06, 0x7A, 0x27, 0xFF, 0x08, + 0x80, 0x04, 0x7A, 0x37, 0xFF, 0x08, 0x7E, 0x63, 0x05, 0x21, 0x7E, 0x70, + 0x01, 0x7A, 0x37, 0xFF, 0x0A, 0x7E, 0x34, 0x10, 0x01, 0x7A, 0x37, 0xFF, + 0x0C, 0x1A, 0x3D, 0x7A, 0x37, 0xFF, 0x0E, 0x7A, 0x77, 0xFF, 0x04, 0xDA, + 0x3B, 0x22, 0xCA, 0xF8, 0x12, 0xF5, 0x91, 0x7C, 0xFB, 0x7E, 0xB3, 0x2C, + 0x8B, 0xB4, 0x01, 0x2C, 0x4C, 0xFF, 0x78, 0x28, 0x12, 0xEB, 0x22, 0x7E, + 0xA3, 0x2C, 0x90, 0xBE, 0xA0, 0xFF, 0x68, 0x1C, 0x74, 0xFF, 0x0A, 0x3A, + 0x19, 0xB3, 0x2C, 0xC4, 0x74, 0xFF, 0x7A, 0xB3, 0x2C, 0x90, 0x74, 0xFF, + 0x12, 0xC6, 0x85, 0xB4, 0xFF, 0x06, 0x74, 0x03, 0x7A, 0xB3, 0x2C, 0x8B, + 0xBE, 0xF3, 0x2D, 0x11, 0x68, 0x0A, 0x7A, 0xF3, 0x2D, 0x11, 0x74, 0x01, + 0x7A, 0xB3, 0x2D, 0x12, 0x4C, 0xFF, 0x68, 0x24, 0x74, 0x20, 0x7A, 0xB3, + 0x2D, 0x10, 0x7E, 0x37, 0x2D, 0xE1, 0x7E, 0x39, 0xB0, 0x30, 0xE2, 0x0C, + 0x7E, 0xB3, 0x2D, 0x6C, 0x44, 0x80, 0x7A, 0xB3, 0x2D, 0x6C, 0x80, 0x18, + 0x74, 0x80, 0x7A, 0xB3, 0x2D, 0x6C, 0x80, 0x10, 0x7E, 0xB3, 0x2D, 0x10, + 0x60, 0x05, 0x14, 0x7A, 0xB3, 0x2D, 0x10, 0xE4, 0x7A, 0xB3, 0x2D, 0x6C, + 0xDA, 0xF8, 0x22, 0xCA, 0x3B, 0x7C, 0xE6, 0x7C, 0xF7, 0x7C, 0xDB, 0x80, + 0x74, 0x0A, 0x3F, 0x6D, 0x22, 0x2F, 0x11, 0x7F, 0x01, 0x2E, 0x04, 0x00, + 0xFF, 0x2E, 0x08, 0xF7, 0x88, 0x7E, 0x0B, 0x30, 0x7A, 0x33, 0x37, 0x37, + 0x4C, 0xDD, 0x68, 0x0F, 0x7E, 0x33, 0x37, 0x37, 0x0A, 0x13, 0x2E, 0x17, + 0x2D, 0xDB, 0x7E, 0x19, 0xC0, 0x80, 0x3F, 0x2E, 0x24, 0x00, 0xFF, 0x2E, + 0x18, 0xF7, 0x89, 0x7E, 0x1B, 0x70, 0x7A, 0x73, 0x37, 0x38, 0x7E, 0xB3, + 0x37, 0x37, 0x12, 0xF5, 0x79, 0x7C, 0xCB, 0x0A, 0x3F, 0x2E, 0x37, 0x2D, + 0xDD, 0x7E, 0x39, 0x70, 0x7A, 0x73, 0x37, 0x36, 0x7E, 0x73, 0x37, 0x38, + 0x5E, 0x73, 0x37, 0x36, 0x7A, 0x73, 0x37, 0x36, 0x7E, 0xB3, 0x37, 0x38, + 0x64, 0xFF, 0x5C, 0xCB, 0x7E, 0x73, 0x37, 0x36, 0x4C, 0xC7, 0x7E, 0xB3, + 0x37, 0x37, 0x7C, 0x7C, 0x12, 0xF5, 0x80, 0x0B, 0xF0, 0xBC, 0xEF, 0x38, + 0x88, 0xDA, 0x3B, 0x22, 0xCA, 0xF8, 0x7E, 0xB3, 0x28, 0x1D, 0x60, 0x03, + 0xE4, 0x80, 0x76, 0x7E, 0xA3, 0x28, 0x22, 0xBE, 0xA0, 0x02, 0x78, 0x09, + 0xE4, 0x7A, 0xB3, 0x28, 0x22, 0x74, 0x01, 0x80, 0x64, 0x4C, 0xAA, 0x78, + 0x08, 0x74, 0x01, 0x7A, 0xB3, 0x28, 0x22, 0x80, 0x0D, 0xBE, 0xA0, 0x03, + 0x78, 0x08, 0xD2, 0x28, 0x74, 0x01, 0x7A, 0xB3, 0x28, 0x22, 0x6C, 0xFF, + 0x80, 0x2A, 0x7E, 0xB3, 0x28, 0x22, 0xB4, 0x01, 0x2A, 0x7E, 0x71, 0x5D, + 0x74, 0x7D, 0xAC, 0x7B, 0x2E, 0x34, 0x28, 0x24, 0x12, 0x5E, 0xD9, 0x05, + 0x5D, 0xE5, 0x5D, 0xBE, 0xB0, 0x04, 0x40, 0x03, 0x75, 0x5D, 0x00, 0x05, + 0x4F, 0xBE, 0xF0, 0x03, 0x68, 0x09, 0x0B, 0xF0, 0xE5, 0x4F, 0xBE, 0xB0, + 0x04, 0x40, 0xCF, 0xE5, 0x4F, 0xBE, 0xB0, 0x00, 0x28, 0x0E, 0xA2, 0x28, + 0xE4, 0x33, 0xB4, 0x01, 0x07, 0xC2, 0x28, 0x74, 0x01, 0x12, 0xF0, 0x84, + 0xE4, 0xDA, 0xF8, 0x22, 0xCA, 0x79, 0x12, 0xF3, 0x5A, 0x60, 0x75, 0x7E, + 0xF1, 0x47, 0x7E, 0x37, 0x2D, 0xD9, 0x2E, 0x34, 0x00, 0x07, 0x7E, 0x39, + 0xE0, 0x0A, 0x3E, 0x2E, 0x34, 0x0D, 0xF7, 0x6D, 0x22, 0x6C, 0xAA, 0x80, + 0x12, 0x6C, 0x33, 0xBE, 0xA3, 0x0D, 0xBB, 0x78, 0x03, 0x7E, 0x30, 0x01, + 0x7A, 0x1B, 0x30, 0x0B, 0x34, 0x0B, 0xA0, 0xBC, 0xFA, 0x38, 0xEA, 0x7E, + 0x34, 0x0D, 0xF7, 0x7C, 0xBF, 0x2C, 0xBE, 0x12, 0xD8, 0x31, 0x7E, 0x34, + 0x0D, 0xEB, 0x7A, 0x37, 0x39, 0x0D, 0x7E, 0x34, 0x0E, 0x32, 0x7A, 0x37, + 0x39, 0x0F, 0x7C, 0xBE, 0x7C, 0x7F, 0x7E, 0x24, 0x0D, 0xD1, 0x7E, 0x14, + 0x0E, 0x07, 0x7E, 0x04, 0x0E, 0x1B, 0x12, 0xAF, 0x48, 0x12, 0xF3, 0x0B, + 0x70, 0x15, 0x12, 0xF0, 0xA1, 0x70, 0x10, 0x30, 0x0B, 0x0A, 0x12, 0xDA, + 0x77, 0x30, 0xE5, 0x04, 0x54, 0x0A, 0x78, 0x03, 0xE4, 0x80, 0x02, 0x74, + 0x01, 0xDA, 0x79, 0x22, 0x13, 0x69, 0xCA, 0xD5, 0x47, 0x0E, 0x36, 0x17, + 0x46, 0xF7, 0xBC, 0xCD, 0x79, 0xA4, 0xE9, 0x05, 0x83, 0xAC, 0xC7, 0xEC, + 0xA8, 0x85, 0xDC, 0xF9, 0x39, 0xE0, 0x61, 0x45, 0x56, 0xF2, 0xCD, 0x88, + 0xB4, 0x2B, 0xE1, 0x04, 0xC5, 0x4B, 0xC7, 0x35, 0xF1, 0xD8, 0x83, 0x0A, + 0x31, 0xCB, 0xBD, 0x1C, 0x46, 0x86, 0xA7, 0x0F, 0xDB, 0x6F, 0x7E, 0x99, + 0xCF, 0x40, 0xF0, 0xDA, 0x69, 0xD8, 0xF0, 0x87, 0x3D, 0xB5, 0x29, 0x09, + 0x0E, 0x4C, 0xA7, 0x13, 0xDF, 0xF8, 0x7B, 0x62, 0x0B, 0xB8, 0x43, 0x13, + 0x90, 0xD5, 0x7E, 0xC3, 0xF6, 0xD3, 0x1D, 0x7C, 0x67, 0x31, 0x8B, 0x8F, + 0xE1, 0xC7, 0xCD, 0x5C, 0x3B, 0x7B, 0x63, 0xBA, 0x39, 0xE5, 0x78, 0xEA, + 0x7A, 0xB5, 0x2D, 0x5E, 0x0B, 0x79, 0xEF, 0x26, 0xCA, 0x81, 0xBA, 0x61, + 0x8D, 0x9A, 0xA4, 0x82, 0x05, 0xC2, 0x22, 0x2D, 0x80, 0x20, 0x64, 0xA6, + 0x12, 0x9C, 0x92, 0x7E, 0x34, 0xC0, 0x20, 0x7E, 0x24, 0x00, 0x24, 0x12, + 0xF2, 0xA4, 0x7E, 0x34, 0x04, 0x90, 0x2E, 0x34, 0x00, 0x24, 0x7E, 0x53, + 0x05, 0x1B, 0x0A, 0x55, 0x1B, 0x56, 0x7C, 0xAB, 0x6C, 0x55, 0x1A, 0x05, + 0x7E, 0x14, 0x00, 0x12, 0xAD, 0x10, 0x7D, 0x41, 0x2E, 0x44, 0xC0, 0x20, + 0x6C, 0x44, 0x7E, 0x39, 0xB0, 0x7A, 0x49, 0xB0, 0x0B, 0x44, 0x0B, 0x34, + 0x0B, 0x40, 0xBE, 0x40, 0x02, 0x48, 0xEF, 0x0A, 0x1A, 0x2D, 0x41, 0x80, + 0x0C, 0x7E, 0x39, 0xB0, 0x7A, 0x49, 0xB0, 0x0B, 0x44, 0x0B, 0x34, 0x0B, + 0x40, 0xBE, 0x40, 0x04, 0x48, 0xEF, 0x0B, 0x50, 0xBE, 0x50, 0x02, 0x48, + 0xC1, 0x7E, 0x34, 0xC0, 0x44, 0x7E, 0x24, 0x00, 0x24, 0x12, 0xF2, 0xA4, + 0x7E, 0x34, 0x04, 0x90, 0x7E, 0x24, 0xC0, 0x44, 0x74, 0x02, 0x12, 0xE2, + 0x47, 0x7E, 0x34, 0xC0, 0x20, 0x7E, 0x24, 0xC0, 0x44, 0x74, 0x02, 0x02, + 0xE2, 0x47, 0xCA, 0x79, 0x7D, 0x40, 0x7D, 0xF1, 0x7D, 0xE2, 0x7D, 0x13, + 0x1A, 0xDB, 0x3E, 0xD4, 0x3E, 0xD4, 0x3E, 0xD4, 0x7D, 0xCD, 0x2E, 0xC4, + 0x05, 0xF1, 0x2E, 0xD4, 0x06, 0x41, 0x1A, 0x02, 0x1A, 0x00, 0x7D, 0x32, + 0x1A, 0x26, 0x1A, 0x24, 0x7E, 0xB3, 0x04, 0x70, 0x30, 0xE6, 0x0A, 0x2E, + 0xC4, 0x00, 0x06, 0x2E, 0xD4, 0x00, 0x06, 0x80, 0x3D, 0xE4, 0x0B, 0xC8, + 0xB0, 0x7D, 0x7B, 0x1A, 0x7E, 0x1A, 0xAE, 0x2F, 0x05, 0x0B, 0xC5, 0x0B, + 0xD8, 0xB0, 0x7D, 0x7B, 0x1A, 0x7E, 0x1A, 0xAE, 0x2F, 0x15, 0x0B, 0xD5, + 0x04, 0xBE, 0xB0, 0x03, 0x48, 0xE0, 0x74, 0x02, 0x1E, 0x14, 0x0E, 0x04, + 0x50, 0x03, 0x4E, 0x20, 0x80, 0x14, 0x78, 0xF4, 0x74, 0x02, 0x1E, 0x34, + 0x0E, 0x24, 0x50, 0x03, 0x4E, 0x60, 0x80, 0x14, 0x78, 0xF4, 0x1B, 0xC8, + 0x10, 0x1B, 0xD8, 0x30, 0x1B, 0xF8, 0x10, 0x1B, 0x48, 0x30, 0xDA, 0x79, + 0x22, 0x7C, 0x3B, 0xBE, 0x33, 0x2D, 0x0C, 0x68, 0x25, 0x7E, 0x23, 0x2D, + 0x0C, 0x0A, 0x32, 0x09, 0x73, 0x2C, 0xC4, 0xBE, 0x70, 0x04, 0x50, 0x16, + 0x74, 0x02, 0xAC, 0xB2, 0x49, 0x25, 0x2D, 0x16, 0x7E, 0x73, 0x2D, 0x03, + 0x0A, 0x37, 0xBD, 0x23, 0x50, 0x04, 0x7C, 0xB2, 0x80, 0x51, 0x7E, 0x00, + 0xFF, 0x7E, 0x10, 0xFF, 0x7E, 0x34, 0xFF, 0xFF, 0x7D, 0x43, 0x6C, 0x22, + 0x80, 0x2E, 0xBC, 0x32, 0x68, 0x28, 0x74, 0x02, 0xAC, 0xB2, 0x49, 0x25, + 0x2D, 0x16, 0x0A, 0x52, 0x09, 0xB5, 0x2C, 0xC4, 0xBE, 0xB0, 0x04, 0x50, + 0x08, 0xBD, 0x23, 0x50, 0x04, 0x7D, 0x32, 0x7C, 0x12, 0xBE, 0xB0, 0x10, + 0x50, 0x08, 0xBD, 0x24, 0x50, 0x04, 0x7D, 0x42, 0x7C, 0x02, 0x0B, 0x20, + 0x7E, 0xB3, 0x2D, 0x02, 0xBC, 0xB2, 0x38, 0xCA, 0xBE, 0x10, 0xFF, 0x68, + 0x04, 0x7C, 0xB1, 0x80, 0x02, 0x7C, 0xB0, 0x22, 0xCA, 0xD8, 0xCA, 0x79, + 0x7C, 0xF6, 0x7C, 0xE7, 0x7C, 0xDB, 0x7E, 0x34, 0x37, 0x10, 0x7D, 0x21, + 0x7E, 0x14, 0x00, 0x1E, 0x12, 0xF0, 0xDB, 0x7E, 0x34, 0x2E, 0x54, 0x7E, + 0x24, 0x08, 0xBC, 0x12, 0xF2, 0xA4, 0x7A, 0xD3, 0x2E, 0x56, 0x7A, 0xE3, + 0x2E, 0x57, 0x7A, 0xF3, 0x2E, 0x58, 0x7E, 0xB3, 0x2E, 0x58, 0x70, 0x06, + 0x74, 0x01, 0x7A, 0xB3, 0x2E, 0x58, 0x6D, 0x11, 0x09, 0x71, 0x37, 0x12, + 0x0A, 0x07, 0x3E, 0x04, 0x3E, 0x04, 0x7D, 0x31, 0x3E, 0x34, 0x59, 0x03, + 0x37, 0x09, 0x4D, 0x11, 0x68, 0x1F, 0x7D, 0x01, 0x3E, 0x04, 0x49, 0x20, + 0x37, 0x09, 0x49, 0x30, 0x37, 0x07, 0x9D, 0x32, 0x3E, 0x34, 0x3E, 0x34, + 0x3E, 0x34, 0x7E, 0x24, 0x00, 0x0A, 0x12, 0x8C, 0x88, 0x59, 0x30, 0x37, + 0x03, 0x0B, 0x14, 0xBE, 0x14, 0x00, 0x03, 0x48, 0xC3, 0xDA, 0x79, 0xDA, + 0xD8, 0x22, 0xCA, 0xF8, 0x6C, 0xFF, 0x7E, 0x50, 0x12, 0xAC, 0x5F, 0x3E, + 0x24, 0x7D, 0x32, 0x2E, 0x34, 0x05, 0x39, 0x2E, 0x24, 0x04, 0xBC, 0x7E, + 0x30, 0x02, 0xAC, 0x3F, 0x2E, 0x17, 0x03, 0x10, 0x7E, 0xB3, 0x05, 0x1B, + 0x7E, 0x13, 0x05, 0x1A, 0x12, 0xAF, 0xF3, 0x0B, 0xF0, 0xBE, 0xF0, 0x02, + 0x78, 0xD4, 0x7E, 0xF0, 0x08, 0x7E, 0x23, 0x05, 0x1A, 0xBE, 0x20, 0x08, + 0x50, 0x02, 0x7C, 0xF2, 0x7E, 0x34, 0x05, 0x81, 0x7E, 0x24, 0x05, 0x04, + 0x7E, 0x30, 0x02, 0xAC, 0x23, 0x2E, 0x17, 0x03, 0x10, 0x1B, 0x15, 0x7C, + 0xBF, 0x7E, 0x10, 0xFF, 0x12, 0xAF, 0xF3, 0x7E, 0x34, 0x05, 0x91, 0x7E, + 0x24, 0x05, 0x04, 0x7E, 0x23, 0x05, 0x1B, 0x7E, 0x33, 0x05, 0x1A, 0xAC, + 0x32, 0x3E, 0x14, 0x2E, 0x17, 0x03, 0x10, 0x1B, 0x15, 0x7C, 0xBF, 0x7E, + 0x10, 0xFF, 0x12, 0xAF, 0xF3, 0xDA, 0xF8, 0x22, 0xCA, 0x69, 0xCA, 0xF8, + 0x7D, 0x62, 0x7A, 0x37, 0x37, 0x61, 0x7E, 0x18, 0x37, 0x65, 0x7A, 0x1F, + 0x37, 0x71, 0x7E, 0x70, 0x01, 0x7E, 0x08, 0x37, 0x63, 0x12, 0xE9, 0x84, + 0x7E, 0x37, 0x37, 0x63, 0x0B, 0x38, 0x30, 0x7E, 0x27, 0x37, 0x65, 0x0B, + 0x28, 0x20, 0x1A, 0x1B, 0x3E, 0x14, 0x3E, 0x14, 0x3E, 0x14, 0x2E, 0x14, + 0x05, 0xF1, 0x7A, 0x17, 0x37, 0x63, 0x1A, 0x1B, 0x3E, 0x14, 0x3E, 0x14, + 0x3E, 0x14, 0x2E, 0x14, 0x06, 0x41, 0x7A, 0x17, 0x37, 0x65, 0x7E, 0x17, + 0x37, 0x63, 0x49, 0x01, 0x00, 0x02, 0x49, 0x11, 0x00, 0x04, 0x9D, 0x10, + 0x2D, 0x13, 0x7E, 0x37, 0x37, 0x61, 0x1B, 0x38, 0x10, 0x7E, 0x37, 0x37, + 0x65, 0x49, 0x13, 0x00, 0x02, 0x49, 0x33, 0x00, 0x04, 0x9D, 0x31, 0x2D, + 0x32, 0x1B, 0x68, 0x30, 0xDA, 0xF8, 0xDA, 0x69, 0x22, 0xCA, 0x3B, 0x7C, + 0xF6, 0x7C, 0xE7, 0x7C, 0xDB, 0x9F, 0x11, 0x7A, 0x1F, 0x37, 0x35, 0x6C, + 0xCC, 0x80, 0x3E, 0x7C, 0xBD, 0x7C, 0x7C, 0x12, 0xB8, 0xCC, 0x7A, 0x37, + 0x37, 0x39, 0xE4, 0x7A, 0xB3, 0x37, 0x34, 0x80, 0x24, 0x7E, 0x37, 0x37, + 0x39, 0x0B, 0x38, 0x50, 0x1A, 0x4A, 0x1A, 0x48, 0x7E, 0x0F, 0x37, 0x35, + 0x2F, 0x02, 0x7A, 0x0F, 0x37, 0x35, 0x0B, 0x35, 0x7A, 0x37, 0x37, 0x39, + 0x7E, 0xB3, 0x37, 0x34, 0x04, 0x7A, 0xB3, 0x37, 0x34, 0xBE, 0xF3, 0x37, + 0x34, 0x38, 0xD6, 0x0B, 0xC0, 0xBC, 0xEC, 0x38, 0xBE, 0xE5, 0x5F, 0x7E, + 0x31, 0x5E, 0xAC, 0x3B, 0x7D, 0x51, 0x1E, 0x54, 0x6D, 0x44, 0x7E, 0x1F, + 0x37, 0x35, 0x2F, 0x12, 0x7A, 0x1F, 0x37, 0x35, 0x6D, 0x00, 0x7E, 0x1F, + 0x37, 0x35, 0x12, 0x8D, 0x27, 0xDA, 0x3B, 0x22, 0xCA, 0x79, 0x7C, 0xE7, + 0x7C, 0xFB, 0x7E, 0x18, 0x3A, 0x7C, 0x7A, 0x1F, 0x37, 0x2E, 0x7E, 0x34, + 0x3A, 0x7C, 0xE4, 0x7E, 0x24, 0x00, 0xD3, 0x12, 0xF2, 0xF7, 0xBE, 0xF0, + 0x01, 0x40, 0x54, 0xBE, 0xF0, 0x0C, 0x38, 0x4F, 0x0A, 0x2F, 0x7E, 0x34, + 0x00, 0x10, 0x9D, 0x32, 0x7E, 0x0F, 0x37, 0x2E, 0x39, 0x70, 0x00, 0x01, + 0x0A, 0x3F, 0x6D, 0x22, 0x2E, 0x24, 0x00, 0xFF, 0x2E, 0x18, 0xF7, 0xE0, + 0x7E, 0x1B, 0x70, 0x7E, 0x0F, 0x37, 0x2E, 0x39, 0x70, 0x00, 0x02, 0x4C, + 0xEE, 0x68, 0x24, 0x7C, 0x7E, 0x1E, 0x70, 0x0A, 0x37, 0x6D, 0x22, 0x2E, + 0x18, 0x27, 0x10, 0x0A, 0x1E, 0x6D, 0x00, 0x12, 0x8D, 0x27, 0x7E, 0x0F, + 0x37, 0x2E, 0x39, 0x70, 0x00, 0x06, 0x74, 0x01, 0x7E, 0x1F, 0x37, 0x2E, + 0x7A, 0x1B, 0xB0, 0xDA, 0x79, 0x22, 0xCA, 0x3B, 0x7C, 0xFB, 0xA2, 0xEB, + 0xE4, 0x33, 0x7C, 0xEB, 0xC2, 0xEB, 0x7E, 0x37, 0xF0, 0x20, 0x5E, 0x60, + 0xFB, 0x7A, 0x37, 0xF0, 0x20, 0x6D, 0x33, 0x7A, 0x37, 0xF1, 0x62, 0xE4, + 0x12, 0xCB, 0xA2, 0xE4, 0x12, 0xDC, 0x9B, 0xE4, 0x6C, 0x77, 0x6C, 0x66, + 0x12, 0x88, 0x8E, 0x7C, 0xBF, 0x12, 0xBB, 0x27, 0x12, 0xE5, 0xD1, 0x74, + 0x01, 0x12, 0xEE, 0xA5, 0xE4, 0x12, 0xEE, 0xA5, 0x12, 0xF4, 0xAE, 0x7E, + 0x67, 0xF0, 0x02, 0xA2, 0x01, 0xE4, 0x33, 0xB4, 0x01, 0x10, 0x7E, 0x37, + 0xF0, 0x20, 0x4E, 0x70, 0xFF, 0x7A, 0x37, 0xF0, 0x20, 0x12, 0xE1, 0x45, + 0x80, 0x05, 0x74, 0x01, 0x12, 0xCB, 0xA2, 0xBE, 0x67, 0xF0, 0x02, 0x78, + 0xFA, 0xE5, 0x5B, 0x12, 0xEE, 0xE7, 0x2E, 0xE0, 0xFF, 0x92, 0xEB, 0xDA, + 0x3B, 0x22, 0xCA, 0xF8, 0x30, 0x01, 0x6B, 0x20, 0x0F, 0x68, 0x7E, 0x73, + 0x2C, 0x7B, 0x0A, 0x27, 0x1B, 0x24, 0x7E, 0x73, 0x2C, 0x5F, 0x0A, 0x37, + 0xBD, 0x32, 0x78, 0x12, 0x6C, 0xAA, 0xA2, 0x24, 0xE4, 0x33, 0x0A, 0x2B, + 0x7E, 0x34, 0x00, 0xCB, 0xAD, 0x32, 0x19, 0xA3, 0x2A, 0x1B, 0x7E, 0xF3, + 0x2C, 0x7B, 0xBE, 0xF3, 0x2C, 0x5F, 0x28, 0x2A, 0x7E, 0xB3, 0x2C, 0x5F, + 0x60, 0x24, 0xCA, 0xB8, 0xA2, 0x24, 0xE4, 0x33, 0x0A, 0x0B, 0x7E, 0x14, + 0x00, 0xCB, 0xAD, 0x10, 0x2E, 0x14, 0x2A, 0x1D, 0x6D, 0x00, 0xDA, 0xB8, + 0x12, 0xA7, 0xA5, 0xD2, 0x26, 0xD2, 0x2A, 0x74, 0x01, 0x12, 0xF4, 0x96, + 0x80, 0x10, 0xBE, 0xF3, 0x2C, 0x5F, 0x38, 0x0A, 0xE4, 0x7A, 0xB3, 0x2C, + 0x5F, 0xE4, 0x7A, 0xB3, 0x2C, 0x7B, 0xDA, 0xF8, 0x22, 0x6D, 0x33, 0x80, + 0x36, 0x7E, 0xB3, 0x2D, 0x0F, 0x04, 0x7A, 0xB3, 0x2D, 0x0F, 0x7E, 0x53, + 0x2D, 0x02, 0xBE, 0x53, 0x2D, 0x0F, 0x38, 0x05, 0xE4, 0x7A, 0xB3, 0x2D, + 0x0F, 0x7E, 0x53, 0x2D, 0x0F, 0x0A, 0x25, 0x09, 0xB2, 0x2D, 0x5E, 0x60, + 0x10, 0x7E, 0x33, 0x2D, 0x0D, 0xBE, 0x33, 0x2D, 0x0F, 0x68, 0x06, 0x09, + 0xB2, 0x2D, 0x50, 0x60, 0x0C, 0x0B, 0x34, 0x7E, 0x53, 0x2D, 0x02, 0x0A, + 0x25, 0xBD, 0x23, 0x18, 0xC0, 0x7E, 0x53, 0x2D, 0x02, 0x0A, 0x25, 0xBD, + 0x23, 0x18, 0x1F, 0x6D, 0x33, 0x80, 0x11, 0x09, 0xB3, 0x2C, 0xC4, 0xBE, + 0xB0, 0x10, 0x68, 0x06, 0x74, 0x01, 0x19, 0xB3, 0x2D, 0x5E, 0x0B, 0x34, + 0x7E, 0x53, 0x2D, 0x02, 0x0A, 0x25, 0xBD, 0x23, 0x18, 0xE5, 0x7E, 0xB3, + 0x2D, 0x0F, 0x22, 0x7D, 0x43, 0x7C, 0xAB, 0x7E, 0x73, 0x05, 0x1A, 0x7E, + 0x63, 0x04, 0x15, 0x4C, 0xAB, 0x68, 0x0A, 0x0A, 0x1A, 0x1A, 0x06, 0xAD, + 0x10, 0x1A, 0x22, 0x7C, 0x65, 0x6D, 0x22, 0xE4, 0x80, 0x16, 0x7D, 0x12, + 0x0E, 0x14, 0x0E, 0x14, 0x0E, 0x14, 0x0E, 0x14, 0x1A, 0x0B, 0x2D, 0x04, + 0x7A, 0x09, 0x30, 0x1A, 0x06, 0x2D, 0x20, 0x04, 0xBC, 0x7B, 0x18, 0xE6, + 0x7E, 0x43, 0x04, 0x80, 0x7E, 0x63, 0x04, 0x81, 0x4C, 0xAA, 0x68, 0x16, + 0x0A, 0x1A, 0x1A, 0xE4, 0x7D, 0xFE, 0xAD, 0xF1, 0x7D, 0x2F, 0x1A, 0x24, + 0x7C, 0x45, 0x1A, 0x06, 0xAD, 0x10, 0x1A, 0x52, 0x7C, 0x6B, 0x7E, 0x49, + 0x50, 0x2C, 0x54, 0x7A, 0x49, 0x50, 0x1A, 0x27, 0x2D, 0x24, 0x1B, 0x24, + 0x7E, 0x29, 0x70, 0x2C, 0x76, 0x7A, 0x29, 0x70, 0x22, 0x7D, 0x23, 0xBE, + 0x24, 0x00, 0x10, 0x40, 0x57, 0xBE, 0x24, 0x00, 0x13, 0x38, 0x51, 0x30, + 0x26, 0x5F, 0x20, 0x30, 0x5C, 0x7E, 0x37, 0x2C, 0x5C, 0x7A, 0x37, 0xFF, + 0xD2, 0x7E, 0x34, 0x90, 0x10, 0x7A, 0x37, 0xFF, 0xD6, 0x7E, 0x34, 0x00, + 0xCB, 0x7A, 0x37, 0xFF, 0xDA, 0x7E, 0x34, 0x00, 0x01, 0x7A, 0x37, 0xFF, + 0xD0, 0x30, 0x01, 0x0C, 0x20, 0x0F, 0x09, 0x7E, 0xB3, 0x2C, 0x5F, 0x04, + 0x7A, 0xB3, 0x2C, 0x5F, 0xD2, 0x30, 0x7E, 0x37, 0xFF, 0xD0, 0x5E, 0x34, + 0x00, 0x01, 0x78, 0xF6, 0x7E, 0x37, 0x12, 0xE9, 0x09, 0xB3, 0x00, 0x10, + 0x54, 0x0C, 0x7A, 0xB3, 0x18, 0xF2, 0x80, 0x11, 0xBE, 0x24, 0x01, 0x40, + 0x78, 0x0B, 0x7E, 0x34, 0x00, 0x5C, 0x12, 0xDE, 0xE3, 0xE4, 0x12, 0xF0, + 0x84, 0x22, 0xCA, 0x79, 0x7C, 0xAB, 0x6C, 0x77, 0xA2, 0xEB, 0xE4, 0x33, + 0x7C, 0xFB, 0xA2, 0xAE, 0xE4, 0x33, 0x7C, 0xEB, 0xC2, 0xAE, 0xC2, 0xEB, + 0x4C, 0xAA, 0x68, 0x2A, 0x7E, 0x27, 0x2D, 0xED, 0x0B, 0x28, 0x30, 0x4E, + 0x70, 0x02, 0x1B, 0x28, 0x30, 0x7E, 0x37, 0x2D, 0xED, 0x0B, 0x38, 0x30, + 0x7A, 0x37, 0xF0, 0x00, 0x7E, 0x34, 0xF7, 0xD3, 0x7E, 0x24, 0x00, 0xFF, + 0x0B, 0x1A, 0x30, 0x74, 0x01, 0x12, 0xED, 0xAD, 0x80, 0x20, 0x7E, 0x27, + 0x2D, 0xED, 0x0B, 0x28, 0x30, 0x5E, 0x70, 0xFD, 0x1B, 0x28, 0x30, 0x6C, + 0x77, 0x7E, 0x27, 0x2D, 0xED, 0x0B, 0x28, 0x20, 0x7A, 0x27, 0xF0, 0x00, + 0x0B, 0x70, 0xA5, 0xBF, 0x1E, 0xEF, 0x2E, 0xE0, 0xFF, 0x92, 0xAE, 0x2E, + 0xF0, 0xFF, 0x92, 0xEB, 0xDA, 0x79, 0x22, 0x7C, 0x9B, 0x7E, 0x24, 0x03, + 0xED, 0x49, 0x32, 0x00, 0x04, 0x49, 0x22, 0x00, 0x08, 0x7E, 0x17, 0x03, + 0xD5, 0xBD, 0x12, 0x58, 0x04, 0x7A, 0x27, 0x03, 0xD5, 0xBE, 0x34, 0x00, + 0x00, 0x58, 0x0C, 0x7E, 0x27, 0x03, 0xDB, 0xBD, 0x23, 0x08, 0x04, 0x7A, + 0x37, 0x03, 0xDB, 0x1A, 0x29, 0x09, 0x82, 0x03, 0x32, 0xBE, 0x34, 0x00, + 0x00, 0x58, 0x2E, 0xBE, 0x80, 0x04, 0x50, 0x02, 0x0B, 0x80, 0x1A, 0x26, + 0x1A, 0x24, 0x0A, 0x18, 0x6D, 0x00, 0x12, 0x8C, 0xBA, 0x74, 0x02, 0x1E, + 0x34, 0x0E, 0x24, 0x50, 0x03, 0x4E, 0x60, 0x80, 0x14, 0x78, 0xF4, 0x7E, + 0x27, 0x03, 0xD7, 0xBD, 0x23, 0x08, 0x08, 0x7A, 0x37, 0x03, 0xD7, 0x80, + 0x02, 0x6C, 0x88, 0x1A, 0x39, 0x19, 0x83, 0x03, 0x32, 0x6D, 0x33, 0x22, + 0xCA, 0x79, 0x7E, 0x37, 0xF1, 0x80, 0xBE, 0x73, 0x12, 0xE7, 0x50, 0x14, + 0x7E, 0x37, 0xF1, 0x80, 0x0A, 0x37, 0x7E, 0x53, 0x12, 0xE7, 0x0A, 0x25, + 0x9D, 0x32, 0x6D, 0x77, 0x9D, 0x73, 0x80, 0x0E, 0x7E, 0x37, 0xF1, 0x80, + 0x0A, 0x77, 0x7E, 0x73, 0x12, 0xE7, 0x0A, 0x37, 0x9D, 0x73, 0x12, 0xF5, + 0xB7, 0x70, 0x38, 0x7E, 0x73, 0x2C, 0x3F, 0xBE, 0x70, 0x03, 0x50, 0x0C, + 0x75, 0x9A, 0x03, 0x7C, 0xB7, 0x04, 0x7A, 0xB3, 0x2C, 0x3F, 0x80, 0x25, + 0x7E, 0xA1, 0x9B, 0x75, 0x9A, 0x03, 0xA5, 0xBF, 0x03, 0x06, 0x7A, 0xA3, + 0x2C, 0x3F, 0x80, 0x15, 0xBE, 0xF0, 0x01, 0x78, 0x10, 0x0A, 0x37, 0x0A, + 0x2A, 0x2D, 0x32, 0x1E, 0x34, 0x7A, 0x73, 0x2C, 0x3F, 0x80, 0x02, 0xD2, + 0x0E, 0xDA, 0x79, 0x22, 0xCA, 0x69, 0xCA, 0xF8, 0x7D, 0xF0, 0x7C, 0xA4, + 0x7C, 0x95, 0x7C, 0x8B, 0x7D, 0x03, 0x6C, 0xFF, 0x6C, 0x55, 0x7E, 0xE4, + 0x7F, 0x00, 0x7D, 0x3E, 0x6C, 0x44, 0x80, 0x3A, 0xBC, 0x94, 0x68, 0x27, + 0x4D, 0x11, 0x68, 0x0A, 0x0B, 0x18, 0xD0, 0x0B, 0x08, 0xC0, 0x9D, 0xCD, + 0x80, 0x03, 0x0B, 0x08, 0xC0, 0xBD, 0xEC, 0x08, 0x12, 0xBD, 0x3C, 0x18, + 0x06, 0x7D, 0xEC, 0x7C, 0xF4, 0x80, 0x08, 0x7D, 0xE3, 0x7D, 0x3C, 0x7C, + 0xF5, 0x7C, 0x54, 0x7E, 0xD0, 0x02, 0xAC, 0xDA, 0x2D, 0x06, 0x4D, 0x11, + 0x68, 0x02, 0x0B, 0x15, 0x0B, 0x40, 0xBC, 0x84, 0x38, 0xC2, 0x7A, 0xF9, + 0x50, 0x7E, 0x27, 0x37, 0x6A, 0x7A, 0x29, 0xF0, 0x7E, 0x27, 0x37, 0x6C, + 0x1B, 0x28, 0xE0, 0xDA, 0xF8, 0xDA, 0x69, 0x22, 0xA2, 0x01, 0xE4, 0x33, + 0xB4, 0x01, 0x0B, 0x7E, 0x37, 0xF0, 0x20, 0x5E, 0x60, 0xFB, 0x7A, 0x37, + 0xF0, 0x20, 0x74, 0x01, 0x12, 0xEE, 0xA5, 0xA2, 0x01, 0xE4, 0x33, 0x78, + 0x0A, 0x74, 0xFF, 0x12, 0xBB, 0x27, 0xE5, 0x5B, 0x12, 0xCE, 0x3F, 0xA2, + 0x01, 0xE4, 0x33, 0xB4, 0x01, 0x0A, 0x74, 0xFF, 0x12, 0xBB, 0x27, 0xE5, + 0x5B, 0x12, 0xCE, 0x3F, 0x12, 0xE5, 0xD1, 0xE4, 0x12, 0xEE, 0xA5, 0xE5, + 0x5B, 0x12, 0xEE, 0xE7, 0x12, 0xF3, 0xDB, 0xA2, 0x01, 0xE4, 0x33, 0xB4, + 0x01, 0x0B, 0x7E, 0x37, 0xF0, 0x20, 0x4E, 0x60, 0x04, 0x7A, 0x37, 0xF0, + 0x20, 0x12, 0xF4, 0xAE, 0x7E, 0xB3, 0x2C, 0x64, 0xB4, 0xBB, 0x08, 0x7E, + 0x73, 0x2C, 0x78, 0x7A, 0x73, 0x2C, 0x64, 0xC2, 0x21, 0x22, 0xCA, 0x3B, + 0x7E, 0x34, 0xC1, 0x2A, 0x7A, 0x37, 0x37, 0x45, 0x7E, 0x74, 0x03, 0x52, + 0x6D, 0x66, 0x80, 0x4E, 0x0B, 0x78, 0x30, 0x0B, 0x75, 0x7A, 0x37, 0x37, + 0x47, 0x0B, 0x78, 0x30, 0x0B, 0x75, 0x7A, 0x37, 0x37, 0x49, 0x0B, 0x78, + 0x30, 0x0B, 0x75, 0x7A, 0x37, 0x37, 0x4B, 0x7E, 0x27, 0x37, 0x45, 0x7E, + 0x29, 0x70, 0x0B, 0x24, 0x7A, 0x27, 0x37, 0x45, 0x7A, 0x73, 0x37, 0x4D, + 0x7E, 0xB3, 0x37, 0x4D, 0xBE, 0xB0, 0x02, 0x68, 0x17, 0x74, 0xFF, 0x7E, + 0x37, 0x37, 0x47, 0x7E, 0x27, 0x37, 0x49, 0x7E, 0x17, 0x37, 0x4B, 0x12, + 0x71, 0xF4, 0x74, 0x01, 0x7A, 0xB3, 0x0A, 0xA0, 0x0B, 0x64, 0x7E, 0x73, + 0x03, 0xB6, 0x0A, 0x37, 0xBD, 0x36, 0x18, 0xA8, 0xDA, 0x3B, 0x22, 0x7C, + 0xAB, 0x4C, 0xAA, 0x78, 0x13, 0x7E, 0x37, 0x2D, 0xD9, 0x2E, 0x34, 0x00, + 0x0C, 0x0B, 0x38, 0x30, 0x5E, 0x60, 0x0F, 0x12, 0xF4, 0x62, 0x80, 0x51, + 0xBE, 0xA0, 0x02, 0x78, 0x11, 0x7E, 0x37, 0x2D, 0xE3, 0x0B, 0x35, 0x0B, + 0x38, 0x30, 0x5E, 0x60, 0x0F, 0x12, 0xF4, 0x62, 0x80, 0x3B, 0xE4, 0x7A, + 0xB3, 0x18, 0xF9, 0x6D, 0x33, 0x7A, 0x37, 0x28, 0x1F, 0x7A, 0x37, 0x28, + 0x19, 0xE4, 0x7A, 0xB3, 0x2D, 0xF2, 0xBE, 0xA0, 0x01, 0x78, 0x13, 0x7E, + 0x37, 0x2D, 0xD9, 0x2E, 0x34, 0x00, 0x0E, 0x0B, 0x38, 0x30, 0x5E, 0x60, + 0x0F, 0x12, 0xF4, 0x62, 0x80, 0x0F, 0x7E, 0x37, 0x2D, 0xE3, 0x0B, 0x36, + 0x0B, 0x38, 0x30, 0x5E, 0x60, 0x0F, 0x12, 0xF4, 0x62, 0x22, 0xCA, 0x79, + 0x7E, 0x74, 0xC1, 0x20, 0x12, 0x85, 0x71, 0x7C, 0xAB, 0x6C, 0x77, 0x74, + 0xFF, 0x1A, 0x27, 0x2D, 0x27, 0x7A, 0x29, 0xB0, 0x0B, 0x70, 0xBE, 0x70, + 0x0A, 0x48, 0xF0, 0x7C, 0xBA, 0x12, 0x1D, 0xED, 0x7E, 0x37, 0x0A, 0x9C, + 0x0B, 0x34, 0x7A, 0x37, 0x0A, 0x9C, 0xE4, 0x7A, 0xB3, 0x0A, 0x9E, 0x7A, + 0xB3, 0x0A, 0x9F, 0x7A, 0xB3, 0x0A, 0xA0, 0x7E, 0x34, 0xC1, 0x2A, 0x7E, + 0x24, 0x00, 0x0A, 0x12, 0xF2, 0xA4, 0x7E, 0x34, 0x0A, 0xAB, 0x7E, 0x24, + 0x00, 0x0A, 0x12, 0xF2, 0xA4, 0x7D, 0x37, 0x12, 0x67, 0x55, 0x7D, 0x17, + 0x6D, 0x00, 0x12, 0x23, 0x05, 0x7D, 0x37, 0x12, 0x9A, 0x12, 0x12, 0xCD, + 0xD2, 0xDA, 0x79, 0x22, 0x7D, 0x13, 0x7E, 0xB3, 0x18, 0xF2, 0x0A, 0x3B, + 0x5E, 0x34, 0x00, 0x08, 0x68, 0x24, 0x7E, 0xA3, 0x12, 0xEE, 0x0A, 0x3A, + 0xBD, 0x31, 0x40, 0x1A, 0xBD, 0x32, 0x38, 0x16, 0x54, 0xF7, 0x7A, 0xB3, + 0x18, 0xF2, 0x7E, 0x37, 0x12, 0xE9, 0x2E, 0x34, 0x00, 0x10, 0x7E, 0x39, + 0xB0, 0x54, 0xF7, 0x7A, 0x39, 0xB0, 0x7E, 0xB3, 0x18, 0xF2, 0x0A, 0x3B, + 0x5E, 0x34, 0x00, 0x04, 0x68, 0x24, 0x7E, 0xA3, 0x2C, 0x58, 0x0A, 0x3A, + 0xBD, 0x31, 0x40, 0x1A, 0xBD, 0x32, 0x38, 0x16, 0x54, 0xFB, 0x7A, 0xB3, + 0x18, 0xF2, 0x7E, 0x37, 0x12, 0xE9, 0x2E, 0x34, 0x00, 0x10, 0x7E, 0x39, + 0xB0, 0x54, 0xFB, 0x7A, 0x39, 0xB0, 0x22, 0xCA, 0xF8, 0x7E, 0x34, 0x0D, + 0xF7, 0x7E, 0x24, 0x0E, 0x07, 0x7E, 0x14, 0x0E, 0x1B, 0x7E, 0x04, 0x0D, + 0xEB, 0x12, 0x3A, 0x4F, 0x7A, 0x73, 0x0E, 0x31, 0x12, 0xF5, 0xA5, 0x7A, + 0xB3, 0x0E, 0x32, 0xA2, 0x01, 0xE4, 0x33, 0x78, 0x04, 0x74, 0x01, 0x80, + 0x01, 0xE4, 0x7E, 0x73, 0x12, 0xE7, 0x12, 0x73, 0x61, 0x7E, 0xB3, 0x0D, + 0xBB, 0xB4, 0xFF, 0x0A, 0x7E, 0xB3, 0x0E, 0x31, 0x70, 0x04, 0x6C, 0xFF, + 0x80, 0x03, 0x7E, 0xF0, 0x01, 0x12, 0xF4, 0xD2, 0x4C, 0xFB, 0x12, 0xF5, + 0x4C, 0x4C, 0xFB, 0x12, 0xDA, 0x77, 0x30, 0xE7, 0x03, 0x4E, 0xF0, 0x01, + 0x12, 0xDC, 0xE7, 0x4C, 0xFB, 0x7C, 0xBF, 0xDA, 0xF8, 0x22, 0x7C, 0x93, + 0x7D, 0xE2, 0x7D, 0xB3, 0x6D, 0xAA, 0x0A, 0x1B, 0x6D, 0x00, 0x7F, 0x15, + 0x12, 0x8C, 0xBA, 0x7C, 0x76, 0x7C, 0x65, 0x7D, 0xF3, 0x9F, 0x66, 0x9F, + 0x11, 0x4C, 0x99, 0x68, 0x33, 0x0A, 0x19, 0x6D, 0x00, 0x7F, 0x15, 0x12, + 0x8C, 0xBA, 0x7C, 0x76, 0x7C, 0x65, 0x1A, 0x24, 0x7D, 0x1E, 0x6D, 0x00, + 0x9F, 0x10, 0xBE, 0x18, 0x00, 0x00, 0x18, 0x04, 0x7F, 0x16, 0x80, 0x14, + 0x7E, 0x33, 0x04, 0x41, 0x0A, 0x13, 0x6D, 0x00, 0x12, 0x8C, 0xBA, 0x1E, + 0x34, 0x0E, 0x24, 0x50, 0x03, 0x4E, 0x60, 0x80, 0x7D, 0x1F, 0x6D, 0x00, + 0x2F, 0x10, 0xBE, 0x18, 0xFF, 0xFF, 0x08, 0x04, 0x7E, 0x18, 0xFF, 0xFF, + 0x22, 0xCA, 0x79, 0x7E, 0x74, 0x3A, 0x7C, 0x6C, 0xAA, 0x09, 0xB7, 0x00, + 0x0C, 0xBE, 0xB0, 0x02, 0x50, 0x06, 0x09, 0xB7, 0x00, 0x0F, 0x60, 0x39, + 0x09, 0xA7, 0x00, 0x0D, 0x09, 0xB7, 0x00, 0x0F, 0x60, 0x03, 0x7E, 0xA0, + 0xFF, 0x7C, 0xBA, 0x12, 0xA9, 0xCC, 0x7C, 0xAB, 0xBE, 0xA0, 0x00, 0x58, + 0x0C, 0x09, 0x77, 0x00, 0x0D, 0x19, 0x77, 0x00, 0x0E, 0x6C, 0xAA, 0x80, + 0x14, 0x4C, 0xAA, 0x68, 0x10, 0xE4, 0x19, 0xB7, 0x00, 0x0E, 0x74, 0x01, + 0x19, 0xB7, 0x00, 0x08, 0x12, 0xC4, 0x78, 0x7C, 0xAB, 0x7D, 0x47, 0x2E, + 0x44, 0x00, 0x0D, 0x7E, 0x49, 0xB0, 0x04, 0x7A, 0x49, 0xB0, 0x7C, 0xBA, + 0xDA, 0x79, 0x22, 0x7C, 0x95, 0x7C, 0xA6, 0x7C, 0x87, 0x7F, 0x70, 0x6D, + 0x33, 0x2C, 0x8B, 0xBE, 0x80, 0x00, 0x48, 0x50, 0x7E, 0xB3, 0x0E, 0x7E, + 0xBC, 0xB8, 0x28, 0x48, 0x7E, 0x53, 0x0E, 0x7B, 0x0A, 0x15, 0x1A, 0xAA, + 0x7D, 0xBA, 0xAD, 0xB1, 0x7E, 0x43, 0x0E, 0x7C, 0x0A, 0xD4, 0x1A, 0xC8, + 0xAD, 0xDC, 0x7D, 0x0D, 0x2D, 0x0B, 0x6C, 0x44, 0x80, 0x26, 0xBE, 0xA0, + 0x00, 0x48, 0x1B, 0x7E, 0xB3, 0x0E, 0x7D, 0xBC, 0xBA, 0x28, 0x13, 0x7D, + 0xD0, 0x3E, 0xD4, 0x2D, 0xDF, 0x7D, 0xCE, 0x0B, 0x6A, 0xD0, 0xBE, 0xD4, + 0x00, 0x00, 0x08, 0x02, 0x2D, 0x3D, 0x0B, 0xA0, 0x2D, 0x01, 0x0B, 0x40, + 0xBC, 0x94, 0x38, 0xD6, 0x22, 0x7E, 0x37, 0x2D, 0xD5, 0x49, 0x33, 0x00, + 0x26, 0x2E, 0x34, 0x03, 0x00, 0x7E, 0x08, 0xF0, 0x4E, 0x7E, 0x24, 0x00, + 0x8A, 0x12, 0xEE, 0x3D, 0xE4, 0x12, 0xCB, 0xA2, 0x7E, 0x37, 0xF3, 0x12, + 0x5E, 0x34, 0xF0, 0x00, 0x4E, 0x60, 0x02, 0x7A, 0x37, 0xF3, 0x12, 0x7E, + 0x34, 0x11, 0x35, 0x7A, 0x37, 0xF3, 0x14, 0x7E, 0x37, 0x2D, 0xD5, 0x49, + 0x33, 0x00, 0x2A, 0x2E, 0x34, 0x03, 0x00, 0x7E, 0x08, 0xE0, 0x00, 0x7E, + 0x24, 0x03, 0x30, 0x12, 0xEE, 0x3D, 0x7E, 0x37, 0x2D, 0xD5, 0x49, 0x33, + 0x00, 0x28, 0x2E, 0x34, 0x03, 0x00, 0x7E, 0x08, 0xF2, 0x00, 0x7E, 0x24, + 0x00, 0x35, 0x12, 0xEE, 0x3D, 0x22, 0x20, 0x2E, 0x5D, 0xD2, 0x2E, 0x20, + 0x01, 0x04, 0xE4, 0x12, 0xCB, 0xA2, 0x7E, 0x71, 0x5E, 0x1E, 0x70, 0x0A, + 0x57, 0xC4, 0x54, 0xF0, 0x7C, 0xAB, 0xE4, 0x7D, 0x25, 0x2E, 0x24, 0x04, + 0x00, 0x7E, 0x37, 0x28, 0x1B, 0x5E, 0x34, 0x00, 0x07, 0x2D, 0x32, 0x7A, + 0x37, 0xF0, 0x24, 0x7E, 0x37, 0x2B, 0xB1, 0x4E, 0x70, 0x01, 0x7A, 0x37, + 0x2B, 0xB1, 0x7E, 0x37, 0x2B, 0xB5, 0x4E, 0x60, 0x08, 0x7A, 0x37, 0x2B, + 0xB5, 0x74, 0x01, 0x12, 0xEE, 0xA5, 0x12, 0xE5, 0xD1, 0xE4, 0x12, 0xEE, + 0xA5, 0x20, 0x01, 0x05, 0x74, 0x01, 0x12, 0xCB, 0xA2, 0x6C, 0x77, 0x00, + 0x0B, 0x70, 0xA5, 0xBF, 0x80, 0xF9, 0x22, 0x7E, 0x34, 0x2C, 0x65, 0x7E, + 0x24, 0x00, 0x12, 0x12, 0xF2, 0x4B, 0x75, 0x5B, 0xFF, 0x75, 0x58, 0xFF, + 0x75, 0x59, 0xFF, 0x75, 0x54, 0xFF, 0x75, 0x51, 0xFF, 0x74, 0xE4, 0x7E, + 0x34, 0x00, 0x61, 0x7E, 0x24, 0x00, 0x00, 0x7A, 0x1B, 0xB0, 0xE4, 0x7E, + 0x34, 0x2E, 0x53, 0x7E, 0x24, 0x00, 0x00, 0x7A, 0x1B, 0xB0, 0xE4, 0x7A, + 0xB3, 0x2C, 0x60, 0x7E, 0xB3, 0x2C, 0x5E, 0x70, 0x22, 0xA2, 0x01, 0xE4, + 0x33, 0xB4, 0x01, 0x0A, 0x75, 0x50, 0x00, 0x74, 0x02, 0x12, 0xC9, 0x66, + 0x80, 0x11, 0x7E, 0x37, 0x2D, 0xD9, 0x2E, 0x34, 0x00, 0x17, 0x7E, 0x39, + 0xB0, 0xF5, 0x50, 0xE4, 0x12, 0xC9, 0x66, 0x22, 0xCA, 0xF8, 0x7C, 0xFB, + 0x7D, 0x41, 0x7D, 0xD2, 0x7D, 0xC3, 0x7D, 0x31, 0x9D, 0x30, 0xBE, 0x34, + 0x00, 0x00, 0x58, 0x02, 0x6D, 0x33, 0x7D, 0x13, 0x1A, 0x02, 0x1A, 0x00, + 0x1A, 0x26, 0x1A, 0x24, 0x12, 0x8C, 0xBA, 0x7F, 0x51, 0x7D, 0xF4, 0x1A, + 0x38, 0x1A, 0xE6, 0x7D, 0x3C, 0x1A, 0x26, 0x1A, 0x24, 0x7F, 0x07, 0x12, + 0x8C, 0xBA, 0x2F, 0x15, 0x7D, 0x1D, 0x1A, 0x02, 0x1A, 0x00, 0x2F, 0x07, + 0x0B, 0x0C, 0x12, 0x8D, 0x27, 0x1A, 0x26, 0x1A, 0x24, 0x0A, 0x1F, 0x6D, + 0x00, 0x12, 0x8C, 0xBA, 0x74, 0x06, 0x1E, 0x34, 0x0E, 0x24, 0x50, 0x03, + 0x4E, 0x60, 0x80, 0x14, 0x78, 0xF4, 0xDA, 0xF8, 0x22, 0xCA, 0x3B, 0x7D, + 0x43, 0x7C, 0x3B, 0x7D, 0x32, 0x5E, 0x34, 0x00, 0x01, 0x68, 0x02, 0x0B, + 0x24, 0x7D, 0x32, 0x1E, 0x34, 0x7C, 0xB3, 0x44, 0x01, 0xF5, 0xD2, 0x7D, + 0x54, 0x0A, 0x5A, 0xF5, 0xD7, 0x7C, 0xB9, 0xF5, 0xD6, 0x7D, 0x53, 0x0A, + 0x5A, 0xF5, 0xD9, 0x7C, 0xB7, 0xF5, 0xD8, 0x00, 0x00, 0x00, 0x00, 0xE5, + 0xD5, 0x0A, 0x3B, 0x6D, 0x22, 0x7C, 0xC5, 0x7C, 0xD6, 0x7C, 0xE7, 0x6C, + 0xFF, 0xE5, 0xD4, 0x0A, 0x1B, 0x6D, 0x00, 0x2F, 0x03, 0x2F, 0x10, 0x7C, + 0xC5, 0x7C, 0xD6, 0x7C, 0xE7, 0x6C, 0xFF, 0xE5, 0xD3, 0x0A, 0x1B, 0x6D, + 0x00, 0x2F, 0x03, 0x2F, 0x10, 0xDA, 0x3B, 0x22, 0xCA, 0xF8, 0x7C, 0x7B, + 0x7C, 0xF7, 0x7E, 0xB3, 0x28, 0x1D, 0x30, 0xE4, 0x4E, 0xE4, 0x12, 0xCB, + 0xA2, 0x12, 0xF1, 0x9F, 0xE5, 0x59, 0xBE, 0xB0, 0x01, 0x68, 0x05, 0xE5, + 0x59, 0xB4, 0x02, 0x03, 0x12, 0xF5, 0x6B, 0x7C, 0xBF, 0x54, 0x01, 0x0A, + 0x5B, 0x5E, 0x54, 0x00, 0x01, 0xC4, 0x54, 0xF0, 0x7C, 0xAB, 0xE4, 0x7E, + 0x37, 0x2B, 0xB5, 0x5E, 0x60, 0xEF, 0x4D, 0x35, 0x7A, 0x37, 0x2B, 0xB5, + 0x74, 0x01, 0x12, 0xEE, 0xA5, 0x12, 0xE5, 0xD1, 0xE4, 0x12, 0xEE, 0xA5, + 0x74, 0x01, 0x12, 0xCB, 0xA2, 0x7E, 0xB3, 0x28, 0x1D, 0x54, 0xEF, 0x7A, + 0xB3, 0x28, 0x1D, 0xDA, 0xF8, 0x22, 0xCA, 0x3B, 0x7D, 0x72, 0x7D, 0x63, + 0x7E, 0x34, 0x0E, 0x80, 0x7A, 0x37, 0x37, 0x33, 0x12, 0xD7, 0x86, 0x6D, + 0x44, 0x80, 0x3E, 0x6D, 0x33, 0x80, 0x21, 0x7D, 0x23, 0x3E, 0x24, 0x2E, + 0x27, 0x37, 0x33, 0x0B, 0x28, 0x20, 0x0B, 0x68, 0x50, 0xBD, 0x52, 0x58, + 0x03, 0x1B, 0x68, 0x20, 0x0B, 0x78, 0x50, 0xBD, 0x52, 0x08, 0x03, 0x1B, + 0x78, 0x20, 0x0B, 0x34, 0xE5, 0x5F, 0x0A, 0x5B, 0xBD, 0x53, 0x18, 0xD7, + 0x7E, 0x51, 0x5F, 0x74, 0x02, 0xAC, 0x5B, 0x2E, 0x27, 0x37, 0x33, 0x7A, + 0x27, 0x37, 0x33, 0x0B, 0x44, 0xE5, 0x43, 0x0A, 0x2B, 0xBD, 0x24, 0x18, + 0xBA, 0xDA, 0x3B, 0x22, 0x74, 0xFF, 0x7A, 0xB3, 0x39, 0x30, 0x7A, 0x37, + 0x39, 0x31, 0x7A, 0x27, 0x39, 0x33, 0x7A, 0x37, 0x39, 0x41, 0x7A, 0x27, + 0x39, 0x43, 0x7A, 0x37, 0x39, 0x3D, 0x7A, 0x37, 0x39, 0x39, 0x7A, 0x27, + 0x39, 0x3F, 0x7A, 0x27, 0x39, 0x3B, 0xE4, 0x7A, 0xB3, 0x39, 0x46, 0xE4, + 0x7A, 0xB3, 0x3A, 0x44, 0xE4, 0x7A, 0xB3, 0x3A, 0x45, 0x74, 0xFF, 0x7A, + 0xB3, 0x3A, 0x43, 0x6C, 0x77, 0xE4, 0x0A, 0x27, 0x19, 0xB2, 0x3A, 0x49, + 0x7E, 0x60, 0x80, 0x7E, 0x50, 0x02, 0xAC, 0x57, 0x19, 0x62, 0x3A, 0x5B, + 0x74, 0x80, 0x19, 0xB2, 0x3A, 0x5A, 0x0B, 0x70, 0xBE, 0x70, 0x11, 0x40, + 0xE0, 0x22, 0x7C, 0xAB, 0x6C, 0x66, 0x7E, 0xB3, 0x04, 0x10, 0x20, 0xE0, + 0x2C, 0x1A, 0x27, 0x3E, 0x24, 0x3E, 0x24, 0x3E, 0x24, 0x3E, 0x24, 0x2E, + 0x24, 0x07, 0x9F, 0x7E, 0x73, 0x04, 0x12, 0x7C, 0xB7, 0x1E, 0xB0, 0x0A, + 0x0B, 0x0B, 0x28, 0x10, 0xBD, 0x10, 0x08, 0x0A, 0x49, 0x12, 0x00, 0x02, + 0x0A, 0x27, 0xBD, 0x12, 0x38, 0x03, 0x7E, 0x60, 0x01, 0x1A, 0x4A, 0x09, + 0xB4, 0x07, 0x27, 0xB4, 0x01, 0x1C, 0x09, 0xA4, 0x0A, 0xB5, 0x4C, 0xAA, + 0x68, 0x14, 0xBE, 0xA0, 0x10, 0x78, 0x04, 0x6C, 0xAA, 0x80, 0x07, 0xA5, + 0xBE, 0x00, 0x03, 0x7E, 0xA0, 0x10, 0x19, 0xA4, 0x0A, 0xB5, 0x22, 0x7C, + 0x35, 0x7D, 0x43, 0x7C, 0x2B, 0x7E, 0xB3, 0x04, 0x0F, 0x70, 0x50, 0x7E, + 0x27, 0x03, 0xAE, 0xBE, 0x24, 0x3F, 0xFF, 0x28, 0x04, 0x7E, 0x24, 0x3F, + 0xFF, 0x1A, 0x32, 0x3E, 0x34, 0x2D, 0x34, 0x0B, 0x38, 0x50, 0x7C, 0x2B, + 0x5E, 0x20, 0x01, 0x3E, 0x24, 0x0A, 0x02, 0x4D, 0x02, 0x7E, 0xB3, 0x04, + 0x0B, 0x60, 0x03, 0x4E, 0x00, 0x80, 0x1B, 0x38, 0x00, 0x7E, 0x20, 0x01, + 0x6C, 0xAA, 0x80, 0x13, 0x1A, 0x0A, 0x3E, 0x04, 0x2D, 0x04, 0x0B, 0x08, + 0x00, 0x5E, 0x04, 0x80, 0x00, 0x78, 0x02, 0x6C, 0x22, 0x0B, 0xA0, 0xBC, + 0x3A, 0x18, 0xE9, 0x7A, 0x23, 0x04, 0x0B, 0x22, 0xCA, 0x79, 0x7C, 0xF3, + 0x7C, 0xEB, 0x7D, 0x42, 0x7D, 0xF3, 0x7E, 0xA3, 0x04, 0x0D, 0x0A, 0xEA, + 0x1B, 0xE4, 0x7D, 0x3E, 0x7C, 0xB7, 0x7E, 0x34, 0x00, 0x01, 0x60, 0x05, + 0x3E, 0x34, 0x14, 0x78, 0xFB, 0x6C, 0x66, 0x80, 0x31, 0x0B, 0xF8, 0xD0, + 0x7D, 0x2D, 0x1A, 0x24, 0x1A, 0xC4, 0x0A, 0x17, 0x6D, 0x00, 0x2F, 0x06, + 0x7C, 0xBA, 0x60, 0x0C, 0x1E, 0x14, 0x0E, 0x04, 0x50, 0x03, 0x4E, 0x20, + 0x80, 0x14, 0x78, 0xF4, 0x0B, 0x48, 0xE0, 0x2D, 0xE1, 0x1B, 0x48, 0xE0, + 0x1A, 0xEF, 0x3E, 0xE4, 0x2D, 0xFE, 0x0B, 0x45, 0x0B, 0x60, 0xBC, 0xE6, + 0x18, 0xCB, 0xDA, 0x79, 0x22, 0x7C, 0x6B, 0x6C, 0xAA, 0xE4, 0xBE, 0x60, + 0x18, 0x50, 0x48, 0xBE, 0x60, 0x15, 0x40, 0x0E, 0x7E, 0xA3, 0x3B, 0x6A, + 0x0A, 0x36, 0x9E, 0x34, 0x00, 0x15, 0x7C, 0xB7, 0x80, 0x35, 0xBE, 0x60, + 0x0D, 0x40, 0x0E, 0x7E, 0xA3, 0x3B, 0x4F, 0x0A, 0x36, 0x9E, 0x34, 0x00, + 0x0D, 0x7C, 0xB7, 0x80, 0x22, 0xBE, 0x60, 0x09, 0x40, 0x0E, 0x7E, 0xA3, + 0x39, 0x2D, 0x0A, 0x36, 0x9E, 0x34, 0x00, 0x09, 0x7C, 0xB7, 0x80, 0x0F, + 0xBE, 0x60, 0x01, 0x40, 0x0A, 0x7E, 0xA3, 0x39, 0x2C, 0x0A, 0x36, 0x1B, + 0x34, 0x7C, 0xB7, 0x60, 0x05, 0x1E, 0xA0, 0x14, 0x78, 0xFB, 0x7C, 0xBA, + 0x13, 0x22, 0x7D, 0x40, 0x7D, 0xC1, 0x7D, 0x52, 0x7D, 0xD3, 0xBD, 0xD2, + 0x58, 0x04, 0xBD, 0xC5, 0x48, 0x08, 0xBD, 0xD5, 0x08, 0x07, 0xBD, 0xC5, + 0x08, 0x03, 0x7D, 0x35, 0x22, 0x0E, 0x44, 0x0E, 0x44, 0xBE, 0x44, 0x00, + 0x20, 0x08, 0x03, 0x7D, 0x3D, 0x22, 0x7D, 0xB4, 0x1A, 0x38, 0x1A, 0xA6, + 0x7E, 0x08, 0x00, 0x20, 0x9F, 0x05, 0x7D, 0x35, 0x1A, 0x26, 0x1A, 0x24, + 0x12, 0x8C, 0xBA, 0x7F, 0x71, 0x7D, 0x3D, 0x1A, 0x26, 0x1A, 0x24, 0x7F, + 0x05, 0x12, 0x8C, 0xBA, 0x2F, 0x17, 0x74, 0x05, 0x1E, 0x34, 0x0E, 0x24, + 0x50, 0x03, 0x4E, 0x60, 0x80, 0x14, 0x78, 0xF4, 0x22, 0xCA, 0x3B, 0x7A, + 0xB3, 0x37, 0x49, 0x7F, 0x31, 0x7A, 0x0F, 0x37, 0x45, 0xE4, 0x80, 0x3A, + 0xE4, 0x80, 0x24, 0x7E, 0x3B, 0x70, 0xBE, 0x70, 0x00, 0x58, 0x15, 0x7E, + 0x0F, 0x37, 0x45, 0x7E, 0xB3, 0x37, 0x4A, 0x7E, 0x73, 0x37, 0x4B, 0x7E, + 0x63, 0x37, 0x4C, 0x6D, 0x22, 0x12, 0xDF, 0xF7, 0x0B, 0x74, 0x7E, 0xB3, + 0x37, 0x4C, 0x04, 0x7A, 0xB3, 0x37, 0x4C, 0x7E, 0x73, 0x0E, 0x7D, 0xBE, + 0x73, 0x37, 0x4C, 0x38, 0xCE, 0x7E, 0xB3, 0x37, 0x4B, 0x04, 0x7A, 0xB3, + 0x37, 0x4B, 0x7E, 0x73, 0x37, 0x49, 0xBE, 0x73, 0x37, 0x4B, 0x38, 0xB8, + 0xDA, 0x3B, 0x22, 0x7D, 0x02, 0x7E, 0x63, 0x39, 0x46, 0x0A, 0x26, 0x19, + 0x72, 0x39, 0x5B, 0x60, 0x0F, 0x7E, 0x70, 0x02, 0x7C, 0xB6, 0xAC, 0xB7, + 0x59, 0x05, 0x39, 0x97, 0x59, 0x15, 0x39, 0xC1, 0x7E, 0x44, 0x00, 0x01, + 0x7E, 0xB3, 0x39, 0x46, 0x7E, 0x70, 0x02, 0xAC, 0xB7, 0x59, 0x45, 0x39, + 0xEB, 0x7E, 0x44, 0x7F, 0xFF, 0x7E, 0x73, 0x39, 0x46, 0x5E, 0x70, 0x01, + 0x74, 0x02, 0xAC, 0xB7, 0x59, 0x45, 0x3A, 0x15, 0x7E, 0xB3, 0x39, 0x46, + 0x04, 0x7A, 0xB3, 0x39, 0x46, 0x7E, 0x73, 0x39, 0x46, 0xBE, 0x70, 0x14, + 0x28, 0x06, 0x74, 0x34, 0x7A, 0xB3, 0x39, 0x2B, 0x22, 0x6C, 0xAA, 0xE5, + 0x46, 0x14, 0x68, 0x1A, 0x14, 0x68, 0x27, 0x14, 0x68, 0x34, 0x24, 0x03, + 0x78, 0x3E, 0x7E, 0x34, 0x2E, 0x53, 0x7E, 0x24, 0x00, 0x00, 0x7E, 0x1B, + 0xA0, 0x5E, 0xA0, 0x01, 0x80, 0x2E, 0x7E, 0x34, 0x2E, 0x53, 0x7E, 0x24, + 0x00, 0x00, 0x7E, 0x1B, 0xA0, 0x5E, 0xA0, 0x02, 0x80, 0x1E, 0x7E, 0x34, + 0x2E, 0x53, 0x7E, 0x24, 0x00, 0x00, 0x7E, 0x1B, 0xA0, 0x5E, 0xA0, 0x04, + 0x80, 0x0E, 0x7E, 0x34, 0x2E, 0x53, 0x7E, 0x24, 0x00, 0x00, 0x7E, 0x1B, + 0xA0, 0x5E, 0xA0, 0x08, 0x4C, 0xAA, 0x68, 0x04, 0x74, 0x01, 0x80, 0x01, + 0xE4, 0x22, 0x6C, 0xAA, 0xE5, 0x46, 0x14, 0x68, 0x1A, 0x14, 0x68, 0x27, + 0x14, 0x68, 0x34, 0x24, 0x03, 0x78, 0x3E, 0x7E, 0x34, 0x2E, 0x53, 0x7E, + 0x24, 0x00, 0x00, 0x7E, 0x1B, 0xA0, 0x5E, 0xA0, 0x10, 0x80, 0x2E, 0x7E, + 0x34, 0x2E, 0x53, 0x7E, 0x24, 0x00, 0x00, 0x7E, 0x1B, 0xA0, 0x5E, 0xA0, + 0x20, 0x80, 0x1E, 0x7E, 0x34, 0x2E, 0x53, 0x7E, 0x24, 0x00, 0x00, 0x7E, + 0x1B, 0xA0, 0x5E, 0xA0, 0x40, 0x80, 0x0E, 0x7E, 0x34, 0x2E, 0x53, 0x7E, + 0x24, 0x00, 0x00, 0x7E, 0x1B, 0xA0, 0x5E, 0xA0, 0x80, 0x4C, 0xAA, 0x68, + 0x04, 0x74, 0x01, 0x80, 0x01, 0xE4, 0x22, 0x7E, 0x73, 0x2D, 0x0B, 0xBE, + 0x73, 0x2C, 0x94, 0x68, 0x24, 0x7A, 0x73, 0x2C, 0x94, 0x7E, 0x34, 0x7F, + 0xFF, 0x7A, 0x37, 0x2C, 0x95, 0x7E, 0x34, 0x7F, 0xFF, 0x7A, 0x37, 0x2C, + 0x97, 0x7E, 0x34, 0x7F, 0xFF, 0x7A, 0x37, 0x2C, 0x99, 0x7E, 0x34, 0x7F, + 0xFF, 0x7A, 0x37, 0x2C, 0x9B, 0x12, 0xEB, 0xA8, 0x7E, 0x47, 0x2C, 0x92, + 0x7E, 0xB3, 0x2C, 0x88, 0x7E, 0x70, 0x02, 0xAC, 0xB7, 0x59, 0x45, 0x2C, + 0x95, 0x7E, 0x47, 0x2C, 0xD2, 0x7E, 0xB3, 0x2C, 0x88, 0x7E, 0x70, 0x02, + 0xAC, 0xB7, 0x59, 0x45, 0x2C, 0xD4, 0x12, 0xEE, 0x83, 0x22, 0x7D, 0x03, + 0xE5, 0x46, 0x0A, 0x2B, 0x7E, 0x34, 0x01, 0x80, 0xAD, 0x32, 0x7D, 0x13, + 0x2E, 0x14, 0x12, 0xF1, 0x6D, 0x44, 0x80, 0x37, 0x6D, 0x33, 0x80, 0x17, + 0x7D, 0x53, 0x3E, 0x54, 0x7D, 0x25, 0x2D, 0x21, 0x0B, 0x28, 0xF0, 0x2D, + 0x50, 0x0B, 0x58, 0x20, 0x9D, 0x2F, 0x1B, 0x58, 0x20, 0x0B, 0x34, 0xE5, + 0x5F, 0x0A, 0x2B, 0xBD, 0x23, 0x38, 0xE1, 0x7E, 0x51, 0x5F, 0x74, 0x02, + 0xAC, 0xB5, 0x2D, 0x15, 0x7E, 0x51, 0x5F, 0x74, 0x02, 0xAC, 0xB5, 0x2D, + 0x05, 0x0B, 0x44, 0xE5, 0x43, 0x0A, 0x2B, 0xBD, 0x24, 0x38, 0xC1, 0x22, + 0x7E, 0x47, 0x12, 0xE9, 0x09, 0x74, 0x00, 0x02, 0x7C, 0x67, 0x1E, 0x60, + 0x5E, 0x60, 0x01, 0xA2, 0x08, 0xE4, 0x33, 0xBC, 0xB6, 0x68, 0x15, 0x2E, + 0x60, 0xFF, 0x92, 0x08, 0x30, 0x09, 0x01, 0xB3, 0x50, 0x0A, 0x7E, 0xB3, + 0x28, 0x1D, 0x44, 0x08, 0x7A, 0xB3, 0x28, 0x1D, 0x30, 0x13, 0x25, 0x7E, + 0xA3, 0x28, 0x1D, 0x0A, 0x2A, 0x5E, 0x24, 0xFF, 0xEF, 0x78, 0x19, 0x7C, + 0xB7, 0xC4, 0x03, 0x7C, 0x7B, 0x5E, 0x70, 0x01, 0xA2, 0x0F, 0xE4, 0x33, + 0xBC, 0x7B, 0x68, 0x08, 0x7C, 0xBA, 0x44, 0x10, 0x7A, 0xB3, 0x28, 0x1D, + 0x22, 0x7C, 0xAB, 0x7D, 0x23, 0x7E, 0x34, 0x0D, 0xD1, 0xA2, 0x26, 0xE4, + 0x33, 0x7C, 0x3B, 0x4C, 0xAA, 0x68, 0x42, 0xA5, 0xBB, 0x00, 0x0A, 0x7E, + 0x39, 0xB0, 0xB4, 0x20, 0x04, 0xE4, 0x7A, 0x39, 0xB0, 0x7E, 0x39, 0x20, + 0x7C, 0xB2, 0x54, 0xF0, 0x78, 0x23, 0x7E, 0x29, 0xB0, 0x60, 0x11, 0xB4, + 0x03, 0x07, 0x74, 0x08, 0x7A, 0x39, 0xB0, 0x80, 0x14, 0x74, 0x02, 0x7A, + 0x39, 0xB0, 0x80, 0x0D, 0x0A, 0x02, 0x5E, 0x04, 0x00, 0x0B, 0x68, 0x05, + 0x74, 0x20, 0x7A, 0x39, 0xB0, 0x0B, 0x34, 0x0B, 0x24, 0x1B, 0xA0, 0x78, + 0xBE, 0x22, 0x7C, 0xA4, 0x7C, 0x95, 0x7D, 0x03, 0x09, 0x80, 0x00, 0x04, + 0x0A, 0x38, 0x0A, 0xE2, 0x9D, 0x3E, 0xBE, 0x34, 0x00, 0x00, 0x58, 0x02, + 0x6D, 0x33, 0x09, 0x60, 0x00, 0x05, 0x0A, 0x26, 0x0A, 0xF2, 0x2D, 0x2F, + 0x7C, 0x65, 0x09, 0x20, 0x00, 0x06, 0x0A, 0x22, 0x9D, 0x2E, 0xBE, 0x24, + 0x00, 0x00, 0x58, 0x02, 0x6D, 0x22, 0x7C, 0x25, 0x09, 0x80, 0x00, 0x07, + 0x0A, 0x28, 0x2D, 0x2F, 0x7C, 0x85, 0xBC, 0x6B, 0x40, 0x0F, 0xBC, 0x79, + 0x38, 0x0B, 0xBC, 0x8A, 0x40, 0x07, 0xBC, 0x23, 0x38, 0x03, 0x74, 0x01, + 0x22, 0xE4, 0x22, 0xCA, 0xD8, 0xCA, 0x79, 0x7D, 0x41, 0x7D, 0x12, 0x7D, + 0x03, 0x7E, 0x34, 0xFF, 0xFF, 0x7D, 0x23, 0x6C, 0xEE, 0x80, 0x2B, 0x74, + 0x02, 0xAC, 0xBE, 0x49, 0xF5, 0x2D, 0x16, 0x0A, 0x5E, 0x09, 0xD5, 0x2C, + 0xC4, 0xBE, 0xD0, 0xFF, 0x78, 0x08, 0xBD, 0xF2, 0x50, 0x04, 0x7D, 0x2F, + 0x7C, 0xFE, 0xBE, 0xD0, 0x10, 0x68, 0x09, 0xBD, 0xF3, 0x50, 0x05, 0x7D, + 0x3F, 0x7A, 0x49, 0xE0, 0x0B, 0xE0, 0x7E, 0xB3, 0x2D, 0x02, 0xBC, 0xBE, + 0x38, 0xCD, 0x1B, 0x08, 0x20, 0x1B, 0x18, 0x30, 0x7C, 0xBF, 0xDA, 0x79, + 0xDA, 0xD8, 0x22, 0x29, 0x70, 0x00, 0x14, 0x0A, 0x37, 0x09, 0x73, 0x37, + 0x18, 0x7A, 0x73, 0x2E, 0x5A, 0x29, 0x70, 0x00, 0x14, 0x09, 0x73, 0x37, + 0x1B, 0x7A, 0x73, 0x2E, 0x5B, 0x7E, 0x0B, 0x70, 0xBE, 0x73, 0x2E, 0x59, + 0x68, 0x30, 0x7A, 0x73, 0x2E, 0x59, 0x29, 0xB0, 0x00, 0x01, 0x70, 0x0C, + 0x7E, 0x73, 0x37, 0x1E, 0xBE, 0x73, 0x2E, 0x5C, 0x50, 0x10, 0x80, 0x0A, + 0x7E, 0x73, 0x37, 0x1F, 0xBE, 0x73, 0x2E, 0x5C, 0x50, 0x04, 0x7A, 0x73, + 0x2E, 0x5C, 0x7E, 0x08, 0x2E, 0x5D, 0xE4, 0x7E, 0x34, 0x00, 0x04, 0x02, + 0xF2, 0x33, 0x22, 0x7E, 0xB3, 0x05, 0x25, 0x30, 0xE7, 0x06, 0x7E, 0xB3, + 0x05, 0x27, 0x80, 0x04, 0x7E, 0xB3, 0x04, 0x6F, 0x12, 0xE5, 0x22, 0x7E, + 0x73, 0x05, 0x28, 0x4C, 0x77, 0x68, 0x1A, 0x7E, 0x24, 0x01, 0x05, 0x7A, + 0x27, 0xFF, 0x66, 0x7E, 0x24, 0x1F, 0x01, 0x7A, 0x27, 0xFF, 0x68, 0x0A, + 0x27, 0x7C, 0x67, 0x6C, 0x77, 0x4D, 0x32, 0x80, 0x17, 0x7E, 0x73, 0x03, + 0xFD, 0x0A, 0x37, 0x7A, 0x37, 0xFF, 0x66, 0x7E, 0x63, 0x03, 0xFE, 0x7E, + 0x70, 0x01, 0x7A, 0x37, 0xFF, 0x68, 0x6D, 0x33, 0x7A, 0x37, 0xFF, 0x6A, + 0x22, 0xCA, 0xF8, 0x7C, 0x36, 0x7C, 0x27, 0x7C, 0xFB, 0x6D, 0x00, 0x7A, + 0x07, 0x2B, 0xB5, 0xA2, 0x0F, 0xE4, 0x33, 0x0A, 0x5B, 0x5E, 0x54, 0x00, + 0x01, 0xC4, 0x54, 0xF0, 0x7C, 0xAB, 0xE4, 0x6D, 0x00, 0x4D, 0x05, 0x7A, + 0x07, 0x2B, 0xB5, 0x0A, 0x3F, 0x5E, 0x34, 0x00, 0x07, 0x7C, 0x67, 0x6C, + 0x77, 0x7E, 0x07, 0x2B, 0xB5, 0x5E, 0x00, 0xF8, 0x4D, 0x03, 0x7A, 0x07, + 0x2B, 0xB5, 0x30, 0x0F, 0x03, 0x30, 0x01, 0x00, 0xE4, 0x7C, 0x72, 0x7C, + 0x63, 0x12, 0xE7, 0xF8, 0x7A, 0xF1, 0x5B, 0xDA, 0xF8, 0x22, 0xCA, 0x3B, + 0x7F, 0x30, 0x30, 0x0F, 0x08, 0x74, 0x05, 0x7A, 0xB3, 0x2C, 0x59, 0x80, + 0x2D, 0x30, 0x0C, 0x2A, 0x30, 0x0D, 0x1B, 0x30, 0x2F, 0x0A, 0x12, 0xF5, + 0xB7, 0x70, 0x05, 0xE4, 0x7A, 0xB3, 0x2C, 0x59, 0x12, 0xF5, 0xB7, 0xBE, + 0xB0, 0x00, 0x28, 0x03, 0xD3, 0x80, 0x01, 0xC3, 0x92, 0x2F, 0x7E, 0xB3, + 0x2C, 0x59, 0x70, 0x06, 0x12, 0xD1, 0x5E, 0xE4, 0x80, 0x12, 0x12, 0x7C, + 0x6B, 0xD2, 0x44, 0x12, 0xF5, 0xCB, 0x12, 0xF5, 0x64, 0x7F, 0x03, 0x12, + 0xB6, 0x5F, 0x74, 0x01, 0xDA, 0x3B, 0x22, 0x6C, 0xAA, 0x7E, 0x73, 0x03, + 0xBF, 0xA5, 0xBF, 0x01, 0x10, 0x7E, 0x27, 0x03, 0xB0, 0x4D, 0x22, 0x78, + 0x05, 0x7E, 0xA0, 0x01, 0x80, 0x03, 0x7E, 0xA0, 0x80, 0xA5, 0xBF, 0x02, + 0x03, 0x4E, 0xA0, 0x40, 0x7E, 0xB3, 0x03, 0xDD, 0x60, 0x03, 0x4E, 0xA0, + 0x02, 0x7E, 0xB3, 0x03, 0xDE, 0x60, 0x03, 0x4E, 0xA0, 0x04, 0x7E, 0xB3, + 0x03, 0xDF, 0x60, 0x03, 0x4E, 0xA0, 0x08, 0x7E, 0xB3, 0x03, 0xCF, 0x60, + 0x03, 0x4E, 0xA0, 0x10, 0x7E, 0xB3, 0x03, 0xCD, 0x60, 0x03, 0x4E, 0xA0, + 0x20, 0x7C, 0xBA, 0x22, 0x7E, 0xB3, 0x2C, 0x5E, 0x70, 0x47, 0x7E, 0x37, + 0x2D, 0xD7, 0x7E, 0x39, 0x50, 0x7E, 0x37, 0x12, 0xE9, 0x7A, 0x39, 0x50, + 0x7E, 0x37, 0x2D, 0xD9, 0x2E, 0x34, 0x00, 0x03, 0x0B, 0x38, 0x30, 0x7E, + 0x27, 0x12, 0xE9, 0x59, 0x32, 0x00, 0x05, 0x7E, 0x37, 0x2D, 0xD9, 0x2E, + 0x34, 0x00, 0x05, 0x0B, 0x38, 0x30, 0x7E, 0x27, 0x12, 0xE9, 0x59, 0x32, + 0x00, 0x07, 0x7E, 0x37, 0x2D, 0xD9, 0x2E, 0x34, 0x00, 0x07, 0x7E, 0x39, + 0x70, 0x7E, 0x27, 0x12, 0xE9, 0x19, 0x72, 0x00, 0x09, 0x22, 0xA2, 0x17, + 0xE4, 0x33, 0x78, 0x06, 0x6D, 0x33, 0x7A, 0x37, 0xF1, 0x62, 0x30, 0x34, + 0x04, 0xD2, 0x36, 0x80, 0x3A, 0x30, 0x35, 0x28, 0x7E, 0x73, 0x18, 0xF3, + 0x0A, 0x37, 0x2E, 0x37, 0x2D, 0xE3, 0x2E, 0x34, 0x00, 0x0B, 0x7E, 0x39, + 0xB0, 0x6C, 0x77, 0x12, 0xEE, 0xC6, 0x7E, 0xA3, 0x18, 0xF3, 0x7C, 0xBA, + 0x04, 0x7A, 0xB3, 0x18, 0xF3, 0x7C, 0xBA, 0x12, 0x89, 0x8F, 0xC2, 0x35, + 0x7E, 0x37, 0xF0, 0x20, 0x5E, 0x60, 0xFB, 0x7A, 0x37, 0xF0, 0x20, 0xE4, + 0x12, 0xCB, 0xA2, 0x22, 0x7E, 0x34, 0x00, 0x08, 0xE5, 0x4E, 0x0A, 0x2B, + 0x2E, 0x25, 0x4A, 0xBE, 0x24, 0x00, 0xF8, 0x78, 0x08, 0x7E, 0xB3, 0x12, + 0xE0, 0xF5, 0xDE, 0x80, 0x2E, 0xBE, 0x24, 0x01, 0x10, 0x40, 0x14, 0xBE, + 0x24, 0x01, 0x2F, 0x38, 0x0E, 0x7D, 0x12, 0x9E, 0x14, 0x01, 0x10, 0x09, + 0xB1, 0x2E, 0x33, 0xF5, 0xDE, 0x80, 0x14, 0xBE, 0x24, 0x01, 0xBC, 0x38, + 0x0B, 0x2E, 0x27, 0x12, 0xE9, 0x7E, 0x29, 0xB0, 0xF5, 0xDE, 0x80, 0x03, + 0x75, 0xDE, 0x00, 0x05, 0x4E, 0x1B, 0x34, 0x78, 0xB7, 0x22, 0x7C, 0xAB, + 0xE5, 0x46, 0x14, 0x68, 0x0F, 0x14, 0x68, 0x11, 0x14, 0x68, 0x13, 0x24, + 0x03, 0x78, 0x12, 0x7E, 0x60, 0x01, 0x80, 0x0D, 0x7E, 0x60, 0x02, 0x80, + 0x08, 0x7E, 0x60, 0x04, 0x80, 0x03, 0x7E, 0x60, 0x08, 0x4C, 0xAA, 0x68, + 0x12, 0x7E, 0x14, 0x2E, 0x53, 0x7E, 0x04, 0x00, 0x00, 0x7E, 0x0B, 0x70, + 0x4C, 0x76, 0x7A, 0x0B, 0x70, 0x80, 0x14, 0x7C, 0xB6, 0x64, 0xFF, 0x7E, + 0x14, 0x2E, 0x53, 0x7E, 0x04, 0x00, 0x00, 0x7E, 0x0B, 0x70, 0x5C, 0x7B, + 0x7A, 0x0B, 0x70, 0x22, 0x7C, 0xAB, 0xE5, 0x46, 0x14, 0x68, 0x0F, 0x14, + 0x68, 0x11, 0x14, 0x68, 0x13, 0x24, 0x03, 0x78, 0x12, 0x7E, 0x60, 0x10, + 0x80, 0x0D, 0x7E, 0x60, 0x20, 0x80, 0x08, 0x7E, 0x60, 0x40, 0x80, 0x03, + 0x7E, 0x60, 0x80, 0x4C, 0xAA, 0x68, 0x12, 0x7E, 0x14, 0x2E, 0x53, 0x7E, + 0x04, 0x00, 0x00, 0x7E, 0x0B, 0x70, 0x4C, 0x76, 0x7A, 0x0B, 0x70, 0x80, + 0x14, 0x7C, 0xB6, 0x64, 0xFF, 0x7E, 0x14, 0x2E, 0x53, 0x7E, 0x04, 0x00, + 0x00, 0x7E, 0x0B, 0x70, 0x5C, 0x7B, 0x7A, 0x0B, 0x70, 0x22, 0x7C, 0x3B, + 0x7D, 0x03, 0x7E, 0x34, 0xC0, 0x00, 0x1A, 0x54, 0x2D, 0x35, 0x7C, 0x25, + 0x7E, 0x43, 0x03, 0xE5, 0xA5, 0xBB, 0x00, 0x06, 0x7E, 0x43, 0x03, 0xE6, + 0x80, 0x12, 0x7E, 0x53, 0x05, 0x1B, 0x0A, 0x45, 0x1B, 0x44, 0x1A, 0x53, + 0xBD, 0x54, 0x78, 0x04, 0x7E, 0x43, 0x03, 0xE7, 0x7E, 0x53, 0x03, 0xE8, + 0x1A, 0x12, 0x7A, 0x17, 0xFF, 0x52, 0x7A, 0x27, 0xFF, 0x54, 0x7A, 0x37, + 0xFF, 0x56, 0x7E, 0x17, 0x03, 0xE3, 0x7A, 0x17, 0xFF, 0x58, 0x7A, 0x07, + 0xFF, 0x50, 0x22, 0x7C, 0xAB, 0xA2, 0xEB, 0xE4, 0x33, 0x7C, 0x7B, 0xC2, + 0xEB, 0x6C, 0x66, 0x4C, 0xAA, 0x68, 0x11, 0x7E, 0x17, 0x2D, 0xED, 0x0B, + 0x16, 0x0B, 0x18, 0x20, 0x4E, 0x40, 0x02, 0x1B, 0x18, 0x20, 0x80, 0x0F, + 0x7E, 0x17, 0x2D, 0xED, 0x0B, 0x16, 0x0B, 0x18, 0x20, 0x5E, 0x40, 0xFD, + 0x1B, 0x18, 0x20, 0x6C, 0x66, 0x7E, 0x27, 0x2D, 0xED, 0x0B, 0x26, 0x0B, + 0x28, 0x20, 0x7A, 0x27, 0xF0, 0x04, 0x0B, 0x60, 0xBE, 0x60, 0x1E, 0x40, + 0xEC, 0x2E, 0x70, 0xFF, 0x92, 0xEB, 0x22, 0x7E, 0x73, 0x04, 0x2F, 0x0A, + 0x37, 0x4D, 0x33, 0x68, 0x0F, 0x6E, 0x34, 0xFF, 0xFF, 0x0B, 0x34, 0xBE, + 0x37, 0x03, 0xDB, 0x08, 0x03, 0x74, 0x01, 0x22, 0x7E, 0xB3, 0x05, 0x19, + 0x60, 0x15, 0x7E, 0x73, 0x03, 0xBD, 0xBE, 0x70, 0x0A, 0x38, 0x03, 0x74, + 0x01, 0x22, 0x7E, 0xB3, 0x04, 0x09, 0x60, 0x03, 0x74, 0x01, 0x22, 0x7E, + 0x73, 0x03, 0xBC, 0xBE, 0x70, 0x0A, 0x28, 0x09, 0x7E, 0x73, 0x03, 0xC3, + 0xBE, 0x70, 0x00, 0x28, 0x04, 0x74, 0x01, 0x80, 0x01, 0xE4, 0x22, 0x7D, + 0x13, 0x7E, 0x73, 0x05, 0x1B, 0x0A, 0x07, 0x1B, 0x04, 0x7C, 0x01, 0x6C, + 0x11, 0x7E, 0x73, 0x05, 0x1A, 0x0A, 0x37, 0x1B, 0x34, 0x7C, 0x67, 0x6C, + 0x77, 0x7E, 0xB3, 0x05, 0x16, 0x70, 0x06, 0x7D, 0x50, 0x7D, 0x03, 0x7D, + 0x35, 0x7E, 0xB3, 0x04, 0x62, 0x1A, 0x4B, 0x7E, 0xB3, 0x04, 0x63, 0x1A, + 0x5B, 0x9D, 0x04, 0x9D, 0x35, 0xBD, 0x41, 0x18, 0x0C, 0xBD, 0x52, 0x18, + 0x08, 0xBD, 0x01, 0x48, 0x04, 0xBD, 0x32, 0x58, 0x03, 0x74, 0x01, 0x22, + 0xE4, 0x22, 0x7E, 0xA3, 0x05, 0x1A, 0x7A, 0xA3, 0x0E, 0x7E, 0x7E, 0xB3, + 0x05, 0x1B, 0x7A, 0xB3, 0x0E, 0x7D, 0x74, 0x01, 0x7A, 0xB3, 0x0E, 0x7C, + 0x7A, 0xA3, 0x0E, 0x7B, 0xE4, 0x7A, 0xB3, 0x37, 0x4D, 0x7E, 0x17, 0x03, + 0x10, 0x6D, 0x00, 0x7E, 0x18, 0x04, 0x90, 0x74, 0x02, 0x12, 0x01, 0x9C, + 0x7E, 0x73, 0x0E, 0x7E, 0x0A, 0x37, 0x1B, 0x35, 0x7A, 0x73, 0x37, 0x4D, + 0x7E, 0x17, 0x03, 0x10, 0x6D, 0x00, 0x7E, 0x18, 0xC0, 0x20, 0x74, 0x02, + 0x02, 0x01, 0x9C, 0xE4, 0x7A, 0xB3, 0x03, 0xE1, 0x6D, 0x33, 0x6C, 0xAA, + 0x1A, 0x2A, 0x09, 0x52, 0x07, 0x27, 0xA5, 0xBD, 0x01, 0x08, 0x74, 0x01, + 0x7A, 0xB3, 0x03, 0xDF, 0x80, 0x0A, 0xA5, 0xBD, 0x02, 0x06, 0x74, 0x01, + 0x7A, 0xB3, 0x03, 0xDE, 0xBE, 0x50, 0x01, 0x28, 0x16, 0xBE, 0x50, 0x05, + 0x50, 0x11, 0x1A, 0x1A, 0x09, 0xB1, 0x08, 0x49, 0x30, 0xE6, 0x06, 0x74, + 0x01, 0x7A, 0xB3, 0x03, 0xE1, 0x0B, 0x34, 0x0B, 0xA0, 0xBE, 0xA0, 0x0A, + 0x48, 0xC2, 0x22, 0x7A, 0x37, 0x39, 0x35, 0x7A, 0x27, 0x39, 0x37, 0x7E, + 0x37, 0x39, 0x35, 0x7E, 0x27, 0x39, 0x39, 0x12, 0xF4, 0x7C, 0x7A, 0x37, + 0x39, 0x39, 0x7E, 0x37, 0x39, 0x37, 0x7E, 0x27, 0x39, 0x3B, 0x12, 0xF4, + 0x7C, 0x7A, 0x37, 0x39, 0x3B, 0x7E, 0x37, 0x39, 0x35, 0x7E, 0x27, 0x39, + 0x3D, 0x12, 0xF4, 0x89, 0x7A, 0x37, 0x39, 0x3D, 0x7E, 0x37, 0x39, 0x37, + 0x7E, 0x27, 0x39, 0x3F, 0x12, 0xF4, 0x89, 0x7A, 0x37, 0x39, 0x3F, 0x12, + 0x8F, 0x64, 0x22, 0x7E, 0x44, 0x3A, 0x7C, 0x09, 0xB4, 0x00, 0x04, 0x09, + 0xA4, 0x00, 0x01, 0x2C, 0xBA, 0xBE, 0xB0, 0x10, 0x40, 0x03, 0xE4, 0x80, + 0x2F, 0x19, 0xB4, 0x00, 0x04, 0x09, 0xA4, 0x00, 0x06, 0xA4, 0x2E, 0x54, + 0x00, 0x08, 0x1E, 0x54, 0x1E, 0x54, 0x1E, 0x54, 0x1E, 0x54, 0x7C, 0xAB, + 0x09, 0xB4, 0x00, 0x05, 0x19, 0xA4, 0x00, 0x05, 0x0A, 0x3A, 0x1B, 0x35, + 0x7C, 0xA7, 0x9C, 0xAB, 0x74, 0x01, 0x19, 0xB4, 0x00, 0x03, 0x7C, 0xBA, + 0x22, 0x7E, 0x73, 0x39, 0x2B, 0xBE, 0x70, 0x00, 0x28, 0x08, 0xBE, 0x70, + 0x20, 0x50, 0x03, 0xD3, 0x80, 0x34, 0x7E, 0x73, 0x3B, 0x54, 0xBE, 0x70, + 0x00, 0x28, 0x08, 0xBE, 0x70, 0x20, 0x50, 0x03, 0xD3, 0x80, 0x23, 0x7E, + 0x73, 0x3B, 0x77, 0xBE, 0x70, 0x00, 0x28, 0x08, 0xBE, 0x70, 0x20, 0x50, + 0x03, 0xD3, 0x80, 0x12, 0x7E, 0x73, 0x3B, 0x7A, 0xBE, 0x70, 0x00, 0x28, + 0x08, 0xBE, 0x70, 0x20, 0x38, 0x03, 0xD3, 0x80, 0x01, 0xC3, 0x22, 0xCA, + 0x79, 0x7D, 0x73, 0xE5, 0x4F, 0xBE, 0xB0, 0x00, 0x28, 0x34, 0x12, 0xEC, + 0xF4, 0x7E, 0x79, 0xB0, 0x04, 0x7A, 0x79, 0xB0, 0x7E, 0x79, 0x70, 0xBE, + 0x70, 0x04, 0x40, 0x04, 0xE4, 0x7A, 0x79, 0xB0, 0x7E, 0x79, 0x60, 0x7E, + 0x70, 0x7D, 0xAC, 0x67, 0x2E, 0x34, 0x28, 0x24, 0x7A, 0x37, 0x12, 0xDB, + 0x15, 0x4F, 0x7E, 0x37, 0xFF, 0xD0, 0x5E, 0x34, 0x00, 0x01, 0x78, 0xF6, + 0x80, 0x03, 0x12, 0xF4, 0x39, 0xDA, 0x79, 0x22, 0xCA, 0x3B, 0x7D, 0x72, + 0x7D, 0x63, 0x7E, 0x18, 0x37, 0x6F, 0x7A, 0x1F, 0x37, 0x71, 0x6C, 0x77, + 0x7E, 0x08, 0x37, 0x6D, 0x12, 0xE9, 0x84, 0x6C, 0x77, 0x7E, 0x27, 0x37, + 0x6D, 0x1B, 0x28, 0x60, 0x7E, 0x27, 0x37, 0x6D, 0x0B, 0x25, 0x7A, 0x27, + 0x37, 0x6D, 0x7E, 0x27, 0x37, 0x6F, 0x1B, 0x28, 0x70, 0x7E, 0x27, 0x37, + 0x6F, 0x0B, 0x25, 0x7A, 0x27, 0x37, 0x6F, 0x0B, 0x70, 0xBE, 0x70, 0x02, + 0x48, 0xD7, 0xDA, 0x3B, 0x22, 0x7C, 0x56, 0x7C, 0xA7, 0x7F, 0x70, 0x2C, + 0xAB, 0xBE, 0xA0, 0x00, 0x48, 0x35, 0x7E, 0x43, 0x0E, 0x7E, 0xBC, 0x4A, + 0x28, 0x2D, 0xBE, 0x50, 0x00, 0x48, 0x28, 0x7E, 0x43, 0x0E, 0x7D, 0xBC, + 0x45, 0x28, 0x20, 0x7E, 0x43, 0x0E, 0x7B, 0x0A, 0x14, 0x1A, 0x05, 0xAD, + 0x10, 0x7E, 0xB3, 0x0E, 0x7C, 0x0A, 0x3B, 0x1A, 0x2A, 0xAD, 0x32, 0x2D, + 0x31, 0x3E, 0x34, 0x2D, 0x3F, 0x7D, 0x2E, 0x0B, 0x1A, 0x30, 0x22, 0x6D, + 0x33, 0x22, 0xE4, 0x12, 0xEC, 0x53, 0x7E, 0xA3, 0x39, 0x46, 0x4C, 0xAA, + 0x78, 0x08, 0x74, 0x32, 0x7A, 0xB3, 0x39, 0x2B, 0x80, 0x30, 0xBE, 0xA0, + 0x01, 0x78, 0x08, 0x74, 0x33, 0x7A, 0xB3, 0x39, 0x2B, 0x80, 0x23, 0x12, + 0x64, 0x02, 0x7E, 0xB3, 0x39, 0x2B, 0xB4, 0x10, 0x19, 0x12, 0xBF, 0xB8, + 0xE4, 0x6C, 0x77, 0x12, 0x5B, 0x55, 0x74, 0x01, 0x7E, 0x70, 0x01, 0x12, + 0x5B, 0x55, 0x74, 0x02, 0x7E, 0x70, 0xFE, 0x12, 0x5B, 0x55, 0x22, 0x7D, + 0xF2, 0x7C, 0x57, 0x7F, 0x60, 0x2C, 0x5B, 0xBE, 0x50, 0x00, 0x48, 0x36, + 0x7E, 0x73, 0x0E, 0x7E, 0xBC, 0x75, 0x28, 0x2E, 0xBE, 0x60, 0x00, 0x48, + 0x29, 0x7E, 0x73, 0x0E, 0x7D, 0xBC, 0x76, 0x28, 0x21, 0x7E, 0x73, 0x0E, + 0x7B, 0x0A, 0x17, 0x1A, 0x06, 0xAD, 0x10, 0x7E, 0x43, 0x0E, 0x7C, 0x0A, + 0x34, 0x1A, 0x25, 0xAD, 0x32, 0x7D, 0xE3, 0x2D, 0xE1, 0x3E, 0xE4, 0x7F, + 0x16, 0x2D, 0x3E, 0x1B, 0x1A, 0xF0, 0x22, 0x7E, 0x27, 0x12, 0xE9, 0x09, + 0xA2, 0x00, 0xF1, 0x7C, 0xBA, 0x23, 0x23, 0x7C, 0x6B, 0x5E, 0x60, 0x01, + 0x7C, 0x7A, 0x1E, 0x70, 0x1E, 0x70, 0x5E, 0x70, 0x07, 0xA2, 0x00, 0xE4, + 0x33, 0xBC, 0xB6, 0x78, 0x06, 0xBE, 0x73, 0x12, 0xE2, 0x68, 0x13, 0x2E, + 0x60, 0xFF, 0x92, 0x00, 0x7A, 0x73, 0x12, 0xE2, 0x7E, 0xB3, 0x28, 0x1D, + 0x44, 0x01, 0x7A, 0xB3, 0x28, 0x1D, 0x7C, 0xBA, 0x54, 0x03, 0x12, 0xEA, + 0x10, 0x22, 0x7D, 0x43, 0x7C, 0xAB, 0x6C, 0x77, 0x6C, 0x66, 0xBE, 0xA0, + 0x00, 0x28, 0x2C, 0xBE, 0xA0, 0x10, 0x38, 0x27, 0xBE, 0xA0, 0x07, 0x78, + 0x04, 0x7E, 0x73, 0x0E, 0x2F, 0x0A, 0x2A, 0x09, 0x62, 0x0D, 0xBA, 0x1B, + 0xA0, 0x7E, 0x24, 0x00, 0x01, 0x7C, 0xBA, 0x60, 0x05, 0x3E, 0x24, 0x14, + 0x78, 0xFB, 0x5E, 0x27, 0x0D, 0xE9, 0x68, 0x03, 0x4E, 0x70, 0x80, 0x4D, + 0x44, 0x68, 0x03, 0x7A, 0x49, 0x60, 0x7C, 0xB7, 0x22, 0xA9, 0xD1, 0xEE, + 0x7E, 0x34, 0xF7, 0xD3, 0x7E, 0x24, 0x00, 0xFF, 0x0B, 0x1A, 0x30, 0x74, + 0x03, 0x12, 0xED, 0xAD, 0xA9, 0xC1, 0xEE, 0x7E, 0x34, 0xF7, 0xD3, 0x7E, + 0x24, 0x00, 0xFF, 0x0B, 0x1A, 0x30, 0x74, 0x03, 0x12, 0xED, 0xAD, 0xA9, + 0xD1, 0xEE, 0x7E, 0x34, 0xF7, 0xD3, 0x7E, 0x24, 0x00, 0xFF, 0x0B, 0x1A, + 0x30, 0x74, 0x03, 0x12, 0xED, 0xAD, 0x7E, 0x34, 0x00, 0x01, 0x7A, 0x37, + 0xF3, 0x04, 0x22, 0x7C, 0x57, 0x7C, 0xAB, 0xBE, 0xA0, 0x00, 0x28, 0x38, + 0xBE, 0xA0, 0x10, 0x38, 0x33, 0xBE, 0xA0, 0x07, 0x78, 0x08, 0x7C, 0xB5, + 0x54, 0x03, 0x7A, 0xB3, 0x0E, 0x30, 0x1B, 0xA0, 0x7E, 0x14, 0x00, 0x01, + 0x7C, 0xBA, 0x60, 0x05, 0x3E, 0x14, 0x14, 0x78, 0xFB, 0x7E, 0x37, 0x0D, + 0xF5, 0x7D, 0x01, 0x6E, 0x04, 0xFF, 0xFF, 0x5D, 0x30, 0x7C, 0xB5, 0x30, + 0xE7, 0x02, 0x4D, 0x31, 0x7A, 0x37, 0x0D, 0xF5, 0x22, 0xE4, 0x7A, 0xB3, + 0x18, 0xF3, 0x30, 0x17, 0x04, 0xE4, 0x12, 0x89, 0x8F, 0x7E, 0xB3, 0x18, + 0xF3, 0x04, 0x7A, 0xB3, 0x18, 0xF3, 0x7E, 0x34, 0x00, 0x04, 0x7A, 0x37, + 0xF1, 0x62, 0x7E, 0x37, 0xF0, 0x20, 0x4E, 0x60, 0x04, 0x7A, 0x37, 0xF0, + 0x20, 0x74, 0x01, 0x12, 0xCB, 0xA2, 0x30, 0x17, 0x07, 0x7E, 0xB3, 0x18, + 0xF3, 0x12, 0x89, 0x8F, 0x7E, 0xB3, 0x18, 0xF3, 0x04, 0x7A, 0xB3, 0x18, + 0xF3, 0x22, 0x7D, 0x12, 0x7C, 0xA7, 0x7E, 0x04, 0xC1, 0x50, 0x1A, 0x3B, + 0x3E, 0x34, 0x3E, 0x34, 0x3E, 0x34, 0x3E, 0x34, 0x2D, 0x03, 0xE4, 0x80, + 0x25, 0x09, 0x71, 0x00, 0x0C, 0x19, 0x70, 0x00, 0x0C, 0x09, 0x71, 0x00, + 0x0D, 0x19, 0x70, 0x00, 0x0D, 0x09, 0x71, 0x00, 0x0E, 0x19, 0x70, 0x00, + 0x0E, 0x09, 0x71, 0x00, 0x0F, 0x19, 0x70, 0x00, 0x0F, 0x2E, 0x04, 0x00, + 0x10, 0x04, 0xBC, 0xAB, 0x18, 0xD7, 0x22, 0x7C, 0xA7, 0x7F, 0x70, 0x7E, + 0x14, 0x06, 0xFC, 0x7E, 0x04, 0x00, 0x03, 0x7E, 0x44, 0x5A, 0x9D, 0x1B, + 0x0A, 0x40, 0x0B, 0x15, 0x7C, 0x6B, 0x6C, 0x77, 0x1B, 0x0A, 0x30, 0x0B, + 0x15, 0xE4, 0x80, 0x0B, 0x0B, 0x7A, 0x40, 0x1B, 0x0A, 0x40, 0x0B, 0x15, + 0x0B, 0xF5, 0x04, 0xBC, 0xAB, 0x38, 0xF1, 0x7E, 0x14, 0x06, 0xFE, 0x7E, + 0x04, 0x00, 0x03, 0x7E, 0x34, 0x00, 0xA5, 0x1B, 0x0A, 0x30, 0x22, 0xCA, + 0xF8, 0x7C, 0xFB, 0x74, 0xFF, 0x7A, 0xB3, 0x03, 0xBE, 0xE4, 0x7A, 0xB3, + 0x03, 0xBF, 0x74, 0xC8, 0x7A, 0xB3, 0x03, 0xBD, 0xE4, 0x7A, 0xB3, 0x04, + 0x09, 0x7A, 0xB3, 0x04, 0x0A, 0x7E, 0x34, 0x03, 0x02, 0x7E, 0x24, 0x00, + 0x0C, 0x12, 0xF2, 0xA4, 0x4C, 0xFF, 0x68, 0x10, 0xE4, 0x7A, 0xB3, 0x03, + 0xC0, 0x7E, 0x37, 0x03, 0x00, 0x7E, 0x24, 0x00, 0x0C, 0x12, 0xF2, 0xA4, + 0xDA, 0xF8, 0x22, 0xCA, 0xF8, 0x7C, 0xAB, 0x7D, 0x12, 0x7D, 0x03, 0x7E, + 0x70, 0x12, 0x0B, 0x18, 0x40, 0x7C, 0x69, 0x7C, 0x49, 0x6C, 0x55, 0x0A, + 0x49, 0x2D, 0x42, 0x7D, 0x20, 0x0B, 0x04, 0x6C, 0xFF, 0x80, 0x10, 0x7E, + 0x29, 0xB0, 0x54, 0x7F, 0xB4, 0x01, 0x02, 0x0B, 0x44, 0x2E, 0x24, 0x00, + 0x12, 0x0B, 0xF0, 0xBC, 0xAF, 0x18, 0xEC, 0x1B, 0x18, 0x40, 0x0B, 0x15, + 0x1B, 0x70, 0x78, 0xCE, 0xDA, 0xF8, 0x22, 0xCA, 0x3B, 0x7D, 0x73, 0x09, + 0xB7, 0x00, 0x02, 0x54, 0x80, 0x7D, 0x67, 0x2E, 0x64, 0x00, 0x03, 0x60, + 0x1B, 0x7E, 0x69, 0xB0, 0x7D, 0x36, 0x0B, 0x35, 0x12, 0xE0, 0x7E, 0x19, + 0xB6, 0x00, 0x01, 0x74, 0x05, 0x19, 0xB7, 0x00, 0x01, 0x74, 0x85, 0x7A, + 0x79, 0xB0, 0x80, 0x0D, 0x7E, 0x69, 0xB0, 0x09, 0x76, 0x00, 0x01, 0x12, + 0xE1, 0x03, 0xE4, 0x80, 0x02, 0x74, 0x01, 0xDA, 0x3B, 0x22, 0x7E, 0xB3, + 0x2C, 0x5E, 0x70, 0x38, 0x30, 0x0F, 0x1B, 0x30, 0x16, 0x0C, 0x74, 0x08, + 0x7E, 0x37, 0x12, 0xE9, 0x19, 0xB3, 0x00, 0x01, 0x80, 0x26, 0x74, 0x07, + 0x7E, 0x37, 0x12, 0xE9, 0x19, 0xB3, 0x00, 0x01, 0x80, 0x1A, 0xE5, 0x59, + 0xB4, 0x01, 0x0C, 0x74, 0x04, 0x7E, 0x37, 0x12, 0xE9, 0x19, 0xB3, 0x00, + 0x01, 0x80, 0x09, 0xE4, 0x7E, 0x37, 0x12, 0xE9, 0x19, 0xB3, 0x00, 0x01, + 0x22, 0x7C, 0xAB, 0x7E, 0xB3, 0x12, 0xDF, 0x30, 0xE7, 0x04, 0x54, 0x01, + 0x80, 0x2F, 0x1B, 0xA0, 0x68, 0x1B, 0x1B, 0xA0, 0x68, 0x09, 0x1B, 0xA0, + 0x68, 0x13, 0x2E, 0xA0, 0x03, 0x78, 0x1D, 0xA2, 0x25, 0xE4, 0x33, 0xB4, + 0x01, 0x04, 0x74, 0x01, 0x80, 0x01, 0xE4, 0x80, 0x10, 0x12, 0xF4, 0x6F, + 0xBE, 0xB0, 0x00, 0x28, 0x04, 0x74, 0x01, 0x80, 0x01, 0xE4, 0x80, 0x01, + 0xE4, 0x22, 0x7C, 0x7B, 0x1B, 0x70, 0x68, 0x1C, 0x1B, 0x70, 0x68, 0x1D, + 0x1B, 0x70, 0x68, 0x28, 0x2E, 0x70, 0x03, 0x78, 0x28, 0x12, 0xF5, 0xB7, + 0xBE, 0xB0, 0x00, 0x28, 0x04, 0x74, 0x01, 0x80, 0x01, 0xE4, 0x80, 0x1A, + 0x12, 0xD6, 0x7D, 0x80, 0x15, 0x12, 0xF5, 0xB7, 0xBE, 0xB0, 0x00, 0x28, + 0x04, 0x74, 0x01, 0x80, 0x01, 0xE4, 0x80, 0x06, 0x12, 0xD6, 0x7D, 0x80, + 0x01, 0xE4, 0x22, 0x7C, 0x5B, 0x6D, 0x33, 0x7A, 0x37, 0x37, 0x2F, 0x6D, + 0x33, 0x7A, 0x37, 0x37, 0x31, 0x4C, 0x55, 0x68, 0x0D, 0x7E, 0x34, 0x37, + 0x2F, 0x7E, 0x24, 0x37, 0x31, 0x12, 0xD3, 0x3E, 0x80, 0x0D, 0xE5, 0x5F, + 0x0A, 0x2B, 0x3E, 0x24, 0x7E, 0x34, 0x0E, 0x80, 0x12, 0xF2, 0x4B, 0x7E, + 0x37, 0x37, 0x2F, 0x7A, 0x37, 0x28, 0x1F, 0x7E, 0x37, 0x37, 0x31, 0x7A, + 0x37, 0x28, 0x19, 0x22, 0x7C, 0x5B, 0x7E, 0x44, 0xE0, 0x00, 0x74, 0x20, + 0xAC, 0xB5, 0x2D, 0x54, 0x49, 0x35, 0x00, 0x06, 0x5E, 0x60, 0x0F, 0x7D, + 0x53, 0x7C, 0xAB, 0xE4, 0x4D, 0x53, 0x7A, 0x57, 0xF2, 0x08, 0x74, 0x20, + 0xAC, 0xB5, 0x2D, 0x54, 0x49, 0x55, 0x00, 0x0E, 0x7A, 0x57, 0xF5, 0x14, + 0x7E, 0x70, 0x20, 0xAC, 0x75, 0x2D, 0x34, 0x49, 0x33, 0x00, 0x16, 0x7A, + 0x37, 0xF2, 0x2C, 0x22, 0x7D, 0x52, 0x7F, 0x70, 0x7D, 0x03, 0x7F, 0x17, + 0x6D, 0x11, 0x80, 0x2B, 0x7D, 0x41, 0x2D, 0x40, 0xBE, 0x44, 0x00, 0x03, + 0x68, 0x1F, 0xBE, 0x44, 0x00, 0x05, 0x40, 0x06, 0xBE, 0x44, 0x00, 0x0A, + 0x28, 0x13, 0x7D, 0xF1, 0x3E, 0xF4, 0x2D, 0xF3, 0x7D, 0xE2, 0x0B, 0x7A, + 0xF0, 0x7D, 0xE4, 0x3E, 0xE4, 0x59, 0xFE, 0xF0, 0x00, 0x0B, 0x14, 0xBD, + 0x51, 0x38, 0xD1, 0x22, 0x7C, 0xAB, 0x54, 0xF0, 0x78, 0x29, 0x30, 0x01, + 0x1B, 0x30, 0x0F, 0x0C, 0x74, 0x08, 0x7E, 0x37, 0x12, 0xE9, 0x19, 0xB3, + 0x00, 0x01, 0x80, 0x23, 0x74, 0x03, 0x7E, 0x37, 0x12, 0xE9, 0x19, 0xB3, + 0x00, 0x01, 0x80, 0x17, 0xE4, 0x7E, 0x37, 0x12, 0xE9, 0x19, 0xB3, 0x00, + 0x01, 0x80, 0x0C, 0x0A, 0x3A, 0x0B, 0x35, 0x7E, 0x27, 0x12, 0xE9, 0x19, + 0x72, 0x00, 0x01, 0x22, 0x6C, 0xAA, 0x7E, 0xB3, 0x04, 0x07, 0x30, 0xE0, + 0x04, 0x7E, 0xA3, 0x04, 0x2A, 0x7E, 0xB3, 0x04, 0x39, 0xC4, 0x54, 0x0F, + 0x7C, 0x7B, 0x6C, 0x66, 0x7C, 0x5A, 0x0A, 0x16, 0x09, 0xB1, 0x07, 0x27, + 0xB4, 0x01, 0x0B, 0x0A, 0x16, 0x09, 0xB1, 0x0A, 0xB5, 0x30, 0xE0, 0x02, + 0x2C, 0x57, 0x0A, 0x16, 0x19, 0x51, 0x0A, 0x4C, 0x0B, 0x60, 0xBE, 0x60, + 0x0A, 0x40, 0xDD, 0x22, 0x7C, 0x7B, 0xC2, 0xA8, 0xA9, 0xC7, 0xDA, 0xA9, + 0xD1, 0xA6, 0xA9, 0xC1, 0xA7, 0xA9, 0xD1, 0xA2, 0xA9, 0xC1, 0xA4, 0xA9, + 0xD2, 0xA6, 0xA9, 0xC2, 0xA7, 0xA9, 0xD2, 0xA2, 0xA9, 0xC2, 0xA4, 0x7A, + 0x71, 0xDA, 0x75, 0xDD, 0x04, 0xD2, 0x40, 0xC2, 0x45, 0xC2, 0x43, 0x75, + 0x4E, 0x00, 0x75, 0xDB, 0x00, 0x75, 0xC3, 0xFE, 0xA9, 0xD7, 0xDA, 0x43, + 0x53, 0x01, 0x22, 0xCA, 0xF8, 0x7E, 0xB3, 0x2D, 0x00, 0x60, 0x16, 0x6C, + 0xFF, 0x80, 0x0D, 0x74, 0x02, 0x7C, 0x7F, 0x7E, 0x24, 0x2C, 0xA8, 0x12, + 0xE8, 0x2B, 0x0B, 0xF0, 0xBE, 0xF1, 0x5E, 0x40, 0xEE, 0x7E, 0xB3, 0x2D, + 0x01, 0x60, 0x14, 0x6C, 0xFF, 0x74, 0x20, 0x7C, 0x7F, 0x7E, 0x24, 0x2C, + 0xE4, 0x12, 0xE8, 0x2B, 0x0B, 0xF0, 0xBE, 0xF0, 0x02, 0x78, 0xEE, 0xDA, + 0xF8, 0x22, 0x0A, 0x3B, 0x4D, 0x33, 0x78, 0x04, 0x7E, 0x34, 0x7F, 0xE1, + 0x7E, 0x24, 0x0E, 0xFF, 0x7A, 0x27, 0xFF, 0x12, 0x7E, 0x24, 0xF1, 0x01, + 0x7A, 0x27, 0xFF, 0x10, 0x7E, 0x24, 0xFF, 0xFE, 0x7A, 0x27, 0xFF, 0x22, + 0x6D, 0x11, 0x7A, 0x17, 0xFF, 0x24, 0x7A, 0x27, 0xFF, 0x26, 0x7A, 0x37, + 0xFF, 0x2A, 0x6E, 0x34, 0xFF, 0xFF, 0x0B, 0x34, 0x7A, 0x37, 0xFF, 0x28, + 0x22, 0x74, 0xFF, 0x7A, 0xB3, 0x2C, 0x78, 0x74, 0xFF, 0x7A, 0xB3, 0x2C, + 0x64, 0xE4, 0x7A, 0xB3, 0x2A, 0x18, 0x20, 0x00, 0x04, 0x6C, 0x77, 0x80, + 0x03, 0x7E, 0x70, 0x02, 0x7A, 0x73, 0x18, 0xF8, 0xE4, 0x7A, 0xB3, 0x12, + 0xEB, 0xE4, 0x7A, 0xB3, 0x12, 0xDF, 0x74, 0xFF, 0x7A, 0xB3, 0x12, 0xE3, + 0xE4, 0x7A, 0xB3, 0x2B, 0xAF, 0xE4, 0x7A, 0xB3, 0x12, 0xE8, 0x22, 0x7C, + 0x67, 0x7C, 0xAB, 0xBC, 0x6A, 0x78, 0x03, 0xE4, 0x80, 0x2E, 0xBE, 0xA0, + 0x08, 0x68, 0x04, 0xA5, 0xBE, 0x08, 0x04, 0x74, 0x01, 0x80, 0x21, 0xBC, + 0x6A, 0x50, 0x08, 0x0A, 0x06, 0x0A, 0x1A, 0x9D, 0x10, 0x80, 0x06, 0x0A, + 0x0A, 0x0A, 0x16, 0x9D, 0x10, 0xBE, 0x30, 0x04, 0x28, 0x08, 0x0A, 0x03, + 0x7E, 0x14, 0x00, 0x08, 0x9D, 0x10, 0x7C, 0xB3, 0x22, 0x7E, 0x37, 0x2B, + 0xB1, 0x7A, 0x37, 0xF5, 0x06, 0x7E, 0x37, 0x2B, 0xB3, 0x7A, 0x37, 0xF5, + 0x08, 0x7E, 0x37, 0x2B, 0xB5, 0x7A, 0x37, 0xF5, 0x1C, 0x7E, 0x37, 0x2B, + 0xB7, 0x7A, 0x37, 0xF5, 0x1E, 0x7E, 0x37, 0x2B, 0xB9, 0x7A, 0x37, 0xF5, + 0x20, 0x7E, 0x37, 0x2B, 0xBB, 0x7A, 0x37, 0xF2, 0x36, 0x7E, 0x37, 0x2B, + 0xBD, 0x7A, 0x37, 0xF2, 0x64, 0x22, 0x74, 0x01, 0x7A, 0xB3, 0x12, 0xED, + 0xC2, 0x2C, 0x7E, 0x34, 0x2D, 0x8B, 0x7E, 0x24, 0x00, 0x4A, 0x12, 0xF2, + 0x4B, 0x7E, 0x34, 0x2A, 0x19, 0x7E, 0x24, 0x01, 0x96, 0x12, 0xF2, 0x4B, + 0xE4, 0x7A, 0xB3, 0x2C, 0x59, 0x7E, 0xB3, 0x2C, 0x5E, 0x70, 0x0F, 0x12, + 0xA3, 0x07, 0x12, 0xA4, 0x99, 0x6D, 0x33, 0x7A, 0x37, 0x18, 0xFC, 0x12, + 0x9F, 0x0A, 0x22, 0xA2, 0x01, 0xE4, 0x33, 0xB4, 0x01, 0x30, 0xE5, 0x5B, + 0xB4, 0x03, 0x15, 0x7E, 0x37, 0x2D, 0xE3, 0x0B, 0x34, 0x7E, 0x39, 0xB0, + 0xC4, 0x23, 0x54, 0x1F, 0x7E, 0x70, 0x03, 0x12, 0xEE, 0xC6, 0x80, 0x16, + 0x7E, 0x37, 0x2D, 0xE3, 0x0B, 0x35, 0x0B, 0x38, 0x50, 0x0A, 0x5A, 0xC4, + 0x5E, 0x54, 0x00, 0x0F, 0x7E, 0x70, 0x03, 0x12, 0xEE, 0xC6, 0x22, 0x7C, + 0xA3, 0x7C, 0x3B, 0x7D, 0x43, 0x6C, 0x22, 0x7E, 0xB3, 0x04, 0x0B, 0x70, + 0x21, 0x7E, 0xB3, 0x04, 0x0D, 0x7E, 0x34, 0x00, 0x01, 0x60, 0x05, 0x3E, + 0x34, 0x14, 0x78, 0xFB, 0xBD, 0x30, 0x08, 0x05, 0x7E, 0x20, 0x80, 0x80, + 0x09, 0xBE, 0x04, 0x00, 0x20, 0x58, 0x03, 0x7E, 0x20, 0x02, 0x7D, 0x34, + 0x7C, 0xB3, 0x7C, 0x3A, 0x02, 0x96, 0x96, 0x7C, 0x57, 0x7C, 0xAB, 0x0A, + 0x4B, 0x09, 0x74, 0x36, 0xF5, 0x09, 0x44, 0x36, 0xF8, 0xA5, 0xBD, 0x00, + 0x0C, 0x4C, 0x44, 0x68, 0x04, 0x1B, 0x40, 0x80, 0x13, 0x6C, 0x77, 0x80, + 0x0F, 0x09, 0x64, 0x37, 0x15, 0xBC, 0x64, 0x28, 0x04, 0x0B, 0x40, 0x80, + 0x03, 0x7E, 0x70, 0x01, 0x19, 0x74, 0x36, 0xF5, 0x0A, 0x3A, 0x19, 0x43, + 0x36, 0xF8, 0x22, 0xCA, 0xF8, 0x7C, 0xAB, 0x7D, 0x43, 0xA2, 0xEB, 0xE4, + 0x33, 0x7C, 0xFB, 0xC2, 0xEB, 0x5E, 0x40, 0x0F, 0x1E, 0x24, 0x7D, 0x32, + 0x7D, 0x14, 0x2E, 0x14, 0x00, 0x06, 0x6D, 0x00, 0x7C, 0x5A, 0x1E, 0x50, + 0x0A, 0x25, 0x12, 0xE3, 0xF8, 0x74, 0x01, 0x12, 0xEE, 0xA5, 0xE4, 0x12, + 0xEE, 0xA5, 0x2E, 0xF0, 0xFF, 0x92, 0xEB, 0xDA, 0xF8, 0x22, 0x7E, 0x18, + 0x3A, 0x7C, 0x29, 0xB1, 0x00, 0x09, 0x60, 0x06, 0x29, 0xB1, 0x00, 0x0B, + 0x60, 0x03, 0xE4, 0x80, 0x23, 0x29, 0x31, 0x00, 0x0D, 0xBE, 0x30, 0x10, + 0x40, 0x03, 0xE4, 0x80, 0x17, 0x29, 0xA1, 0x00, 0x03, 0x4C, 0xAA, 0x78, + 0x03, 0xE4, 0x80, 0x0C, 0x2E, 0x34, 0x00, 0x03, 0x7C, 0xBA, 0x14, 0x7A, + 0x1B, 0xB0, 0x74, 0x01, 0x22, 0x7D, 0x12, 0x7D, 0x03, 0x1A, 0x3B, 0x3E, + 0x34, 0x3E, 0x34, 0x3E, 0x34, 0x7D, 0x23, 0x2E, 0x24, 0x05, 0xF1, 0x2E, + 0x34, 0x06, 0x41, 0xE4, 0x49, 0x42, 0x00, 0x02, 0x1B, 0x28, 0x40, 0x0B, + 0x25, 0x49, 0x43, 0x00, 0x02, 0x1B, 0x38, 0x40, 0x0B, 0x35, 0x04, 0xBE, + 0xB0, 0x02, 0x48, 0xE8, 0x1B, 0x28, 0x00, 0x1B, 0x38, 0x10, 0x22, 0x7D, + 0x13, 0x7C, 0xAB, 0x7E, 0x34, 0xC1, 0x50, 0x6C, 0x11, 0x80, 0x24, 0x09, + 0xB3, 0x00, 0x09, 0x70, 0x18, 0x49, 0x43, 0x00, 0x02, 0xBD, 0x14, 0x08, + 0x10, 0x09, 0x03, 0x00, 0x08, 0x0A, 0xF0, 0xBD, 0xF2, 0x58, 0x06, 0x74, + 0x01, 0x19, 0xB3, 0x00, 0x09, 0x2E, 0x34, 0x00, 0x10, 0x0B, 0x10, 0xBC, + 0xA1, 0x18, 0xD8, 0x22, 0xCA, 0x79, 0xA2, 0xEB, 0xE4, 0x33, 0x7C, 0xFB, + 0xA2, 0xAE, 0xE4, 0x33, 0x7C, 0xEB, 0xC2, 0xAE, 0xC2, 0xEB, 0xA2, 0x23, + 0xE4, 0x33, 0xB4, 0x01, 0x0E, 0xC2, 0x23, 0xC2, 0x22, 0xE4, 0x12, 0xDC, + 0x9B, 0x30, 0x21, 0x03, 0x12, 0xF5, 0x6B, 0x2E, 0xE0, 0xFF, 0x92, 0xAE, + 0x2E, 0xF0, 0xFF, 0x92, 0xEB, 0xDA, 0x79, 0x22, 0x7C, 0x36, 0x7C, 0x27, + 0x0A, 0x22, 0x5E, 0x24, 0x00, 0x0F, 0x7E, 0x37, 0x2B, 0xB5, 0x5E, 0x70, + 0xF0, 0x4D, 0x32, 0x7A, 0x37, 0x2B, 0xB5, 0x0A, 0x23, 0x5E, 0x24, 0x00, + 0x0F, 0x3E, 0x24, 0x3E, 0x24, 0x3E, 0x24, 0x3E, 0x24, 0x7E, 0x37, 0x2B, + 0xB5, 0x5E, 0x70, 0x0F, 0x4D, 0x32, 0x7A, 0x37, 0x2B, 0xB5, 0x22, 0xCA, + 0x79, 0x7C, 0xA7, 0x7E, 0x83, 0x2D, 0x0B, 0x7E, 0x90, 0x02, 0xAC, 0x89, + 0x2D, 0x42, 0x0B, 0x48, 0x70, 0x4D, 0x77, 0x68, 0x1A, 0x7C, 0x7A, 0x12, + 0xB8, 0xCC, 0x6C, 0x55, 0x80, 0x0C, 0x0B, 0x38, 0x10, 0x2D, 0x17, 0x1B, + 0x38, 0x10, 0x0B, 0x35, 0x0B, 0x50, 0xBE, 0x51, 0x5F, 0x40, 0xEF, 0xDA, + 0x79, 0x22, 0x7F, 0x70, 0x7A, 0x37, 0x05, 0x1C, 0x7A, 0x27, 0x05, 0x1E, + 0x7E, 0x14, 0x04, 0x10, 0x7F, 0x17, 0x7E, 0x54, 0x01, 0x04, 0x12, 0x8D, + 0x5D, 0x7E, 0xB3, 0x04, 0x6C, 0x12, 0xEF, 0xCB, 0x7E, 0x73, 0x04, 0x60, + 0x1A, 0x57, 0x2E, 0x54, 0x00, 0x0C, 0x12, 0xED, 0x3F, 0xE4, 0x7E, 0x34, + 0xC0, 0x00, 0x02, 0xCA, 0xBF, 0x7C, 0xAB, 0x7E, 0x44, 0xC1, 0x50, 0xE4, + 0x80, 0x25, 0x09, 0x74, 0x00, 0x04, 0x19, 0x74, 0x00, 0x0C, 0x09, 0x74, + 0x00, 0x05, 0x19, 0x74, 0x00, 0x0D, 0x09, 0x74, 0x00, 0x06, 0x19, 0x74, + 0x00, 0x0E, 0x09, 0x74, 0x00, 0x07, 0x19, 0x74, 0x00, 0x0F, 0x2E, 0x44, + 0x00, 0x10, 0x04, 0xBC, 0xAB, 0x38, 0xD7, 0x22, 0xCA, 0xF8, 0x7C, 0xAB, + 0x7D, 0x43, 0xA2, 0xEB, 0xE4, 0x33, 0x7C, 0xFB, 0xC2, 0xEB, 0x5E, 0x40, + 0x0F, 0x1E, 0x24, 0x7D, 0x12, 0x3E, 0x14, 0x2E, 0x14, 0xF0, 0x00, 0x6D, + 0x00, 0x7C, 0x7A, 0x1E, 0x70, 0x0A, 0x27, 0x7D, 0x34, 0x0B, 0x36, 0x12, + 0xEE, 0x3D, 0x2E, 0xF0, 0xFF, 0x92, 0xEB, 0xDA, 0xF8, 0x22, 0xCA, 0x79, + 0x6C, 0xFF, 0xA2, 0xEB, 0xE4, 0x33, 0x7C, 0xEB, 0xC2, 0xEB, 0x12, 0x93, + 0xF1, 0xA2, 0x23, 0xE4, 0x33, 0xB4, 0x01, 0x05, 0x7E, 0xF0, 0x01, 0x80, + 0x09, 0x30, 0x33, 0x06, 0x30, 0x37, 0x03, 0x12, 0xDB, 0x16, 0xC2, 0x37, + 0x2E, 0xE0, 0xFF, 0x92, 0xEB, 0x7C, 0xBF, 0xDA, 0x79, 0x22, 0xE4, 0x7E, + 0x37, 0x18, 0xF4, 0x4D, 0x33, 0x78, 0x04, 0x74, 0x01, 0x80, 0x21, 0xBE, + 0x34, 0x0F, 0xFF, 0x78, 0x03, 0xE4, 0x80, 0x18, 0xBE, 0x37, 0x18, 0xFC, + 0x40, 0x12, 0xBE, 0x37, 0x18, 0xFC, 0x78, 0x02, 0x74, 0x01, 0x7E, 0x37, + 0x18, 0xFC, 0x0B, 0x34, 0x7A, 0x37, 0x18, 0xFC, 0x22, 0x7F, 0x71, 0x7F, + 0x60, 0x7E, 0x53, 0x05, 0x1A, 0x1A, 0x3B, 0x1A, 0x25, 0xAD, 0x32, 0x7D, + 0x23, 0x3E, 0x24, 0x2E, 0x27, 0x03, 0x0E, 0xBE, 0x68, 0x00, 0x00, 0x68, + 0x03, 0x1B, 0x6A, 0x20, 0xBE, 0x78, 0x00, 0x00, 0x68, 0x09, 0x3E, 0x34, + 0x2E, 0x37, 0x03, 0x10, 0x1B, 0x7A, 0x30, 0x22, 0x7F, 0x70, 0x7C, 0xA7, + 0x1A, 0x37, 0x3E, 0x34, 0x1A, 0x4B, 0x3E, 0x44, 0x3E, 0x44, 0x2D, 0x43, + 0x2E, 0x44, 0x06, 0xB9, 0x1B, 0x7A, 0x40, 0x1A, 0x0A, 0x3E, 0x04, 0x1A, + 0x1B, 0x3E, 0x14, 0x3E, 0x14, 0x2D, 0x10, 0x2E, 0x14, 0x06, 0xE1, 0x7E, + 0x1F, 0x37, 0x71, 0x1B, 0x1A, 0x10, 0x22, 0xE4, 0x7A, 0xB3, 0x37, 0x4A, + 0x7E, 0x17, 0x03, 0x10, 0x6D, 0x00, 0x7E, 0x18, 0x04, 0x90, 0x74, 0x02, + 0x12, 0xD5, 0xC9, 0x7E, 0x73, 0x0E, 0x7E, 0x0A, 0x37, 0x1B, 0x35, 0x7A, + 0x73, 0x37, 0x4A, 0x7E, 0x17, 0x03, 0x10, 0x6D, 0x00, 0x7E, 0x18, 0xC0, + 0x20, 0x74, 0x02, 0x02, 0xD5, 0xC9, 0x74, 0x03, 0x7A, 0xB3, 0x28, 0x22, + 0xE4, 0x7A, 0xB3, 0x2C, 0x77, 0xE4, 0x7A, 0xB3, 0x2C, 0x85, 0xC2, 0x27, + 0x75, 0x4F, 0x00, 0x75, 0x5D, 0x00, 0x75, 0x5C, 0x00, 0x7E, 0x71, 0x5C, + 0x74, 0x7D, 0xAC, 0x7B, 0x2E, 0x34, 0x28, 0x24, 0x7A, 0x37, 0x12, 0xDB, + 0x12, 0xF4, 0x39, 0x22, 0xCA, 0x3B, 0x7C, 0x7B, 0xA5, 0xBF, 0x01, 0x0A, + 0x7E, 0x77, 0x2D, 0xD7, 0x0B, 0x74, 0x6D, 0x66, 0x80, 0x08, 0x7E, 0x3F, + 0x2C, 0x7E, 0x2E, 0x74, 0x00, 0x0C, 0x7F, 0x03, 0x7E, 0x37, 0x12, 0xE9, + 0x2E, 0x34, 0x00, 0x0C, 0x7E, 0x24, 0x00, 0x04, 0x12, 0xF0, 0x0A, 0xDA, + 0x3B, 0x22, 0xA2, 0x01, 0xE4, 0x33, 0xB4, 0x01, 0x18, 0x7E, 0x37, 0x2D, + 0xE3, 0x0B, 0x35, 0x0B, 0x38, 0x50, 0x0A, 0x5A, 0xC4, 0x5E, 0x54, 0x00, + 0x0F, 0x7E, 0x70, 0x03, 0x12, 0xEE, 0xC6, 0x80, 0x08, 0x74, 0x9B, 0x7E, + 0x70, 0x03, 0x12, 0xEE, 0xC6, 0x43, 0x53, 0x40, 0x75, 0xBB, 0x00, 0x22, + 0x7C, 0xA7, 0x12, 0xB8, 0xCC, 0x7D, 0x13, 0x7E, 0x34, 0x80, 0x00, 0x7E, + 0x24, 0x7F, 0xFF, 0x6C, 0x11, 0x80, 0x13, 0x0B, 0x18, 0x40, 0x0B, 0x15, + 0xBD, 0x43, 0x08, 0x02, 0x7D, 0x34, 0xBD, 0x42, 0x58, 0x02, 0x7D, 0x24, + 0x0B, 0x10, 0xBE, 0x11, 0x5F, 0x40, 0xE8, 0x9D, 0x32, 0x22, 0xCA, 0x3B, + 0x7D, 0x72, 0x7D, 0x63, 0x7E, 0x18, 0x37, 0x63, 0x7A, 0x1F, 0x37, 0x71, + 0x6C, 0x77, 0x7E, 0x08, 0x37, 0x61, 0x12, 0xE9, 0x84, 0x7E, 0x37, 0x37, + 0x61, 0x0B, 0x38, 0x30, 0x1B, 0x68, 0x30, 0x7E, 0x37, 0x37, 0x63, 0x0B, + 0x38, 0x30, 0x1B, 0x78, 0x30, 0xDA, 0x3B, 0x22, 0x7E, 0x37, 0x12, 0xE9, + 0x09, 0xB3, 0x00, 0xF8, 0xB4, 0x01, 0x0F, 0x2E, 0x34, 0x01, 0x10, 0x12, + 0x5D, 0x19, 0x7E, 0x37, 0x12, 0xE9, 0x19, 0xB3, 0x00, 0xF8, 0x7E, 0xB3, + 0x12, 0xE0, 0xB4, 0x01, 0x0B, 0x7E, 0x34, 0x2E, 0x33, 0x12, 0x5D, 0x19, + 0x7A, 0xB3, 0x12, 0xE0, 0x22, 0x7E, 0x34, 0x90, 0x00, 0x7A, 0x37, 0x12, + 0xE9, 0x7E, 0x34, 0xF8, 0x06, 0x7E, 0x24, 0x00, 0xFF, 0x7A, 0x1F, 0x2C, + 0x7E, 0x7E, 0x34, 0xA5, 0x00, 0x7A, 0x37, 0x2C, 0x82, 0x7E, 0x34, 0xA4, + 0x80, 0x7A, 0x37, 0x2C, 0x61, 0x7E, 0x34, 0xA0, 0x00, 0x7A, 0x37, 0x2C, + 0x7C, 0x22, 0x12, 0xEE, 0x83, 0xB4, 0x01, 0x26, 0x7E, 0x73, 0x2C, 0x94, + 0x7A, 0x73, 0x2C, 0x9D, 0x7E, 0x08, 0x2C, 0x95, 0x7E, 0x34, 0x2C, 0x9E, + 0x7E, 0x24, 0x00, 0x04, 0x12, 0xEE, 0x3D, 0x7E, 0x08, 0x2C, 0xD4, 0x7E, + 0x34, 0x2C, 0xDC, 0x7E, 0x24, 0x00, 0x04, 0x12, 0xEE, 0x3D, 0x22, 0x7E, + 0xB3, 0x3B, 0x81, 0x60, 0x10, 0x7E, 0x37, 0x3B, 0x82, 0x7A, 0x37, 0x0E, + 0x73, 0x7E, 0x37, 0x3B, 0x84, 0x7A, 0x37, 0x0E, 0x75, 0x7E, 0xB3, 0x3B, + 0x86, 0x60, 0x10, 0x7E, 0x37, 0x3B, 0x87, 0x7A, 0x37, 0x0E, 0x77, 0x7E, + 0x37, 0x3B, 0x89, 0x7A, 0x37, 0x0E, 0x79, 0x22, 0xE4, 0x7A, 0xB3, 0x09, + 0xF1, 0x6C, 0x77, 0x6C, 0x66, 0x74, 0x0B, 0xAC, 0xB7, 0x19, 0x65, 0x09, + 0x83, 0x0B, 0x70, 0xA5, 0xBF, 0x0A, 0xF0, 0x6C, 0x77, 0xE4, 0x0A, 0x27, + 0x19, 0xB2, 0x09, 0xF2, 0x19, 0xB2, 0x0A, 0x1A, 0x0B, 0x70, 0xBE, 0x70, + 0x28, 0x40, 0xEE, 0x22, 0x7E, 0xB3, 0x2D, 0x00, 0x60, 0x0F, 0x74, 0x02, + 0x7E, 0x71, 0x5E, 0x7E, 0x61, 0x5F, 0x12, 0xC8, 0x79, 0x7A, 0x37, 0x2C, + 0x92, 0x7E, 0xB3, 0x2D, 0x01, 0x60, 0x0F, 0x74, 0x20, 0x7E, 0x70, 0x02, + 0x7E, 0x61, 0x5F, 0x12, 0xC8, 0x79, 0x7A, 0x37, 0x2C, 0xD2, 0x22, 0xCA, + 0xF8, 0x7D, 0x23, 0x7C, 0xFB, 0x7A, 0xB3, 0x03, 0xC7, 0x7E, 0x34, 0x05, + 0x23, 0x7E, 0x14, 0x00, 0x16, 0x12, 0xF0, 0xDB, 0x4C, 0xFF, 0x68, 0x04, + 0x74, 0x14, 0x80, 0x07, 0x7E, 0xB3, 0x03, 0xC8, 0x60, 0x05, 0x14, 0x7A, + 0xB3, 0x03, 0xC8, 0xDA, 0xF8, 0x22, 0x7C, 0xAB, 0x7D, 0x12, 0x7D, 0x03, + 0x0B, 0x08, 0x40, 0x49, 0x30, 0x00, 0x02, 0x6C, 0x55, 0x80, 0x15, 0x7D, + 0x01, 0x74, 0x01, 0x19, 0xB1, 0x00, 0x09, 0x1B, 0x08, 0x40, 0x59, 0x30, + 0x00, 0x02, 0x2E, 0x14, 0x00, 0x10, 0x0B, 0x50, 0xBC, 0xA5, 0x18, 0xE7, + 0x22, 0x2E, 0x34, 0xFF, 0x0F, 0x68, 0x11, 0x2E, 0x34, 0xFF, 0xF8, 0x68, + 0x10, 0x2E, 0x34, 0x00, 0xF7, 0x78, 0x0D, 0x12, 0xD7, 0xDC, 0x80, 0x08, + 0x12, 0xE0, 0x3B, 0x80, 0x03, 0x12, 0xF2, 0x79, 0x7E, 0xB3, 0x28, 0x1D, + 0x60, 0x04, 0xE4, 0x12, 0xF4, 0x55, 0x22, 0x7C, 0x3B, 0x7E, 0x23, 0x39, + 0x46, 0xBE, 0x20, 0x00, 0x28, 0x1B, 0x74, 0x02, 0xAC, 0xB2, 0x49, 0x35, + 0x39, 0xE9, 0x7E, 0x53, 0x39, 0x2F, 0x0A, 0x05, 0xBD, 0x30, 0x50, 0x09, + 0x7C, 0xB2, 0x14, 0x7A, 0xB3, 0x39, 0x46, 0x6C, 0x33, 0x7C, 0xB3, 0x22, + 0x7C, 0xAB, 0x7D, 0x43, 0xBE, 0x24, 0x00, 0x80, 0x40, 0x06, 0xBE, 0x24, + 0x01, 0x00, 0x40, 0x0A, 0xE4, 0x7D, 0x34, 0x7C, 0x3A, 0x12, 0x65, 0xAC, + 0x80, 0x0D, 0x7D, 0x32, 0x7D, 0x24, 0x2E, 0x24, 0x00, 0x06, 0x0A, 0x1A, + 0x12, 0xAC, 0x6A, 0x22, 0x74, 0x9B, 0x7E, 0x70, 0x03, 0x12, 0xEE, 0xC6, + 0xD2, 0x07, 0x7E, 0xB3, 0x28, 0x1D, 0x54, 0xFB, 0x7A, 0xB3, 0x28, 0x1D, + 0xE4, 0x12, 0xCB, 0xA2, 0x12, 0xF5, 0x19, 0x43, 0xA8, 0x80, 0xA9, 0xD1, + 0x87, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x7D, 0x12, 0x7D, 0x03, + 0x1A, 0x2B, 0x3E, 0x24, 0x3E, 0x24, 0x3E, 0x24, 0x7D, 0x32, 0x2E, 0x34, + 0x05, 0xF1, 0x2E, 0x24, 0x06, 0x41, 0xE4, 0x1B, 0x38, 0x00, 0x0B, 0x35, + 0x1B, 0x28, 0x10, 0x0B, 0x25, 0x04, 0xBE, 0xB0, 0x04, 0x48, 0xF0, 0x22, + 0x7E, 0x37, 0x12, 0xDB, 0x7A, 0x37, 0xFF, 0xD2, 0x7E, 0x24, 0x91, 0x40, + 0x7A, 0x27, 0xFF, 0xD6, 0x0B, 0x34, 0x7E, 0x39, 0x70, 0x0A, 0x37, 0x0B, + 0x35, 0x7A, 0x37, 0xFF, 0xDA, 0x7E, 0x34, 0x00, 0x01, 0x7A, 0x37, 0xFF, + 0xD0, 0x22, 0x7C, 0xAB, 0x7D, 0x43, 0xBE, 0x24, 0x00, 0x80, 0x40, 0x06, + 0xBE, 0x24, 0x01, 0x00, 0x40, 0x0B, 0x74, 0x01, 0x7D, 0x34, 0x7C, 0x3A, + 0x12, 0x65, 0xAC, 0x80, 0x09, 0x7D, 0x34, 0x0B, 0x36, 0x0A, 0x1A, 0x12, + 0xAC, 0x3D, 0x22, 0x7C, 0x6B, 0xBE, 0x60, 0x02, 0x50, 0x03, 0x7E, 0x60, + 0x02, 0x7E, 0x70, 0x01, 0xBE, 0x60, 0x04, 0x40, 0x03, 0x7E, 0x70, 0x02, + 0xBE, 0x60, 0x09, 0x40, 0x02, 0x0B, 0x70, 0x7A, 0x73, 0x04, 0x0D, 0x7A, + 0x63, 0x04, 0x0C, 0x22, 0x7D, 0x12, 0x7D, 0x03, 0x1A, 0x3B, 0x3E, 0x34, + 0x3E, 0x34, 0x3E, 0x34, 0x7D, 0x23, 0x2E, 0x24, 0x05, 0xF1, 0x2E, 0x34, + 0x06, 0x41, 0x49, 0x22, 0x00, 0x06, 0x1B, 0x08, 0x20, 0x49, 0x03, 0x00, + 0x06, 0x1B, 0x18, 0x00, 0x22, 0x7E, 0xB3, 0x28, 0x1D, 0x30, 0xE0, 0x1B, + 0xE4, 0x7A, 0xB3, 0x2C, 0x5E, 0xE4, 0x7A, 0xB3, 0x18, 0xF1, 0x12, 0xD0, + 0xFD, 0x7E, 0xB3, 0x28, 0x1D, 0x54, 0xFE, 0x7A, 0xB3, 0x28, 0x1D, 0x74, + 0x01, 0x80, 0x01, 0xE4, 0x22, 0x7D, 0x23, 0x7C, 0x3B, 0xA5, 0xBB, 0x00, + 0x05, 0x12, 0x9A, 0xEB, 0x80, 0x16, 0x7D, 0x32, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1B, 0x34, 0x78, 0xF2, 0x1B, 0x30, + 0xA5, 0xBB, 0x00, 0xEA, 0x22, 0x7C, 0x7B, 0x7E, 0xB3, 0x18, 0xF8, 0xB4, + 0x01, 0x0E, 0x7E, 0x63, 0x05, 0x1A, 0xAC, 0x76, 0x3E, 0x34, 0x2E, 0x37, + 0x03, 0x0E, 0x80, 0x0C, 0x7E, 0x63, 0x05, 0x1A, 0xAC, 0x76, 0x3E, 0x34, + 0x2E, 0x37, 0x03, 0x10, 0x22, 0x7C, 0x7B, 0x7E, 0xB3, 0x18, 0xF8, 0xB4, + 0x01, 0x0E, 0x7E, 0x63, 0x05, 0x1A, 0xAC, 0x76, 0x3E, 0x34, 0x2E, 0x37, + 0x03, 0x0E, 0x80, 0x0C, 0x7E, 0x63, 0x05, 0x1A, 0xAC, 0x76, 0x3E, 0x34, + 0x2E, 0x37, 0x03, 0x10, 0x22, 0x7D, 0x41, 0x7D, 0x53, 0x4D, 0x41, 0x78, + 0x04, 0x7E, 0x44, 0x00, 0x01, 0x7D, 0x12, 0x1A, 0x04, 0x1A, 0x00, 0x7D, + 0x35, 0x1A, 0x2A, 0x1A, 0x24, 0x12, 0x8C, 0xBA, 0x7D, 0x14, 0x1A, 0x08, + 0x1A, 0x00, 0x02, 0x8D, 0x27, 0x7D, 0x52, 0x7D, 0x43, 0x6D, 0x22, 0x6D, + 0x44, 0x80, 0x14, 0x7D, 0xC4, 0x3E, 0xC4, 0x7F, 0x70, 0x2D, 0xFC, 0x0B, + 0x7A, 0xD0, 0x7F, 0x71, 0x2D, 0xFC, 0x1B, 0x7A, 0xD0, 0x0B, 0x44, 0xBD, + 0x45, 0x40, 0xE8, 0x22, 0x12, 0xA5, 0x60, 0x12, 0xE4, 0x70, 0x7E, 0x34, + 0x07, 0x27, 0x7E, 0x24, 0x07, 0x1D, 0x7E, 0x14, 0x07, 0x31, 0x74, 0x0A, + 0x12, 0x95, 0xB5, 0x12, 0xA3, 0xD0, 0x12, 0x18, 0x47, 0x12, 0x09, 0xAC, + 0x02, 0x4B, 0x68, 0x6C, 0x77, 0x80, 0x13, 0x74, 0x02, 0xAC, 0xB7, 0x49, + 0x25, 0x2C, 0x95, 0xBE, 0x24, 0x7F, 0xFF, 0x78, 0x03, 0xE4, 0x80, 0x0C, + 0x0B, 0x70, 0x7E, 0x63, 0x2C, 0x87, 0xBC, 0x67, 0x38, 0xE5, 0x74, 0x01, + 0x22, 0x7C, 0xAB, 0xA2, 0xEB, 0xE4, 0x33, 0xC2, 0xEB, 0x4C, 0xAA, 0x68, + 0x0A, 0x7E, 0x34, 0x00, 0x01, 0x7A, 0x37, 0xF5, 0x1A, 0x80, 0x06, 0x6D, + 0x33, 0x7A, 0x37, 0xF5, 0x1A, 0x24, 0xFF, 0x92, 0xEB, 0x22, 0x7C, 0x67, + 0x7C, 0x7B, 0xC2, 0xAE, 0x75, 0xBC, 0x00, 0x0A, 0x47, 0x7E, 0x54, 0x00, + 0xFF, 0x9D, 0x54, 0xF5, 0xBD, 0x7C, 0xB6, 0x54, 0x03, 0x44, 0x80, 0xF5, + 0xBC, 0x75, 0xC3, 0xBF, 0xD2, 0xAE, 0x22, 0x7C, 0x7B, 0x5E, 0x70, 0x03, + 0x74, 0x02, 0xAC, 0xB7, 0x7E, 0x37, 0x2D, 0xD9, 0x09, 0xA3, 0x00, 0x0A, + 0x60, 0x05, 0x1E, 0xA0, 0x14, 0x78, 0xFB, 0x7C, 0xBA, 0x54, 0x03, 0x7A, + 0xB3, 0x28, 0x00, 0x22, 0x7D, 0x13, 0x6C, 0x77, 0x80, 0x12, 0x0B, 0x18, + 0x00, 0x1E, 0x04, 0x7D, 0x20, 0x1E, 0x24, 0x2D, 0x20, 0x1B, 0x18, 0x20, + 0x0B, 0x15, 0x0B, 0x70, 0x7E, 0x63, 0x2D, 0x02, 0xBC, 0x67, 0x38, 0xE6, + 0x22, 0x7C, 0xAB, 0x7E, 0x53, 0x04, 0x39, 0x5E, 0x50, 0x0F, 0x68, 0x15, + 0x4C, 0xAA, 0x68, 0x11, 0x7C, 0xBA, 0x7E, 0x43, 0x04, 0x12, 0x1E, 0x40, + 0x0A, 0x34, 0x0A, 0x25, 0x0B, 0x24, 0x02, 0xE7, 0x8F, 0x22, 0x7C, 0xA7, + 0x7C, 0x9B, 0x4C, 0xAA, 0x68, 0x18, 0x2E, 0xA0, 0x08, 0x7E, 0x0B, 0xB0, + 0xBE, 0xB0, 0x08, 0x68, 0x07, 0x2C, 0xBA, 0x54, 0x07, 0x7A, 0x0B, 0xB0, + 0x0B, 0x14, 0x1B, 0x90, 0x78, 0xEB, 0x22, 0x7E, 0xA0, 0x01, 0xE5, 0x5B, + 0x70, 0x16, 0xA2, 0xEB, 0xE4, 0x33, 0x7C, 0x7B, 0xC2, 0xEB, 0x30, 0x2B, + 0x04, 0xC2, 0x2B, 0x80, 0x02, 0x6C, 0xAA, 0x2E, 0x70, 0xFF, 0x92, 0xEB, + 0x7C, 0xBA, 0x22, 0x75, 0x52, 0x01, 0xE5, 0x40, 0x60, 0x03, 0x75, 0x52, + 0x21, 0xE5, 0x49, 0x60, 0x03, 0x43, 0x52, 0x02, 0xE5, 0x43, 0x60, 0x03, + 0x43, 0x52, 0x04, 0xE5, 0x48, 0x60, 0x03, 0x43, 0x52, 0x08, 0x22, 0xC2, + 0x07, 0x7E, 0xB3, 0x28, 0x1D, 0x54, 0xFB, 0x7A, 0xB3, 0x28, 0x1D, 0x12, + 0xF3, 0xA6, 0x12, 0xF5, 0x0E, 0x7E, 0xB3, 0x28, 0x1D, 0x44, 0x01, 0x7A, + 0xB3, 0x28, 0x1D, 0x43, 0xA8, 0x80, 0x22, 0x0A, 0x2B, 0x7E, 0x34, 0x00, + 0x07, 0x9D, 0x32, 0x7A, 0x73, 0x03, 0xFD, 0x7E, 0xB3, 0x03, 0xFD, 0x7E, + 0x34, 0x00, 0x01, 0x60, 0x05, 0x3E, 0x34, 0x14, 0x78, 0xFB, 0x7A, 0x73, + 0x03, 0xFE, 0x22, 0x7C, 0x7B, 0x4C, 0x77, 0x68, 0x0B, 0x7C, 0xB7, 0x6C, + 0x77, 0x12, 0xEE, 0xC6, 0xD2, 0x2C, 0x80, 0x0D, 0x30, 0x2C, 0x0A, 0x74, + 0x9B, 0x7E, 0x70, 0x03, 0x12, 0xEE, 0xC6, 0xC2, 0x2C, 0x22, 0x7D, 0xF2, + 0x7F, 0x20, 0x7D, 0x03, 0x6D, 0x11, 0x80, 0x10, 0x7F, 0x12, 0x2D, 0x31, + 0x7E, 0x1B, 0x70, 0x7D, 0xE0, 0x2D, 0xE1, 0x7A, 0xE9, 0x70, 0x0B, 0x14, + 0xBD, 0x1F, 0x40, 0xEC, 0x22, 0x7E, 0x34, 0x07, 0x8B, 0x6C, 0xAA, 0x7E, + 0x39, 0xB0, 0x70, 0x08, 0x74, 0x01, 0x7A, 0x39, 0xB0, 0x7C, 0xBA, 0x22, + 0x0B, 0x34, 0x0B, 0xA0, 0xBE, 0xA0, 0x0A, 0x48, 0xEA, 0x74, 0xFF, 0x22, + 0x7C, 0xA3, 0x7C, 0x9B, 0x7D, 0x12, 0x7D, 0x03, 0xE4, 0x80, 0x0F, 0x0B, + 0x18, 0x30, 0x1B, 0x08, 0x30, 0x1A, 0x3A, 0x3E, 0x34, 0x2D, 0x03, 0x0B, + 0x15, 0x04, 0xBC, 0x9B, 0x38, 0xED, 0x22, 0x7C, 0xAB, 0x7E, 0xB3, 0x28, + 0x1D, 0x70, 0x14, 0x20, 0x00, 0x11, 0x7E, 0xB3, 0x12, 0xE2, 0xBE, 0xB0, + 0x01, 0x68, 0x03, 0xB4, 0x05, 0x05, 0x7C, 0xBA, 0x12, 0xF4, 0x55, 0x22, + 0x7C, 0xAB, 0x7E, 0xB3, 0x28, 0x1D, 0x70, 0x14, 0x30, 0x00, 0x11, 0x7E, + 0xB3, 0x12, 0xE2, 0xBE, 0xB0, 0x04, 0x68, 0x03, 0xB4, 0x06, 0x05, 0x7C, + 0xBA, 0x12, 0xF4, 0x55, 0x22, 0x6C, 0xAA, 0x7E, 0x44, 0x0D, 0xD1, 0x74, + 0x10, 0x7E, 0x49, 0x70, 0x4C, 0xA7, 0x0B, 0x44, 0x14, 0x78, 0xF6, 0xBE, + 0xA0, 0x08, 0x78, 0x03, 0xE4, 0x80, 0x02, 0x7C, 0xBA, 0x22, 0x7C, 0xAB, + 0x7D, 0x13, 0xE4, 0x80, 0x0C, 0x6D, 0x44, 0x1A, 0x0B, 0x3E, 0x04, 0x2D, + 0x01, 0x1B, 0x08, 0x40, 0x04, 0xBC, 0xAB, 0x18, 0xF0, 0xE4, 0x7A, 0xB3, + 0x04, 0x0E, 0x22, 0x7D, 0x02, 0x7D, 0x53, 0x6D, 0x44, 0x80, 0x10, 0x7D, + 0x34, 0x2D, 0x30, 0x7E, 0x39, 0x50, 0x7D, 0x34, 0x2D, 0x35, 0x7A, 0x39, + 0x50, 0x0B, 0x44, 0xBD, 0x14, 0x18, 0xEC, 0x22, 0x7E, 0xB3, 0x3B, 0x6A, + 0x60, 0x16, 0x7E, 0xB3, 0x3B, 0x77, 0x12, 0x9E, 0x38, 0x7A, 0xB3, 0x3B, + 0x77, 0x7E, 0xB3, 0x3B, 0x7A, 0x12, 0xBC, 0x4F, 0x7A, 0xB3, 0x3B, 0x7A, + 0x22, 0x7C, 0x7B, 0x4C, 0x77, 0x68, 0x15, 0x7E, 0xB3, 0x12, 0xE2, 0xB4, + 0x01, 0x0E, 0x7E, 0x37, 0x2D, 0xD9, 0x7E, 0x39, 0xB0, 0x30, 0xE0, 0x04, + 0xE4, 0x12, 0xF4, 0x55, 0x22, 0x12, 0xF4, 0x2A, 0x7C, 0x7B, 0x7E, 0xB3, + 0x0E, 0x31, 0x7E, 0x24, 0x0E, 0x07, 0x7E, 0x14, 0x0E, 0x1B, 0x7E, 0x04, + 0x0D, 0xF7, 0x12, 0xC0, 0xCC, 0x12, 0xF1, 0x69, 0x22, 0x9D, 0x31, 0x7D, + 0x13, 0x7D, 0x32, 0x9D, 0x30, 0x7A, 0x17, 0xFF, 0x30, 0x7A, 0x37, 0xFF, + 0x32, 0x00, 0x00, 0x00, 0x7E, 0x37, 0xFF, 0x32, 0x1E, 0x34, 0x1E, 0x34, + 0x22, 0x12, 0xF5, 0xAA, 0x7C, 0x7B, 0x30, 0x01, 0x11, 0x0A, 0x37, 0x6D, + 0x22, 0x2E, 0x24, 0x00, 0xFF, 0x2E, 0x18, 0xF7, 0xB9, 0x7E, 0x1B, 0xB0, + 0x80, 0x01, 0xE4, 0x22, 0x7C, 0x3B, 0x7D, 0x03, 0x1A, 0x3B, 0x7A, 0x37, + 0xFF, 0x62, 0x7A, 0x27, 0xFF, 0x64, 0x7E, 0x17, 0x03, 0xEB, 0x7A, 0x17, + 0xFF, 0x6C, 0x7A, 0x07, 0xFF, 0x60, 0x22, 0xCA, 0xF8, 0xA2, 0xEB, 0xE4, + 0x33, 0x7C, 0xFB, 0xC2, 0xEB, 0xC2, 0x23, 0xC2, 0x22, 0xE4, 0x12, 0xDC, + 0x9B, 0x2E, 0xF0, 0xFF, 0x92, 0xEB, 0xDA, 0xF8, 0x22, 0x7E, 0xB3, 0x18, + 0xF8, 0xB4, 0x01, 0x0D, 0x7E, 0x71, 0x46, 0x74, 0x40, 0xAC, 0x7B, 0x2E, + 0x34, 0x33, 0xE1, 0x80, 0x04, 0x7E, 0x34, 0x31, 0xA1, 0x22, 0x7C, 0x7B, + 0xA5, 0xBF, 0x00, 0x0A, 0x7E, 0x34, 0xF5, 0xE2, 0x7E, 0x24, 0x00, 0xFF, + 0x80, 0x08, 0x7E, 0x34, 0xF6, 0x96, 0x7E, 0x24, 0x00, 0xFF, 0x22, 0x7E, + 0xA0, 0x66, 0x7E, 0xB3, 0x2C, 0x5E, 0x70, 0x09, 0x7E, 0x37, 0x2D, 0xD9, + 0x0B, 0x35, 0x7E, 0x39, 0xA0, 0x7C, 0xBA, 0x12, 0xE4, 0xAC, 0x22, 0x7E, + 0xB3, 0x2C, 0x5E, 0x70, 0x11, 0x12, 0x56, 0x01, 0x12, 0xF5, 0xC8, 0xC2, + 0xEB, 0x75, 0xC0, 0xF7, 0x75, 0xEF, 0x00, 0x43, 0x62, 0x08, 0x22, 0x7E, + 0x24, 0x04, 0x90, 0x6C, 0x33, 0x7E, 0x39, 0x20, 0x7A, 0x29, 0x20, 0x0B, + 0x24, 0x0B, 0x34, 0x0B, 0x30, 0xBE, 0x30, 0x84, 0x40, 0xEF, 0x22, 0xCA, + 0xF8, 0x7D, 0xF3, 0x7C, 0xFB, 0x7F, 0x20, 0x4D, 0xF3, 0x68, 0x09, 0x7A, + 0x2B, 0xF0, 0x0B, 0x54, 0x1B, 0xF4, 0x78, 0xF7, 0xDA, 0xF8, 0x22, 0x7D, + 0x12, 0x7D, 0x03, 0x6D, 0x33, 0x80, 0x0A, 0xE4, 0x7D, 0x20, 0x2D, 0x23, + 0x7A, 0x29, 0xB0, 0x0B, 0x34, 0xBD, 0x31, 0x40, 0xF2, 0x22, 0x12, 0xF3, + 0x1F, 0x0A, 0x3B, 0x4D, 0x33, 0x68, 0x0C, 0x12, 0xF5, 0x9B, 0x0A, 0x3B, + 0x4D, 0x33, 0x68, 0x03, 0x74, 0x01, 0x22, 0xE4, 0x22, 0x30, 0x00, 0x12, + 0xE5, 0x4F, 0xBE, 0xB0, 0x00, 0x28, 0x09, 0xC2, 0x28, 0x74, 0x01, 0x12, + 0xF0, 0x84, 0x80, 0x02, 0xD2, 0x28, 0x22, 0x7E, 0xA0, 0x28, 0x1B, 0xA0, + 0x7E, 0x39, 0xB0, 0x60, 0x04, 0x14, 0x7A, 0x39, 0xB0, 0x0B, 0x34, 0x4C, + 0xAA, 0x78, 0xEF, 0x22, 0x7D, 0x13, 0x6D, 0x33, 0x80, 0x0A, 0xE4, 0x7D, + 0x03, 0x2D, 0x01, 0x7A, 0x09, 0xB0, 0x0B, 0x34, 0xBD, 0x23, 0x18, 0xF2, + 0x22, 0x9D, 0x32, 0xBE, 0x34, 0x00, 0x00, 0x58, 0x06, 0x6E, 0x34, 0xFF, + 0xFF, 0x0B, 0x34, 0x0E, 0x34, 0x0E, 0x34, 0x0E, 0x34, 0x22, 0x7D, 0x53, + 0x6D, 0x33, 0x7E, 0x47, 0x3B, 0x8B, 0x4D, 0x44, 0x68, 0x08, 0x7D, 0x35, + 0x7E, 0x57, 0x3B, 0x8B, 0x99, 0x54, 0x22, 0x7E, 0x37, 0x12, 0xE9, 0x09, + 0xB3, 0x00, 0xF8, 0xB4, 0x01, 0x04, 0x74, 0x01, 0x80, 0x04, 0xA2, 0x29, + 0xE4, 0x33, 0x22, 0x7D, 0x12, 0x7C, 0x5B, 0x7D, 0x03, 0x4D, 0x11, 0x68, + 0x09, 0x7A, 0x09, 0x50, 0x0B, 0x04, 0x1B, 0x14, 0x78, 0xF7, 0x22, 0x7E, + 0x73, 0x0E, 0x32, 0xBE, 0x73, 0x0D, 0xBA, 0x68, 0x08, 0x7A, 0x73, 0x0D, + 0xBA, 0x74, 0x01, 0x80, 0x01, 0xE4, 0x22, 0x7E, 0xB3, 0x05, 0x19, 0x60, + 0x09, 0x7E, 0x73, 0x03, 0xC0, 0xBE, 0x70, 0x20, 0x28, 0x03, 0x74, 0x01, + 0x22, 0xE4, 0x22, 0x7D, 0x02, 0x7D, 0x13, 0x80, 0x0B, 0x14, 0x7E, 0x09, + 0xA0, 0x0B, 0x04, 0x7A, 0x19, 0xA0, 0x0B, 0x14, 0x70, 0xF3, 0x22, 0x4D, + 0x11, 0x68, 0x0E, 0x7E, 0x29, 0x10, 0x7A, 0x39, 0x10, 0x0B, 0x34, 0x0B, + 0x24, 0x1B, 0x14, 0x78, 0xF2, 0x22, 0x7E, 0x18, 0x3A, 0x7C, 0x29, 0xB1, + 0x00, 0x09, 0x70, 0x04, 0x74, 0x01, 0x80, 0x04, 0x29, 0xB1, 0x00, 0x08, + 0x22, 0x7C, 0xA7, 0x0A, 0x4A, 0x0A, 0x5B, 0x9D, 0x54, 0xBE, 0x54, 0xFF, + 0x80, 0x58, 0x04, 0x7E, 0x54, 0xFF, 0x80, 0x22, 0x7C, 0xA7, 0x0A, 0x4A, + 0x0A, 0x5B, 0x9D, 0x54, 0xBE, 0x54, 0x00, 0x00, 0x58, 0x04, 0x2E, 0x54, + 0x01, 0x00, 0x22, 0x6D, 0x33, 0x7A, 0x37, 0x0E, 0x73, 0x7A, 0x37, 0x0E, + 0x75, 0x7A, 0x37, 0x0E, 0x77, 0x7A, 0x37, 0x0E, 0x79, 0x22, 0xE4, 0x7E, + 0x37, 0x12, 0xE9, 0x7A, 0x39, 0xB0, 0xE4, 0x7E, 0x37, 0x12, 0xE9, 0x19, + 0xB3, 0x00, 0x02, 0x22, 0x7C, 0x7B, 0x0A, 0x37, 0x6D, 0x22, 0x2E, 0x24, + 0x00, 0xFF, 0x2E, 0x18, 0xF5, 0xD1, 0x7E, 0x1B, 0xB0, 0x22, 0x6C, 0xAA, + 0xE4, 0x1A, 0x4A, 0x19, 0xB4, 0x07, 0x31, 0x0B, 0xA0, 0xBE, 0xA0, 0x0A, + 0x48, 0xF2, 0x22, 0xE4, 0x7A, 0xB3, 0x28, 0x22, 0xE4, 0x7A, 0xB3, 0x2C, + 0x77, 0xE4, 0x7A, 0xB3, 0x2C, 0x85, 0x22, 0x7E, 0xB3, 0x12, 0xE0, 0xB4, + 0x01, 0x04, 0x74, 0x01, 0x80, 0x04, 0xA2, 0x45, 0xE4, 0x33, 0x22, 0x9D, + 0x32, 0xBE, 0x34, 0x00, 0x00, 0x08, 0x01, 0x22, 0x6E, 0x34, 0xFF, 0xFF, + 0x0B, 0x34, 0x22, 0x74, 0xFF, 0x7A, 0xB3, 0x03, 0xBE, 0xE4, 0x7A, 0xB3, + 0x03, 0xBF, 0x7A, 0xB3, 0x03, 0xBD, 0x22, 0xA9, 0xC0, 0xA6, 0xA9, 0xC0, + 0xA7, 0xA9, 0xC0, 0xA2, 0xA9, 0xD0, 0xA4, 0xD2, 0x80, 0x22, 0x7E, 0xB3, + 0x0D, 0xBB, 0xBE, 0xB0, 0xFF, 0x68, 0x04, 0x74, 0x01, 0x80, 0x01, 0xE4, + 0x22, 0xE4, 0x7A, 0xB3, 0x91, 0x40, 0x7E, 0x34, 0x01, 0x02, 0x7A, 0x37, + 0x91, 0x41, 0x22, 0x12, 0xC3, 0xF4, 0x60, 0x08, 0x12, 0x7E, 0xCE, 0xD2, + 0x25, 0x12, 0xE7, 0xC4, 0x22, 0x7C, 0x7B, 0x4C, 0x77, 0x68, 0x04, 0xC2, + 0x80, 0x80, 0x02, 0xD2, 0x80, 0x22, 0x7D, 0x23, 0x6D, 0x33, 0x7A, 0x37, + 0x18, 0xFC, 0x7A, 0x27, 0x18, 0xF4, 0x22, 0x7E, 0xB3, 0x18, 0xF9, 0xB4, + 0x01, 0x04, 0x74, 0x01, 0x80, 0x01, 0xE4, 0x22, 0x7D, 0x13, 0xBD, 0x21, + 0x28, 0x04, 0x7D, 0x31, 0x80, 0x02, 0x7D, 0x32, 0x22, 0x7D, 0x13, 0xBD, + 0x21, 0x50, 0x04, 0x7D, 0x31, 0x80, 0x02, 0x7D, 0x32, 0x22, 0x7C, 0x7B, + 0x4C, 0x77, 0x68, 0x05, 0x74, 0x01, 0x12, 0xF0, 0x67, 0x22, 0x7E, 0x34, + 0x00, 0x24, 0x7E, 0x24, 0x00, 0x04, 0x12, 0xF2, 0x4B, 0x22, 0x7E, 0x37, + 0xF0, 0x04, 0x4E, 0x60, 0x20, 0x7A, 0x37, 0xF0, 0x04, 0x22, 0x7E, 0xB3, + 0x28, 0x1D, 0x70, 0x04, 0x74, 0x01, 0x80, 0x01, 0xE4, 0x22, 0x12, 0xCF, + 0x73, 0x60, 0x06, 0x74, 0x01, 0x7A, 0xB3, 0x18, 0xF9, 0x22, 0x7E, 0xB3, + 0x03, 0xBB, 0x60, 0x04, 0x74, 0x01, 0x80, 0x01, 0xE4, 0x22, 0x74, 0x01, + 0x12, 0xBB, 0xBB, 0x74, 0x02, 0x7A, 0xB3, 0x04, 0x0F, 0x22, 0x7C, 0xAB, + 0xBE, 0xA0, 0xFF, 0x50, 0x02, 0x0B, 0xA0, 0x7C, 0xBA, 0x22, 0x74, 0xC8, + 0x7A, 0xB3, 0x03, 0xBD, 0xE4, 0x7A, 0xB3, 0x03, 0xC0, 0x22, 0x7E, 0x17, + 0x39, 0x35, 0x7E, 0x07, 0x39, 0x37, 0x12, 0xF2, 0xCE, 0x22, 0x74, 0x01, + 0x7E, 0x37, 0x12, 0xE9, 0x19, 0xB3, 0x00, 0x01, 0x22, 0x74, 0x05, 0x7E, + 0x37, 0x12, 0xE9, 0x19, 0xB3, 0x00, 0x01, 0x22, 0x7E, 0x37, 0x03, 0x0E, + 0x7E, 0x24, 0x04, 0x80, 0x02, 0xF2, 0xA4, 0x12, 0xC1, 0x55, 0xE5, 0x62, + 0x54, 0x13, 0xF5, 0x42, 0x22, 0xE5, 0xBA, 0x7A, 0xB3, 0x28, 0x21, 0x75, + 0xBA, 0x00, 0x22, 0xE5, 0x59, 0x20, 0xE1, 0x03, 0x12, 0x97, 0x77, 0x22, + 0x7E, 0x18, 0x3A, 0x7C, 0x29, 0xB1, 0x00, 0x09, 0x22, 0x12, 0xF1, 0x4D, + 0x3E, 0x34, 0x3E, 0x34, 0x22, 0x7E, 0xB3, 0x28, 0x1D, 0x54, 0xFB, 0x22, + 0x12, 0xF5, 0xBF, 0x12, 0x8A, 0x8E, 0x22, 0x12, 0xCD, 0x64, 0x12, 0xE6, + 0x43, 0x22, 0x75, 0xC1, 0x63, 0x43, 0x53, 0x80, 0x22, 0x0A, 0x3B, 0x09, + 0xB3, 0x04, 0x10, 0x22, 0x0A, 0x2B, 0x19, 0x72, 0x04, 0x10, 0x22, 0xA2, + 0x0E, 0xE4, 0x33, 0x22, 0x7E, 0x34, 0x04, 0x10, 0x22, 0x7E, 0xB3, 0x03, + 0xBB, 0x22, 0x7E, 0x37, 0x03, 0x0E, 0x22, 0x7E, 0xB3, 0x04, 0x0B, 0x22, + 0x7E, 0x34, 0x0E, 0x33, 0x22, 0x7E, 0xB3, 0x36, 0xFC, 0x22, 0x7E, 0xB3, + 0x3B, 0x7D, 0x22, 0x75, 0xC2, 0x00, 0x22, 0x12, 0xDE, 0x9D, 0x22, 0x12, + 0xF2, 0x62, 0x22, 0x12, 0xF4, 0xDE, 0x22, 0x74, 0x01, 0x22, 0xC3, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x06, 0x07, 0x07, 0x08, 0x05, 0x00, 0x00, 0x07, 0x06, 0x00, 0x06, + 0x00, 0x00, 0x02, 0x04, 0x02, 0x04, 0x02, 0x0A, 0x03, 0x05, 0x03, 0x02, + 0x08, 0x06, 0x08, 0x01, 0x00, 0x07, 0x0C, 0x09, 0x05, 0x03, 0x02, 0x08, + 0x06, 0x08, 0x01, 0x00, 0x07, 0x06, 0x05, 0x03, 0x05, 0x02, 0x07, 0x01, + 0x06, 0x09, 0x03, 0x04, 0x05, 0x08, 0x02, 0x08, 0x07, 0x00, 0x01, 0x03, + 0x10, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, + 0x03, 0x04, 0x05, 0x06, 0x07, 0x03, 0x10, 0x07, 0x06, 0x05, 0x04, 0x03, + 0x02, 0x01, 0x00, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x01, + 0x0A, 0x04, 0x08, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x01, + 0x07, 0x04, 0x01, 0x04, 0x05, 0x06, 0x07, 0x00, 0x00, 0x07, 0x01, 0x02, + 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x04, 0x01, 0x03, 0x05, 0x07, 0x04, + 0x07, 0x01, 0x02, 0x03, 0x08, 0x07, 0x06, 0x05, 0x04, 0x04, 0x01, 0x03, + 0x07, 0x05, 0x05, 0x03, 0x03, 0x06, 0x01, 0x07, 0x04, 0x03, 0x01, 0x05, + 0x07, 0x08, 0x03, 0x03, 0x00, 0x05, 0x0D, 0x03, 0x05, 0x00, 0x03, 0x09, + 0x03, 0x05, 0x02, 0x07, 0x0E, 0x03, 0x07, 0x02, 0x05, 0x0A, 0x03, 0x01, + 0x04, 0x07, 0x0F, 0x03, 0x07, 0x04, 0x01, 0x0B, 0x03, 0x03, 0x06, 0x01, + 0x10, 0x03, 0x01, 0x06, 0x03, 0x11, 0x02, 0x05, 0x06, 0x02, 0x06, 0x02, + 0x06, 0x02, 0x0B, 0x06, 0x02, 0x01, 0x00, 0x07, 0x06, 0x02, 0x01, 0x00, + 0x07, 0x06, 0x02, 0x0F, 0x03, 0x02, 0x01, 0x00, 0x07, 0x06, 0x05, 0x04, + 0x03, 0x02, 0x01, 0x00, 0x07, 0x06, 0x05, 0x0C, 0x04, 0x01, 0x07, 0x01, + 0x07, 0x0C, 0x04, 0x02, 0x07, 0x01, 0x06, 0x0C, 0x04, 0x02, 0x06, 0x02, + 0x06, 0x0C, 0x0A, 0x02, 0x01, 0x00, 0x07, 0x06, 0x02, 0x01, 0x00, 0x07, + 0x06, 0x06, 0x04, 0x07, 0x01, 0x07, 0x01, 0x06, 0x0A, 0x06, 0x07, 0x00, + 0x01, 0x02, 0x06, 0x07, 0x00, 0x01, 0x02, 0x06, 0x0C, 0x05, 0x06, 0x07, + 0x00, 0x01, 0x02, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x03, 0x10, 0x00, + 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x04, + 0x05, 0x06, 0x07, 0x03, 0x10, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, + 0x00, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x01, 0x0A, 0x00, + 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x01, 0x06, 0x01, + 0x04, 0x05, 0x06, 0x07, 0x00, 0x00, 0x07, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x00, 0x01, 0x04, 0x0B, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x07, 0x06, + 0x05, 0x04, 0x03, 0x04, 0x0A, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x07, + 0x06, 0x05, 0x04, 0x04, 0x03, 0x05, 0x07, 0x05, 0x04, 0x04, 0x02, 0x05, + 0x07, 0x05, 0x05, 0x02, 0x07, 0x01, 0x07, 0x03, 0x00, 0x05, 0x00, 0x08, + 0x02, 0x07, 0x05, 0x0D, 0x02, 0x01, 0x03, 0x09, 0x02, 0x01, 0x07, 0x0E, + 0x02, 0x03, 0x05, 0x0A, 0x02, 0x05, 0x07, 0x0F, 0x02, 0x03, 0x01, 0x0B, + 0x02, 0x07, 0x01, 0x10, 0x02, 0x05, 0x03, 0x11, 0x00, 0x00, 0x00, 0x00, + 0x5D, 0x00, 0x02, 0x00, 0x1F, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x42, 0xFF, 0x60, 0x02, 0x60, 0x02, 0x60, 0x02, 0x60, 0x02, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x06, 0x07, 0x08, 0x09, 0x0E, 0x0E, + 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x00, 0x63, 0x65, + 0x6D, 0x6F, 0x73, 0x76, 0x77, 0x7A, 0xC5, 0xC4, 0xC7, 0xC6, 0xC0, 0xC3, + 0xC1, 0xC2, 0xF4, 0xF5, 0xF6, 0xC8, 0xB1, 0xB0, 0xB2, 0xF8, 0x2D, 0x00, + 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x02, 0x04, 0x01, + 0x00, 0x08, 0x10, 0x20, 0x20, 0x08, 0x10, 0x20, 0x30, 0x03, 0x04, 0x05, + 0x05, 0x00, 0x40, 0x10, 0x04, 0x04, 0x04, 0x04, 0x00, 0x00, 0x1B, 0x15, + 0x1B, 0x15, 0x54, 0x46, 0x49, 0x33, 0x00, 0x0E, 0x03, 0x83, 0x43, 0x02, + 0x00, 0x23, 0x01, 0x20, 0x01, 0x18, 0x00, 0x00, 0x11, 0x0A, 0xFF, 0xBE, + 0xEE, 0x44, 0x04, 0x04, 0x03, 0x05, 0x07, 0x05, 0x04, 0x04, 0x02, 0x05, + 0x07, 0x05, 0x05, 0x02, 0x07, 0x01, 0x07, 0x03, 0x00, 0x05, 0x00, 0x08, + 0x02, 0x07, 0x05, 0x0D, 0x02, 0x01, 0x03, 0x09, 0x02, 0x01, 0x07, 0x0E, + 0x02, 0x03, 0x05, 0x0A, 0x02, 0x05, 0x07, 0x0F, 0x02, 0x03, 0x01, 0x0B, + 0x02, 0x07, 0x01, 0x10, 0x02, 0x05, 0x03, 0x11, 0x00, 0x00, 0x00, 0x00, + 0x5D, 0x00, 0x02, 0x00, 0x1F, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x42, 0xFF, 0x60, 0x02, 0x60, 0x02, 0x60, 0x02, 0x60, 0x02, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x06, 0x07, 0x08, 0x09, 0x0E, 0x0E, + 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x00, 0x63, 0x65, + 0x6D, 0x6F, 0x73, 0x76, 0x77, 0x7A, 0xC5, 0xC4, 0xC7, 0xC6, 0xC0, 0xC3, + 0xC1, 0xC2, 0xF4, 0xF5, 0xF6, 0xC8, 0xB1, 0xB0, 0xB2, 0xF8, 0x2D, 0x00, + 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x02, 0x04, 0x01, + 0x00, 0x08, 0x10, 0x20, 0x20, 0x08, 0x10, 0x20, 0x30, 0x03, 0x04, 0x05, + 0x05, 0x00, 0x40, 0x10, 0x04, 0x04, 0x04, 0x04, 0x00, 0x00, 0x1B, 0x15, + 0x1B, 0x15, 0x54, 0x46, 0x49, 0x33, 0x00, 0x0E, 0x03, 0x83, 0x43, 0x02, + 0x00, 0x23, 0x01, 0x20, 0x01, 0x18, 0x00, 0x00, 0x01, 0x0A, 0xFF, 0x4A, + 0xB3, 0x09, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0x43, 0x46, 0x54, 0x31, 0x0A, 0xB4, 0x23, 0x23, + 0x83, 0x00, 0x0A, 0xB7, 0x00, 0x00, 0x00, 0x2E, 0x00, 0x33, 0x00, 0x51, + 0x00, 0xD1, 0x00, 0xE1, 0x00, 0xFF, 0x01, 0x3D, 0x01, 0x88, 0x02, 0x0C, + 0x02, 0x3F, 0x02, 0x87, 0x02, 0x8E, 0x02, 0xD8, 0x03, 0xEC, 0x04, 0x56, + 0xD7, 0xFE, 0x02, 0x00, 0x00, 0x00, 0x00, 0x35, 0x01, 0x66, 0x02, 0xD0, + 0x06, 0x40, 0x0A, 0x00, 0x00, 0x55, 0x86, 0x02, 0x58, 0x00, 0x01, 0x1E, + 0x19, 0x00, 0x32, 0x08, 0x00, 0x00, 0x00, 0x05, 0x55, 0x00, 0x00, 0x00, + 0x00, 0x97, 0x08, 0x28, 0xBE, 0x40, 0x00, 0x40, 0x50, 0x50, 0x0A, 0x00, + 0x00, 0x00, 0x00, 0xF3, 0xF8, 0x00, 0x00, 0x02, 0xD0, 0x06, 0x40, 0x00, + 0x00, 0x00, 0x00, 0x02, 0x01, 0x60, 0x60, 0x64, 0x50, 0x00, 0x28, 0x1E, + 0xFF, 0xFF, 0x1E, 0x02, 0x00, 0x28, 0x05, 0x50, 0x00, 0x03, 0x15, 0x41, + 0x41, 0x08, 0x08, 0x04, 0x05, 0x00, 0x00, 0x00, 0x20, 0xFF, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x40, 0x20, 0x20, 0x00, 0x05, 0x14, 0x1E, 0x0A, + 0x07, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFA, 0x00, 0x40, + 0x40, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x02, 0x00, 0x00, + 0x64, 0x40, 0x00, 0x00, 0x00, 0x1E, 0x96, 0x28, 0x4B, 0x05, 0x14, 0x78, + 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, + 0x51, 0x97, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x02, 0x00, 0x02, 0x00, + 0x00, 0x10, 0x04, 0x19, 0x1E, 0x0F, 0x18, 0x10, 0x08, 0x40, 0x20, 0x10, + 0x03, 0x02, 0x01, 0x02, 0x01, 0x02, 0x00, 0x03, 0x0E, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x03, 0x0E, 0x80, 0x0C, + 0x07, 0x0F, 0x16, 0x24, 0x36, 0x3C, 0x1C, 0x00, 0x00, 0x00, 0x0A, 0x28, + 0x00, 0x28, 0x00, 0x80, 0x80, 0x18, 0x14, 0x22, 0x33, 0x80, 0xA0, 0x06, + 0x07, 0x03, 0x08, 0x60, 0x60, 0x10, 0x02, 0x20, 0x40, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x1E, 0x3C, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x12, 0x20, + 0x4B, 0x01, 0xF4, 0x03, 0x02, 0x3C, 0x1E, 0x19, 0x83, 0x02, 0x26, 0x00, + 0x01, 0x00, 0xCF, 0x01, 0x1A, 0x21, 0x00, 0xCF, 0x01, 0x18, 0x43, 0x00, + 0xAE, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCF, 0x01, + 0x1A, 0x00, 0xCF, 0x01, 0x18, 0x61, 0xF1, 0x62, 0x02, 0x00, 0x00, 0x81, + 0x00, 0xAE, 0x07, 0xFF, 0xFF, 0x01, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xC0, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x01, 0x63, + 0x02, 0x5A, 0x03, 0x4D, 0x04, 0x40, 0x05, 0x33, 0x06, 0x2A, 0x07, 0x10, + 0x07, 0xFD, 0x09, 0x03, 0x09, 0xF0, 0x0A, 0xD6, 0x0B, 0xCD, 0x0C, 0xC0, + 0x0D, 0xB3, 0x0E, 0xA6, 0x0F, 0x9D, 0x10, 0xCD, 0x80, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x01, 0x1F, + 0x02, 0x00, 0x03, 0x00, 0x04, 0x00, 0x05, 0x00, 0x06, 0x00, 0x07, 0x00, + 0x00, 0x00, 0x08, 0x00, 0xEC, 0xE9, 0xE6, 0xE1, 0xE1, 0xDD, 0xD9, 0xD6, + 0xD6, 0xD4, 0xD3, 0xCD, 0xCB, 0xCA, 0xC8, 0xC3, 0xC2, 0xC0, 0xBE, 0xBB, + 0xBC, 0xBA, 0xB7, 0xB5, 0xB4, 0xB3, 0xAF, 0xAF, 0xAF, 0xAB, 0xAD, 0xAD, + 0xAC, 0xAD, 0xBD, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x12, 0x20, 0x33, 0xC1, 0x98, 0xA2, 0x00, 0x03, 0x10, + 0xFF, 0x90, 0xC3, 0x00, 0x00, 0xC1, 0x5E, 0x5A, 0x03, 0x5A, 0x03, 0x08, + 0x08, 0x03, 0x06, 0x1D, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x11, 0x14, 0x17, 0x1D, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, + 0x17, 0x14, 0x11, 0x15, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, + 0x11, 0x13, 0x00, 0x14, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, + 0x10, 0x12, 0x00, 0x00, 0x00, 0x01, 0x02, 0x04, 0x05, 0x06, 0x00, 0x00, + 0x03, 0xE8, 0x20, 0x02, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x09, 0x01, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0xFF, 0x34, 0x03, 0x90, 0xB3, + 0x00, 0x00, 0x00, 0x00, 0x40, 0x0A, 0x00, 0x01, 0x03, 0x43, 0x00, 0x10, + 0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x35, 0x0D, 0x35, 0x0D, 0x35, 0x0D, + 0x06, 0x56, 0x1F, 0x1F, 0x41, 0x00, 0x92, 0x11, 0x01, 0x30, 0x04, 0x44, + 0x00, 0xE0, 0x01, 0x60, 0x05, 0x80, 0x01, 0xC0, 0x02, 0xC8, 0x02, 0xE9, + 0x03, 0x0A, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x12, + 0x14, 0x00, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x13, + 0x15, 0x00, 0x01, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x13, + 0x15, 0x17, 0x00, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x12, + 0x14, 0x16, 0x0F, 0xFF, 0x0F, 0xFF, 0x00, 0x00, 0x00, 0x55, 0x55, 0x55, + 0x19, 0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, + 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, + 0x01, 0x00, 0x1F, 0x1E, 0x1D, 0x1C, 0x1B, 0x1A, 0x1A, 0x1B, 0x1C, 0x1D, + 0x1E, 0x1F, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, + 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, + 0x16, 0x17, 0x18, 0x19, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, + 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, + 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x00, 0x00, 0x88, 0x88, + 0x43, 0x43, 0x43, 0x43, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF1, 0x03, 0x7D, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x88, 0x88, 0x88, 0x88, 0x00, 0xA0, 0x00, 0xA0, 0x00, 0x0F, 0x00, 0x60, + 0x03, 0x88, 0x66, 0x03, 0x88, 0x66, 0x00, 0x0C, 0x0C, 0x0C, 0x00, 0x50, + 0x71, 0x00, 0x23, 0x43, 0x0B, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0x88, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x20, 0x1C, 0x20, 0x1C, 0x20, 0x1C, 0x20, 0x04, + 0x0A, 0x0A, 0x0A, 0x0D, 0x28, 0x08, 0x00, 0x33, 0x00, 0x00, 0x03, 0x00, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x11, 0x14, 0x17, + 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x17, 0x14, 0x11, + 0x00, 0x88, 0x00, 0xCB, 0x00, 0x00, 0x00, 0x00, 0xA8, 0x5C, 0x01, 0x08, + 0x09, 0x09, 0x0F, 0xFF, 0x00, 0x04, 0x5A, 0x03, 0x5A, 0x03, 0x5A, 0x0A, + 0x08, 0x81, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x1F, 0x00, 0xE0, 0x00, 0xE0, + 0x2B, 0xD3, 0x5A, 0x0A, 0x08, 0x81, 0x00, 0x00, 0x20, 0x1C, 0x40, 0x80, + 0x00, 0x1F, 0x20, 0x04, 0x03, 0xF3, 0x5A, 0x0A, 0x08, 0x85, 0x00, 0x00, + 0x20, 0x0C, 0x00, 0x1F, 0x00, 0xE0, 0x00, 0xE0, 0x2B, 0xD3, 0x5A, 0x0A, + 0x08, 0x83, 0x00, 0x00, 0x20, 0x10, 0x40, 0x7D, 0x00, 0x1F, 0x20, 0xD0, + 0x04, 0x0C, 0x5A, 0x0A, 0x08, 0x8B, 0x00, 0x00, 0x40, 0x0B, 0x00, 0x1F, + 0x00, 0xE0, 0x00, 0xE0, 0x30, 0x00, 0x5A, 0x0A, 0x08, 0x85, 0x00, 0x00, + 0x23, 0x1F, 0x40, 0x7B, 0x00, 0x1F, 0x21, 0x59, 0x04, 0x1D, 0x5A, 0x0A, + 0x08, 0x91, 0x00, 0x00, 0x60, 0x0B, 0x00, 0x1F, 0x00, 0xE0, 0x00, 0xE0, + 0x30, 0x00, 0x5A, 0x0A, 0x08, 0x87, 0x00, 0x00, 0x23, 0x1C, 0x40, 0x78, + 0x00, 0x1F, 0x22, 0x2D, 0x04, 0x37, 0x5A, 0x0A, 0x08, 0x97, 0x00, 0x00, + 0x00, 0x0A, 0x00, 0x1F, 0x00, 0xE0, 0x00, 0xE0, 0x35, 0x0D, 0x5A, 0x0A, + 0x08, 0x89, 0x00, 0x00, 0x26, 0xD3, 0x40, 0x76, 0x00, 0x1F, 0x22, 0xC5, + 0x04, 0x4A, 0x5A, 0x0A, 0x08, 0xA1, 0x00, 0x00, 0x00, 0x09, 0x00, 0x1F, + 0x00, 0xE0, 0x00, 0xE0, 0x3B, 0x4B, 0x5A, 0x0A, 0x08, 0x8B, 0x00, 0x00, + 0x2B, 0x54, 0x80, 0x74, 0x00, 0x1F, 0x23, 0x36, 0x04, 0x5D, 0x5A, 0x0A, + 0x08, 0xA3, 0x00, 0x00, 0x20, 0x09, 0x00, 0x1F, 0x00, 0xE0, 0x00, 0xE0, + 0x3B, 0x4B, 0x5A, 0x0A, 0x08, 0x8D, 0x00, 0x00, 0x2B, 0x49, 0xA0, 0x72, + 0x00, 0x1F, 0x23, 0xD2, 0x04, 0x70, 0x5A, 0x0A, 0x08, 0xAF, 0x00, 0x00, + 0x20, 0x08, 0x00, 0x1F, 0x00, 0xE0, 0x00, 0xE0, 0x43, 0x33, 0x5A, 0x0A, + 0x08, 0x8D, 0x00, 0x00, 0x30, 0xFB, 0x40, 0x72, 0x00, 0x1F, 0x23, 0xF9, + 0x04, 0x70, 0x5A, 0x0A, 0x08, 0xB3, 0x00, 0x00, 0x40, 0x08, 0x00, 0x1F, + 0x00, 0xE0, 0x00, 0xE0, 0x43, 0x33, 0x5A, 0x0A, 0x08, 0x8F, 0x00, 0x00, + 0x31, 0x1B, 0x40, 0x70, 0x00, 0x1F, 0x24, 0xA2, 0x04, 0x85, 0x5A, 0x0A, + 0x08, 0xB9, 0x00, 0x00, 0x20, 0x08, 0x00, 0x1F, 0x00, 0xE0, 0x00, 0xE0, + 0x43, 0x33, 0x5A, 0x0A, 0x08, 0x91, 0x00, 0x00, 0x30, 0xFB, 0x40, 0x6E, + 0x00, 0x1F, 0x25, 0x4D, 0x04, 0x9A, 0x5A, 0x0A, 0x08, 0xBF, 0x00, 0x00, + 0x80, 0x07, 0x00, 0x1F, 0x00, 0xE0, 0x00, 0xE0, 0x4D, 0x89, 0x5A, 0x0A, + 0x08, 0x93, 0x00, 0x00, 0x38, 0xD6, 0x80, 0x6C, 0x00, 0x1F, 0x25, 0xD4, + 0x04, 0xB0, 0x5A, 0x0A, 0x08, 0x8D, 0x00, 0x01, 0x80, 0x07, 0x00, 0x1F, + 0x00, 0xE0, 0x00, 0xE0, 0x4D, 0x89, 0x5A, 0x0A, 0x08, 0x95, 0x00, 0x00, + 0x38, 0xD6, 0x40, 0x6A, 0x00, 0x1F, 0x26, 0xB3, 0x04, 0xC6, 0x5A, 0x0A, + 0x08, 0x9D, 0x00, 0x01, 0x40, 0x06, 0x00, 0x1F, 0x00, 0xE0, 0x00, 0xE0, + 0x5B, 0xA2, 0x5A, 0x0A, 0x08, 0x9D, 0x00, 0x00, 0x42, 0xE8, 0xA0, 0x63, + 0x00, 0x1F, 0x29, 0x49, 0x05, 0x1D, 0x5A, 0x0A, 0x08, 0xB1, 0x00, 0x01, + 0x40, 0x06, 0x00, 0x1F, 0x00, 0xE0, 0x00, 0xE0, 0x5B, 0xA2, 0x5A, 0x0A, + 0x08, 0x9F, 0x00, 0x00, 0x42, 0xE8, 0xA0, 0x62, 0x00, 0x1F, 0x29, 0xB8, + 0x05, 0x2B, 0x00, 0x3C, 0x00, 0x4A, 0x00, 0x5A, 0x00, 0x6A, 0x00, 0x7C, + 0x00, 0x8E, 0x00, 0xA1, 0x00, 0xB5, 0x00, 0xCA, 0x00, 0xDF, 0x00, 0xF5, + 0x01, 0x0B, 0x01, 0x21, 0x01, 0x37, 0x01, 0x4E, 0x01, 0x64, 0x01, 0x79, + 0x01, 0x8E, 0x01, 0xA3, 0x01, 0xB6, 0x01, 0xC9, 0x01, 0xDB, 0x01, 0xEB, + 0x01, 0xFA, 0x02, 0x08, 0x02, 0x14, 0x02, 0x1F, 0x02, 0x28, 0x02, 0x30, + 0x02, 0x35, 0x02, 0x39, 0x02, 0x3B, 0x00, 0x50, 0x00, 0x5F, 0x00, 0x6F, + 0x00, 0x80, 0x00, 0x91, 0x00, 0xA3, 0x00, 0xB6, 0x00, 0xC9, 0x00, 0xDD, + 0x00, 0xF0, 0x01, 0x04, 0x01, 0x18, 0x01, 0x2C, 0x01, 0x40, 0x01, 0x54, + 0x01, 0x67, 0x01, 0x7A, 0x01, 0x8C, 0x01, 0x9E, 0x01, 0xAF, 0x01, 0xBF, + 0x01, 0xCE, 0x01, 0xDC, 0x01, 0xE9, 0x01, 0xF5, 0x01, 0xFF, 0x02, 0x08, + 0x02, 0x0F, 0x02, 0x16, 0x02, 0x1A, 0x02, 0x1D, 0x02, 0x1F, 0x00, 0x21, + 0x00, 0x2C, 0x00, 0x3A, 0x00, 0x49, 0x00, 0x59, 0x00, 0x6B, 0x00, 0x7E, + 0x00, 0x92, 0x00, 0xA8, 0x00, 0xBF, 0x00, 0xD7, 0x00, 0xF0, 0x01, 0x0A, + 0x01, 0x24, 0x01, 0x3E, 0x01, 0x59, 0x01, 0x73, 0x01, 0x8E, 0x01, 0xA8, + 0x01, 0xC1, 0x01, 0xD9, 0x01, 0xF0, 0x02, 0x06, 0x02, 0x1A, 0x02, 0x2C, + 0x02, 0x3D, 0x02, 0x4B, 0x02, 0x58, 0x02, 0x61, 0x02, 0x69, 0x02, 0x6E, + 0x02, 0x71, 0x00, 0x2D, 0x00, 0x3A, 0x00, 0x48, 0x00, 0x58, 0x00, 0x69, + 0x00, 0x7B, 0x00, 0x8F, 0x00, 0xA3, 0x00, 0xB9, 0x00, 0xCF, 0x00, 0xE6, + 0x00, 0xFE, 0x01, 0x16, 0x01, 0x2E, 0x01, 0x47, 0x01, 0x5F, 0x01, 0x77, + 0x01, 0x8F, 0x01, 0xA6, 0x01, 0xBD, 0x01, 0xD2, 0x01, 0xE6, 0x01, 0xFA, + 0x02, 0x0B, 0x02, 0x1B, 0x02, 0x2A, 0x02, 0x36, 0x02, 0x41, 0x02, 0x4A, + 0x02, 0x50, 0x02, 0x55, 0x02, 0x57, 0x00, 0x18, 0x00, 0x22, 0x00, 0x2E, + 0x00, 0x3C, 0x00, 0x4B, 0x00, 0x5C, 0x00, 0x6E, 0x00, 0x83, 0x00, 0x98, + 0x00, 0xB0, 0x00, 0xC8, 0x00, 0xE2, 0x00, 0xFD, 0x01, 0x18, 0x01, 0x35, + 0x01, 0x51, 0x01, 0x6E, 0x01, 0x8B, 0x01, 0xA7, 0x01, 0xC3, 0x01, 0xDE, + 0x01, 0xF7, 0x02, 0x0F, 0x02, 0x26, 0x02, 0x3B, 0x02, 0x4E, 0x02, 0x5E, + 0x02, 0x6C, 0x02, 0x77, 0x02, 0x80, 0x02, 0x86, 0x02, 0x89, 0x00, 0x09, + 0x00, 0x0E, 0x00, 0x15, 0x00, 0x1D, 0x00, 0x26, 0x00, 0x31, 0x00, 0x3E, + 0x00, 0x4B, 0x00, 0x5B, 0x00, 0x6C, 0x00, 0x7E, 0x00, 0x91, 0x00, 0xA6, + 0x00, 0xBC, 0x00, 0xD2, 0x00, 0xEA, 0x01, 0x02, 0x01, 0x1A, 0x01, 0x32, + 0x01, 0x4A, 0x01, 0x61, 0x01, 0x77, 0x01, 0x8D, 0x01, 0xA1, 0x01, 0xB4, + 0x01, 0xC5, 0x01, 0xD4, 0x01, 0xE0, 0x01, 0xEB, 0x01, 0xF3, 0x01, 0xF8, + 0x01, 0xFB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x39, 0xCE, 0x39, 0xCE, 0x39, 0xCE, + 0x39, 0xCE, 0x39, 0xCE, 0x39, 0xCE, 0x39, 0xCE, 0x39, 0xCE, 0x39, 0xCE, + 0x39, 0xCE, 0x39, 0xCE, 0x39, 0xCE, 0x39, 0xCE, 0x39, 0xCE, 0x39, 0xCE, + 0x39, 0xCE, 0x39, 0xCE, 0x39, 0xCE, 0x39, 0xCE, 0x39, 0xCE, 0x39, 0xCE, + 0x39, 0xCE, 0x39, 0xCE, 0x39, 0xCE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, + 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, + 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, + 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, + 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x77, + 0xA4, 0xF9 +}; +#endif //end of ST_UPGRADE_USE_REQUESTFW_BUF diff --git a/drivers/input/touchscreen/sitronix_st7123/sitronix_ts_utility.c b/drivers/input/touchscreen/sitronix_st7123/sitronix_ts_utility.c new file mode 100644 index 00000000000000..2bbae024991d14 --- /dev/null +++ b/drivers/input/touchscreen/sitronix_st7123/sitronix_ts_utility.c @@ -0,0 +1,1837 @@ +// SPDX-License-Identifier: GPL-2.0 +#include "sitronix_ts.h" +#include "sitronix_st7123.h" + +//rawdata parameters +int rawdataType; //0 = disable, 1 = rawdata, 2 = delta +int *rawBase; //baseline +// +int sitronix_ts_get_device_status(struct sitronix_ts_data *ts_data) +{ + int ret; + uint8_t buf[8]; + + ret = sitronix_ts_reg_read(ts_data, STATUS_REG, buf, sizeof(buf)); + if (ret < 0) { + sterr("%s: Read Status register error!(%d)\n", __func__, ret); + return ret; + } + + stmsg("buf = %X, %X, %X, %X, %X, %X, %X, %X\n", buf[0], buf[1], buf[2], + buf[3], buf[4], buf[5], buf[6], buf[7]); + stmsg("Status register = %d.\n", (buf[0] & 0xFF)); + + return (int)(buf[0] & 0x0F); +} + +static int sitronix_ts_get_fw_revision(struct sitronix_ts_data *ts_data) +{ + int ret = 0; + uint8_t buf[4]; + + ret = sitronix_ts_reg_read(ts_data, FIRMWARE_VERSION, buf, 1); + if (ret < 0) { + sterr("%s: Read FW Version error!(%d)\n", __func__, ret); + return ret; + } + + ts_data->ts_dev_info.fw_version = buf[0]; + stmsg("FW Version (hex) = %x\n", buf[0]); + + ret = sitronix_ts_reg_read(ts_data, FIRMWARE_REVISION_3, buf, + sizeof(buf)); + if (ret < 0) { + sterr("%s: Read FW revision error!(%d)\n", __func__, ret); + return ret; + } + + memcpy(&ts_data->ts_dev_info.fw_revision, buf, 4); + stmsg("FW revision (hex) = %x %x %x %x\n", buf[0], buf[1], buf[2], + buf[3]); + + return 0; +} + +static int sitronix_ts_get_max_touches(struct sitronix_ts_data *ts_data) +{ + int ret = 0; + uint8_t max_touches; + + ret = sitronix_ts_reg_read(ts_data, MAX_NUM_TOUCHES, &max_touches, + sizeof(max_touches)); + if (ret < 0) { + sterr("%s: Read max touches error!(%d)\n", __func__, ret); + return ret; + } + + ts_data->ts_dev_info.max_touches = max_touches; + stmsg("Max touches = %d.\n", ts_data->ts_dev_info.max_touches); + + return 0; +} + +static int sitronix_ts_get_chip_id(struct sitronix_ts_data *ts_data) +{ + int ret = 0; + uint8_t chip_id; + + ret = sitronix_ts_reg_read(ts_data, CHIP_ID, &chip_id, sizeof(chip_id)); + if (ret < 0) { + sterr("%s: Read chip ID error!(%d)\n", __func__, ret); + return ret; + } + + ts_data->ts_dev_info.chip_id = chip_id; + stmsg("Chip ID = 0x%X.\n", ts_data->ts_dev_info.chip_id); + + return 0; +} + +static int sitronix_ts_get_xy_chs(struct sitronix_ts_data *ts_data) +{ + int ret = 0; + uint8_t buf[18]; + + ret = TDU_FWInfoRead(2, buf, sizeof(buf)); + if (ret < 0) { + sterr("%s: Read XY channels error!(%d)\n", __func__, ret); + //return ret; + } + + ts_data->ts_dev_info.x_chs = buf[2]; + ts_data->ts_dev_info.y_chs = buf[3]; + ts_data->ts_dev_info.k_chs = buf[4]; + stmsg("X_chs = %d.\n", ts_data->ts_dev_info.x_chs); + stmsg("Y_chs = %d.\n", ts_data->ts_dev_info.y_chs); + stmsg("K_chs = %d.\n", ts_data->ts_dev_info.k_chs); + + ts_data->ts_dev_info.n_chs = (buf[5] & 0x78) >> 3; + //stmsg("n_chs = %d.\n", ts_data->ts_dev_info.n_chs); + ts_data->ts_dev_info.max_swk_touch_num = buf[13]; + stmsg("swk_num = %d.\n", ts_data->ts_dev_info.max_swk_touch_num); + return 0; +} + +static int sitronix_ts_get_resolution(struct sitronix_ts_data *ts_data) +{ + int ret = 0; + uint8_t buf[4]; + + ret = sitronix_ts_reg_read(ts_data, X_RESOLUTION_HIGH, buf, + sizeof(buf)); + if (ret < 0) { + sterr("%s: Read resolution error!(%d)\n", __func__, ret); + return ret; + } + + ts_data->ts_dev_info.x_res = (((uint16_t)buf[0] & 0x3F) << 8) | buf[1]; + ts_data->ts_dev_info.y_res = (((uint16_t)buf[2] & 0x3F) << 8) | buf[3]; + stmsg("Resolution = %u x %u\n", ts_data->ts_dev_info.x_res, + ts_data->ts_dev_info.y_res); + + return 0; +} + +static int sitronix_ts_get_customer_info(struct sitronix_ts_data *ts_data) +{ + int ret = 0; + uint8_t buf[4]; + uint8_t bank; + + ret = sitronix_ts_reg_read(ts_data, MISC_CONTROL, buf, 1); + if (ret < 0) { + sterr("%s: Read MISC_CONTROL error!(%d)\n", __func__, ret); + return ret; + } + + bank = buf[0]; + buf[0] = (buf[0] & 0xFC) | 1; + ret = sitronix_ts_reg_write(ts_data, MISC_CONTROL, buf, 1); + + ret = sitronix_ts_reg_read(ts_data, FIRMWARE_REVISION_3, buf, + sizeof(buf)); + memcpy(&ts_data->ts_dev_info.customer_info, buf, 4); + stmsg("Customer Info (hex) = %x %x %x %x\n", buf[0], buf[1], buf[2], + buf[3]); + + buf[0] = bank; + ret = sitronix_ts_reg_write(ts_data, MISC_CONTROL, buf, 1); + return 0; +} + +static int sitronix_ts_get_misc_info(struct sitronix_ts_data *ts_data) +{ + int ret = 0; + uint8_t misc_info; + + ret = sitronix_ts_reg_read(ts_data, MISC_INFO, &misc_info, + sizeof(misc_info)); + if (ret < 0) { + sterr("%s: Read Misc. Info error!(%d)\n", __func__, ret); + return ret; + } + + ts_data->ts_dev_info.misc_info = misc_info; + ts_data->is_support_coord_chksum = + (misc_info & ST_MISC_INFO_COORD_CHKSUM_FLAG); + + stmsg("Misc. Info = 0x%X.\n", ts_data->ts_dev_info.misc_info); + + return 0; +} + +int sitronix_ts_get_device_info(struct sitronix_ts_data *ts_data) +{ + int ret; + + ret = sitronix_ts_get_fw_revision(ts_data); + if (ret) + return ret; + ret = sitronix_ts_get_customer_info(ts_data); + if (ret) + return ret; + ret = sitronix_ts_get_resolution(ts_data); + if (ret) + return ret; + ret = sitronix_ts_get_max_touches(ts_data); + if (ret) + return ret; + ret = sitronix_ts_get_chip_id(ts_data); + if (ret) + return ret; + ret = sitronix_ts_get_xy_chs(ts_data); + if (ret) + return ret; + ret = sitronix_ts_get_misc_info(ts_data); + if (ret) + return ret; + + return 0; +} + +int sitronix_ts_powerdown(struct sitronix_ts_data *ts_data, bool powerdown) +{ + int ret = 0; + uint8_t ctrl; + + ret = sitronix_ts_reg_read(ts_data, DEVICE_CONTROL_REG, &ctrl, 1); + if (ret < 0) { + sterr("%s: Read device control status error! (%d)\n", __func__, + ret); + return ret; + } + + ctrl = powerdown ? (ctrl | 0x02) : (ctrl & ~0x02); + + ret = sitronix_ts_reg_write(ts_data, DEVICE_CONTROL_REG, &ctrl, 1); + if (ret < 0) { + sterr("%s: Write power down error! (%d)\n", __func__, ret); + return ret; + } + + return 0; +} + +struct CommandIoPacket { + unsigned char CmdID; + unsigned char ValidDataSize; + unsigned char CmdData[30]; +}; + +void STChecksumCalculation(unsigned short *pChecksum, unsigned char *pInData, + unsigned long Len) +{ + unsigned long i; + unsigned char LowByteChecksum = 0; + + for (i = 0; i < Len; i++) { + *pChecksum += (unsigned short)pInData[i]; + LowByteChecksum = (unsigned char)(*pChecksum & 0xFF); + LowByteChecksum = (LowByteChecksum) >> 7 | (LowByteChecksum) + << 1; + *pChecksum = (*pChecksum & 0xFF00) | LowByteChecksum; + } +} + +static bool TDU_SetH2DReady(void) +{ + int ret; + bool bRet = false; + unsigned char buf[2]; + + buf[0] = 0xF8; + buf[1] = 0x01; + + /* ret = st_spi_write_bytes(0xF8, buf+1, 1); */ + ret = sitronix_ts_reg_write(gts, CMDIO_CONTROL, buf + 1, 1); + if (ret <= 0) { + sterr("%s: write ready error.\n", __func__); + bRet = false; + } else { + bRet = true; + } + return bRet; +} + +static bool TDU_GetH2DReady(void) +{ + bool bRet = false; + unsigned char tmp = 0xff; + int ret, retry = 0; + + do { + usleep_range(1000, 2000); + /* ret = st_spi_read_bytes(0xF8, &tmp, 1); */ + ret = sitronix_ts_reg_read(gts, CMDIO_CONTROL, &tmp, 1); + + if (ret <= 0) { + sterr("%s: retry(%d) read ready.\n", __func__, retry++); + } else { + if (tmp == 0x01) { + stdbg("retry ............\n"); + retry++; + ret = 0; + /* continue; */ + } + } + if (retry > 1000) { + sterr("%s: time out\n", __func__); + /* break; */ + bRet = false; + return bRet; + } + + } while (ret <= 0); + + if (tmp == 0x00) { /* OK */ + bRet = true; + } else if (tmp == 0x80) { + sterr("TDU_ReadIOCommand: Unknown Command ID.\n"); + bRet = false; + } else if (tmp == 0x81) { + sterr("TDU_ReadIOCommand: Host to device command checksum error.\n"); + bRet = false; + } else { + sterr("Unknown Error(0x%02X).\n", tmp); + bRet = false; + } + return bRet; +} + +static bool TDU_ReadIOCommand(struct CommandIoPacket *packet) +{ + bool bRet = false; + int ret; + unsigned char tmp[32]; + /* process command */ + memset(tmp, 0, 32); + /* ret = st_spi_read_bytes(0xD0, tmp, 32); */ + ret = sitronix_ts_reg_read(gts, CMDIO_PORT, tmp, 32); + if (ret <= 0) { + sterr("%s: read packet error.\n", __func__); + bRet = false; + } else { + memcpy(packet, tmp, 32); + bRet = true; + } + return bRet; +} + +static bool TDU_WriteIOCommand(struct CommandIoPacket *packet) +{ + bool bRet = false; + int ret; + unsigned char tmp[33]; + + memset(tmp, 0x00, 33); + memcpy(tmp + 1, packet, 32); + + tmp[0] = 0xD0; + /* ret = st_spi_write_bytes(0xD0, tmp+1, 32); */ + ret = sitronix_ts_reg_write(gts, CMDIO_PORT, tmp + 1, 32); + + if (ret <= 0) { + sterr("%s: write packet error.\n", __func__); + bRet = false; + } else { + bRet = true; + } + + return bRet; +} + +int TDU_CmdioRead(int type, int address, unsigned char *buf, int len) +{ + int getLen = 0, offset = 0; + struct CommandIoPacket outPacket; + struct CommandIoPacket inPacket; + int remain = len; + int pktDataSize = 0; + unsigned short chksum, vchksum; + int retry = 0; + + do { + pktDataSize = (remain > 24) ? 24 : remain; + outPacket.CmdID = 0x02; /* read RAM/ROM */ + outPacket.ValidDataSize = 5; + outPacket.CmdData[0] = type; /* RAM */ + outPacket.CmdData[3] = pktDataSize; + chksum = 0; + STChecksumCalculation(&chksum, (unsigned char *)&outPacket, 6); + outPacket.CmdData[4] = (chksum & 0xFF); + if (!TDU_WriteIOCommand(&outPacket)) { + stmsg("%s: (E)TDU_WriteIOCommand.\n", __func__); + goto TDU_CmdioRead_retry; + /* return getLen; */ + } + if (!TDU_SetH2DReady()) { + stmsg("%s: (E)TDU_SetH2DReady.\n", __func__); + goto TDU_CmdioRead_retry; + /* return getLen; */ + } + if (!TDU_GetH2DReady()) { + stmsg("%s: (E)TDU_GetH2DReady.\n", __func__); + goto TDU_CmdioRead_retry; + /* return getLen; */ + } + if (!TDU_ReadIOCommand(&inPacket)) { + stmsg("%s: (E)TDU_ReadIOCommand.\n", __func__); + goto TDU_CmdioRead_retry; + /* return getLen; */ + } + + if (inPacket.CmdID == 0x82 && inPacket.CmdData[0] == type) { + vchksum = 0; + STChecksumCalculation(&vchksum, + (unsigned char *)&inPacket, + inPacket.ValidDataSize + 1); + vchksum = (vchksum & 0xFF); + if (vchksum == + inPacket.CmdData[inPacket.ValidDataSize - 1]) { + memcpy(buf + offset, &(inPacket.CmdData[2]), + inPacket.CmdData[1]); + remain -= inPacket.CmdData[1]; /* data size */ + offset += inPacket.CmdData[1]; + getLen += inPacket.CmdData[1]; + retry = 0; + + } else { + /* drop packet */ + stmsg("Invalid Cheksum Expect(0x%02x) Get(0x%02X)\n", + vchksum, + inPacket.CmdData[inPacket.ValidDataSize - + 1]); + goto TDU_CmdioRead_retry; + } + } else { + /* drop packet */ + stmsg("Unexpect CmdID (0x%02x) or Type (0x%02X)\n", + inPacket.CmdID, inPacket.CmdData[0]); +TDU_CmdioRead_retry: + retry++; + sterr("%s_retry %d with add = %x, size = %d\n", + __func__, retry, (address + offset), pktDataSize); + if (retry > 10) + return -EIO; + } + + } while (remain > 0); + return getLen; +} + +int TDU_CmdioWrite(int type, int address, unsigned char *buf, int len) +{ + int setLen = 0, offset = 0; + struct CommandIoPacket outPacket; + /* CommandIoPacket inPacket; */ + int remain = len; + int pktDataSize = 0; + unsigned short chksum; /* , vchksum; */ + int retry = 0; + + do { + pktDataSize = (remain > 24) ? 24 : remain; + outPacket.CmdID = 0x01; /* write RAM/ROM */ + outPacket.ValidDataSize = pktDataSize + 5; + outPacket.CmdData[0] = type; + outPacket.CmdData[3] = pktDataSize; + memcpy(&outPacket.CmdData[4], buf + offset, pktDataSize); + chksum = 0; + STChecksumCalculation(&chksum, (unsigned char *)&outPacket, + outPacket.ValidDataSize + 1); + outPacket.CmdData[outPacket.ValidDataSize - 1] = + (chksum & 0xFF); + if (!TDU_WriteIOCommand(&outPacket)) { + sterr("TDU_SetDeviceRam: (E)TDU_WriteIOCommand.\n"); + goto TDU_CmdioWrite_retry; + /* return setLen; */ + } + if (!TDU_SetH2DReady()) { + sterr("TDU_SetDeviceRam: (E)TDU_SetH2DReady.\n"); + goto TDU_CmdioWrite_retry; + /* return setLen; */ + } + /* check processing result */ + if (!TDU_GetH2DReady()) { + sterr("TDU_SetDeviceRam: (E)TDU_GetH2DReady.\n"); + /* return setLen; */ +TDU_CmdioWrite_retry: + retry++; + sterr("TDU_CmdioWrite_retry %d with add = %x, size = %d\n", + retry, (address + offset), pktDataSize); + if (retry > 10) + return -EIO; + } else { + /* processing write command OK */ + remain -= pktDataSize; + offset += pktDataSize; + setLen += pktDataSize; + retry = 0; + } + + } while (remain > 0); + + return setLen; +} + +static int TDU_Cmdio_ReadFwControl(int ctrlID, unsigned char *inBuf, int inLen, + unsigned char *getBuf) +{ + int getLen = 0; + struct CommandIoPacket outPacket; + struct CommandIoPacket inPacket; + unsigned short chksum, vchksum; + + if (inLen > 28) + inLen = 28; + + outPacket.CmdID = 0x05; //FW control command + outPacket.ValidDataSize = inLen + 2; //1 for control id, 1 for checksum + outPacket.CmdData[0] = 0x80 | (ctrlID & 0xFF); //read + + memcpy(&outPacket.CmdData[1], inBuf, inLen); //control data + chksum = 0; + STChecksumCalculation(&chksum, (unsigned char *)&outPacket, + outPacket.ValidDataSize + 1); + + outPacket.CmdData[outPacket.ValidDataSize - 1] = (chksum & 0xFF); + + if (!TDU_WriteIOCommand(&outPacket)) { + sterr("%s(NewA): (E)WriteIOCommand.\n", __func__); + return getLen; + } + if (!TDU_SetH2DReady()) { + sterr("%s(NewA): (E)SetH2DReady.\n", __func__); + return getLen; + } + if (!TDU_GetH2DReady()) { + sterr("%s(NewA): (E)GetH2DReady.\n", __func__); + return getLen; + } + if (!TDU_ReadIOCommand(&inPacket)) { + sterr("%s(NewA): (E)ReadIOCommand.\n", __func__); + return getLen; + } + + if ((inPacket.CmdID == 0x85) && + (inPacket.CmdData[0] == (0x80 | (ctrlID & 0xFF)))) { + vchksum = 0; + STChecksumCalculation(&vchksum, (unsigned char *)&inPacket, + inPacket.ValidDataSize + 1); + vchksum = (vchksum & 0xFF); + if (vchksum == inPacket.CmdData[inPacket.ValidDataSize - 1]) { + memcpy(getBuf, &(inPacket.CmdData[1]), + inPacket.ValidDataSize - 2); + getLen += (inPacket.ValidDataSize - 2); + } else { + //drop packet + sterr("%s(NewA): Invalid Cheksum Expect(0x%02x) Get(0x%02X)\n", + __func__, vchksum, + inPacket.CmdData[inPacket.ValidDataSize - 1]); + return -1; + } + + } else { + sterr("%s(NewA): Unknown Commad(0x%02X) or control info(0x%02X)\n", + __func__, inPacket.CmdID, inPacket.CmdData[0]); + return -1; + } + return getLen; +} + +static int TDU_Cmdio_WriteFwControl(int ctrlID, unsigned char *buf, int len) +{ + int setLen = 0; + struct CommandIoPacket outPacket; + unsigned short chksum; + + if (len > 28) + len = 28; + + outPacket.CmdID = 0x05; //FW control command + outPacket.ValidDataSize = len + 2; //1 for CtrlID, 1 for checksum + outPacket.CmdData[0] = (ctrlID & 0xFF); + memcpy(&outPacket.CmdData[1], buf, len); + + chksum = 0; + STChecksumCalculation(&chksum, (unsigned char *)&outPacket, + outPacket.ValidDataSize + 1); + outPacket.CmdData[outPacket.ValidDataSize - 1] = (chksum & 0xFF); + + if (!TDU_WriteIOCommand(&outPacket)) { + sterr("%s(NewA): (E)WriteIOCommand.\n", __func__); + return setLen; + } + if (!TDU_SetH2DReady()) { + sterr("%s(NewA): (E)SetH2DReady.\n", __func__); + return setLen; + } + //check processing result + if (!TDU_GetH2DReady()) { + sterr("%s(NewA): (E)GetH2DReady.\n", __func__); + return setLen; + } + //processing write command OK + setLen += len; + + return setLen; +} + +// mode=0: SWK mode. +// mode=1: Gesture mode. +static int TDU_Cmdio_ReadSWKConfig(int mode, unsigned char *buf, int buf_len) +{ + int get_len = 0; + struct CommandIoPacket outPacket; + struct CommandIoPacket inPacket; + unsigned short chksum, vchksum; + + memset(&outPacket, 0, sizeof(outPacket)); + memset(&inPacket, 0, sizeof(inPacket)); + + outPacket.CmdID = 0x07; //SWK config command + outPacket.ValidDataSize = + buf_len + 2; //1 for Control Info, 1 for checksum + outPacket.CmdData[0] = 0x80 | (mode << 6); //read + + chksum = 0; + STChecksumCalculation(&chksum, (unsigned char *)&outPacket, + outPacket.ValidDataSize + 1); + + outPacket.CmdData[outPacket.ValidDataSize - 1] = (chksum & 0xFF); + + if (!TDU_WriteIOCommand(&outPacket)) { + sterr("%s: (E)WriteIOCommand.\n", __func__); + return get_len; + } + if (!TDU_SetH2DReady()) { + sterr("%s: (E)SetH2DReady.\n", __func__); + return get_len; + } + if (!TDU_GetH2DReady()) { + sterr("%s: (E)GetH2DReady.\n", __func__); + return get_len; + } + if (!TDU_ReadIOCommand(&inPacket)) { + sterr("%s: (E)ReadIOCommand.\n", __func__); + return get_len; + } + + if ((inPacket.CmdID == 0x87) && (inPacket.CmdData[0] & 0x80)) { + vchksum = 0; + STChecksumCalculation(&vchksum, (unsigned char *)&inPacket, + inPacket.ValidDataSize + 1); + vchksum = (vchksum & 0xFF); + if (vchksum == inPacket.CmdData[inPacket.ValidDataSize - 1]) { + //memcpy(buf, &(inPacket.CmdData[1]), inPacket.ValidDataSize - 2); + memcpy(buf, &(inPacket.CmdData[1]), buf_len); + get_len += (inPacket.ValidDataSize - 2); + stmsg("%s: buf_len=%u, get_len=%u.\n", __func__, + buf_len, get_len); + } else { + //drop packet + sterr("%s: Invalid Cheksum Expect(0x%02x) Get(0x%02X)\n", + __func__, vchksum, + inPacket.CmdData[inPacket.ValidDataSize - 1]); + return -1; + } + } else { + sterr("%s: Unknown Commad(0x%02X) or control info(0x%02X)\n", + __func__, inPacket.CmdID, inPacket.CmdData[0]); + return -1; + } + + return get_len; +} + +// mode=0: SWK mode. +// mode=1: Gesture mode. +static int TDU_Cmdio_WriteSWKConfig(int mode, unsigned char *buf, int len) +{ + int set_len = 0; + struct CommandIoPacket outPacket; + unsigned short chksum; + + memset(&outPacket, 0, sizeof(outPacket)); + + if (len > 28) + len = 28; + + outPacket.CmdID = 0x07; //SWK config command + outPacket.ValidDataSize = len + 2; //1 for Control Info, 1 for checksum + outPacket.CmdData[0] = (mode << 6); //write config + memcpy(&outPacket.CmdData[1], buf, len); + + chksum = 0; + STChecksumCalculation(&chksum, (unsigned char *)&outPacket, + outPacket.ValidDataSize + 1); + outPacket.CmdData[outPacket.ValidDataSize - 1] = (chksum & 0xFF); + + if (!TDU_WriteIOCommand(&outPacket)) { + sterr("%s: (E)WriteIOCommand.\n", __func__); + return set_len; + } + if (!TDU_SetH2DReady()) { + sterr("%s: (E)SetH2DReady.\n", __func__); + return set_len; + } + //check processing result + if (!TDU_GetH2DReady()) { + sterr("%s: (E)GetH2DReady.\n", __func__); + return set_len; + } + //processing write command OK + set_len += len; + + return set_len; +} + +int TDU_FWInfoRead(int type, unsigned char *buf, int len) +{ + int getLen = 0, offset = 0; + struct CommandIoPacket outPacket; + struct CommandIoPacket inPacket; + int remain = len; + int pktDataSize = 0; + unsigned short chksum, vchksum; + int retry = 0; + + do { + pktDataSize = (remain > 24) ? 24 : remain; + outPacket.CmdID = 0x04; /* FW information read */ + outPacket.ValidDataSize = 2; + outPacket.CmdData[0] = type; /* RAM */ + chksum = 0; + STChecksumCalculation(&chksum, (unsigned char *)&outPacket, 3); + outPacket.CmdData[1] = (chksum & 0xFF); + + if (!TDU_WriteIOCommand(&outPacket)) { + stmsg("%s: (E)TDU_WriteIOCommand.\n", __func__); + goto TDU_FWInfoRead_retry; + /* return getLen; */ + } + if (!TDU_SetH2DReady()) { + stmsg("%s: (E)TDU_SetH2DReady.\n", __func__); + goto TDU_FWInfoRead_retry; + /* return getLen; */ + } + if (!TDU_GetH2DReady()) { + stmsg("%s: (E)TDU_GetH2DReady.\n", __func__); + goto TDU_FWInfoRead_retry; + /* return getLen; */ + } + if (!TDU_ReadIOCommand(&inPacket)) { + stmsg("%s: (E)TDU_ReadIOCommand.\n", __func__); + goto TDU_FWInfoRead_retry; + /* return getLen; */ + } + + if (inPacket.CmdID == 0x84 && inPacket.CmdData[0] == type) { + vchksum = 0; + STChecksumCalculation(&vchksum, + (unsigned char *)&inPacket, + inPacket.ValidDataSize + 1); + vchksum = (vchksum & 0xFF); + if (vchksum == + inPacket.CmdData[inPacket.ValidDataSize - 1]) { + memcpy(buf + offset, &(inPacket.CmdData[0]), + len); + remain = 0; + getLen = len; + retry = 0; + } else { + /* drop packet */ + stmsg("Invalid Cheksum Expect(0x%02x) Get(0x%02X)\n", + vchksum, + inPacket.CmdData[inPacket.ValidDataSize - + 1]); + goto TDU_FWInfoRead_retry; + } + } else { + /* drop packet */ + stmsg("Unexpect CmdID (0x%02x) or Type (0x%02X)\n", + inPacket.CmdID, inPacket.CmdData[0]); +TDU_FWInfoRead_retry: + retry++; + sterr("%s_retry %d with add = %x, size = %d\n", + __func__, retry, offset, pktDataSize); + if (retry > 10) + return -EIO; + } + + } while (remain > 0); + return getLen; +} + +static int TDU_FWControlRead(int modeID, unsigned char *buf, int len) +{ + //buf[0] = 0x80; + unsigned char rbuf[30]; + unsigned char wbuf[30]; + unsigned char rLen = 0; + unsigned char wLen = 0; + + memset(rbuf, 0, sizeof(rbuf)); + memset(wbuf, 0, sizeof(wbuf)); + + wbuf[wLen++] = modeID & 0xff; //mode id + + rLen = TDU_Cmdio_ReadFwControl(0x01, wbuf, wLen, rbuf); + memcpy(buf, rbuf + 1, len); + stmsg("Read Mode[%02X] = %02X\n", rbuf[0], buf[0]); + return 0; +} + +static int TDU_FWControlWrite(int modeID, unsigned char *buf, int len) +{ + unsigned char wbuf[30]; + int wLen = 0, ret = 0; + + memset(wbuf, 0, sizeof(wbuf)); + wbuf[wLen++] = modeID & 0xFF; //mode id + memcpy(wbuf + wLen, buf, len); //flag + wLen = wLen + len; + ret = TDU_Cmdio_WriteFwControl(0x01, wbuf, wLen); + stmsg("Write Mode[%02X] = %02X (wLen = %d)\n", wbuf[0], wbuf[1], wLen); + return ret; +} + +int sitronix_mode_switch_value(int modeID, bool flag, unsigned char value) +{ + int ret = 0; + unsigned char buf[2]; + + stmsg("modeID: %d , flag: %d , value: %x\n", modeID, flag, value); + if (modeID > ST_MODE_SIZE) { + sterr("%s modeID range error : %x\n", __func__, modeID); + return -EINVAL; + } + + buf[0] = flag ? ST_MODE_SWITCH_ON : ST_MODE_SWITCH_OFF; + buf[0] |= value; + + ret = TDU_FWControlWrite(modeID, buf, 1); + if (ret < 0) { + sterr("TDU_FWControlWrite fail with error : %d\n", ret); + return ret; + } + usleep_range(10000, 11000); + ret = TDU_FWControlRead(modeID, buf + 1, 1); + if (ret < 0) { + sterr("TDU_FWControlRead fail with error : %d\n", ret); + return ret; + } + + if (buf[1] != buf[0]) { + sterr("Mode switch fail with compare different\n"); + return -EINVAL; + } + gts->mode_flag[modeID] = flag; + gts->mode_value[modeID] = value; + + stmsg("%s success with modeID: %x , flag : %d , value : %x\n", __func__, + modeID, flag, value); + return 0; +} + +int sitronix_mode_switch(int modeID, bool flag) +{ + return sitronix_mode_switch_value(modeID, flag, 0); +} + +void sitronix_mode_backup(void) +{ + int i; + u8 buf[1]; + + for (i = ST_MODE_RESTORE_START; i < ST_MODE_SIZE; i++) { + TDU_FWControlRead(i, buf, 1); + + gts->mode_flag[i] = (buf[0] & ST_MODE_SWITCH_ON) ? true : false; + gts->mode_value[i] = (buf[0] & ~ST_MODE_SWITCH_ON); + } +} + +void sitronix_mode_restore(void) +{ + int i = 0; + int ret = 0; + unsigned char buf[2]; + + for (i = ST_MODE_RESTORE_START; i < ST_MODE_SIZE; i++) { + buf[0] = gts->mode_flag[i] ? ST_MODE_SWITCH_ON : + ST_MODE_SWITCH_OFF; + buf[0] |= gts->mode_value[i]; + + TDU_FWControlRead(i, buf + 1, 1); + + if (buf[1] != buf[0]) + ret = TDU_FWControlWrite(i, buf, 1); + //msleep(30); + } + + if (gts->exdiff_flag) + sitronix_ts_exdiff_enable(gts, true); + + if (ret < 0) + stmsg("%s fail\n", __func__); + else + stmsg("%s success\n", __func__); +} + +void sitronix_swk_config_backup(void) +{ + int mode = 0; //0: SWK mode. + int ret = 0; + int i; + + if (gts) { + ret = TDU_Cmdio_ReadSWKConfig(mode, gts->swk_config, + sizeof(gts->swk_config)); + if (ret < 0) { + sterr("%s: TDU_Cmdio_ReadSWKConfig() failed!\n", + __func__); + gts->swk_config_def[0] = 0x01; + gts->swk_config_def[1] = 0x8F; + gts->swk_config_def[2] = 0xFF; + gts->swk_config_def[3] = 0x0F; + } else { + memcpy(gts->swk_config_def, gts->swk_config, + sizeof(gts->swk_config)); + } + + for (i = 0; i < ARRAY_SIZE(gts->swk_config); i++) { + stmsg("Read swk_config[%02X] = 0x%02X\n", i, + gts->swk_config[i]); + } + } +} + +void sitronix_swk_config_restore(void) +{ + int mode = 0; //0: SWK mode. + int ret = 0; + + if (gts) { + ret = TDU_Cmdio_WriteSWKConfig(mode, gts->swk_config, + sizeof(gts->swk_config)); + if (ret < 0) { + sterr("%s: TDU_Cmdio_WriteSWKConfig() failed!\n", + __func__); + } + } +} +int sitronix_get_ic_position(unsigned char *buf) +{ + uint8_t cmd[10] = { 0 }; + int ret = 0; + int off = 0; + + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0xA5; + cmd[5] = 0x3C; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x14; + cmd[5] = 0x55; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + + cmd[1] = 0x03; + cmd[2] = 0x06; + cmd[3] = 0xFC; + cmd[4] = 0x5A; + cmd[5] = 0x9D; + cmd[6] = 0xBD; + cmd[7] = 0x00; + cmd[8] = 0x00; + cmd[9] = 0x00; + + ret = sitronix_ts_addrmode_write(gts, cmd, 9); + if (ret < 0) { + sterr("read ic position step 1 fail - 1\n"); + return -1; + } + + cmd[1] = 0x03; + cmd[2] = 0x06; + cmd[3] = 0xFE; + cmd[4] = 0x00; + cmd[5] = 0xA5; + + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + if (ret < 0) { + sterr("read ic position step 2 fail - 1\n"); + return -1; + } + + cmd[1] = 0x03; + cmd[2] = 0x06; + cmd[3] = 0xFC; + cmd[4] = 0x5A; + cmd[5] = 0x9E; + cmd[6] = 0x6C; + cmd[7] = 0x00; + + ret = sitronix_ts_addrmode_write(gts, cmd, 7); + if (ret < 0) { + sterr("read ic position step 3 fail - 1\n"); + return -1; + } + + wbuf[1] = 0x83; + wbuf[2] = 0x07; + wbuf[3] = 0x04; + + off = sitronix_ts_addrmode_split_read(gts, wbuf, 3, rbuf, 6); + + if (off < 0) { + sterr("read ic position step 4 fail - 2\n"); + ret = -1; + } + + cmd[1] = 0x03; + cmd[2] = 0x06; + cmd[3] = 0xFE; + cmd[4] = 0x00; + cmd[5] = 0xA5; + + sitronix_ts_addrmode_write(gts, cmd, 5); + + if (ret < 0) { + sterr("read ic position step 5 fail - 3\n"); + return -1; + } + + stmsg("ic_position buf = 0x%X 0x%X\n", rbuf[off + 4], rbuf[off + 5]); + memcpy(buf, rbuf + off + 4, 2); + + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x41; + cmd[5] = 0x4C; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x5A; + cmd[5] = 0xC3; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + return ret; +} + +int sitronix_get_chip_id(void) +{ + uint8_t cmd[8] = { 0 }; + int ret, off; + + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0xA5; + cmd[5] = 0x3C; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x14; + cmd[5] = 0x55; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x55; + cmd[5] = 0x55; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + + //AFE ADDR = (MCU SFR - 0x80) * 2 + 0x010100 + wbuf[1] = 0x81; + wbuf[2] = 0x01; + wbuf[3] = 0x1E; + + off = sitronix_ts_addrmode_read(gts, wbuf, 3, rbuf, 3); + if (off < 0) { + sterr("read Chip ID fail\n"); + ret = -1; + } else { + ret = rbuf[off + 1]; + } + + return ret; +} + +int sitronix_get_ic_sfrver(void) +{ + uint8_t cmd[8] = { 0 }; + int ret, off; + + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0xA5; + cmd[5] = 0x3C; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x14; + cmd[5] = 0x55; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x55; + cmd[5] = 0x55; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + + //AFE ADDR = (MCU SFR - 0x80) * 2 + 0x010100 + wbuf[1] = 0x81; + wbuf[2] = 0x01; + wbuf[3] = 0xC2; + + off = sitronix_ts_addrmode_read(gts, wbuf, 3, rbuf, 3); + if (off < 0) { + sterr("read IC VER fail\n"); + ret = -1; + } else { + ret = rbuf[off + 1]; + } + + return ret; +} + +int sitronix_write_driver_cmd(unsigned char dc, unsigned char *buf, int len) +{ + //uint8_t cmd[128] = {0}; + uint8_t *cmd; + int cmd_len = 128; + int ret = 0; + + if (len > (cmd_len - 6)) { + sterr("The max len of driver cmd is %d , now is %d\n", + cmd_len - 6, len); + return -1; + } + + cmd = kzalloc(cmd_len, GFP_KERNEL); + if (!cmd) { + sterr("%s: Alloc memory for cmd failed!\n", __func__); + return -ENOMEM; + } + + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0xA5; + cmd[5] = 0x3C; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x14; + cmd[5] = 0x55; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + + cmd[1] = 0x03; + cmd[2] = 0x06; + cmd[3] = 0xFC; + cmd[4] = 0x5A; + cmd[5] = 0x9D; + + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + if (ret < 0) { + sterr("write_driver_cmd step 1 fail - 1\n"); + ret = -1; + goto err_return; + } + + if (len % 2 == 1) + len = len + 1; + + cmd[1] = 0x03; + cmd[2] = 0x06; + cmd[3] = 0xFE; + cmd[4] = dc; + cmd[5] = 0x00; + memcpy(cmd + 6, buf, len); + + ret = sitronix_ts_addrmode_write(gts, cmd, 5 + len); + if (ret < 0) { + sterr("write_driver_cmd step 2 fail - 1\n"); + ret = -1; + goto err_return; + } + + cmd[1] = 0x03; + cmd[2] = 0x06; + cmd[3] = 0xFE; + cmd[4] = 0x00; + cmd[5] = 0xA5; + + sitronix_ts_addrmode_write(gts, cmd, 5); + + if (ret < 0) { + sterr("write_driver_cmd step 3 fail - 3\n"); + ret = -1; + goto err_return; + } + + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x41; + cmd[5] = 0x4C; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x5A; + cmd[5] = 0xC3; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + +err_return: + kfree(cmd); + + return ret; +} + +int sitronix_read_driver_cmd(unsigned char dc, unsigned char *buf, int len) +{ + uint8_t cmd[32] = { 0 }; + int ret = 0, off; + + if (len > sizeof(cmd) - 6) { + sterr("The max len of driver cmd is %ld , now is %d\n", + (sizeof(cmd) - 6), len); + return -1; + } + + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0xA5; + cmd[5] = 0x3C; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x14; + cmd[5] = 0x55; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + + //BD 00 + cmd[1] = 0x03; + cmd[2] = 0x06; + cmd[3] = 0xFC; + cmd[4] = 0x5A; + cmd[5] = 0x9D; + cmd[6] = 0xBD; + cmd[7] = 0x00; + cmd[8] = 0x00; + cmd[9] = 0x00; + ret = sitronix_ts_addrmode_write(gts, cmd, 9); + + //Transition Complete + cmd[1] = 0x03; + cmd[2] = 0x06; + cmd[3] = 0xFE; + cmd[4] = 0x00; + cmd[5] = 0xA5; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + + cmd[1] = 0x03; + cmd[2] = 0x06; + cmd[3] = 0xFC; + cmd[4] = 0x5A; + cmd[5] = 0x9E; + cmd[6] = dc; + cmd[7] = 0x00; + + ret = sitronix_ts_addrmode_write(gts, cmd, 7); + + cmd[1] = 0x83; + cmd[2] = 0x07; + cmd[3] = 0x00; + + off = sitronix_ts_addrmode_split_read(gts, cmd, 3, wbuf, len); + + if (off < 0) + sterr("read display CMD1 fail - 2\n"); + memcpy(buf, wbuf + off, len); + + cmd[1] = 0x03; + cmd[2] = 0x06; + cmd[3] = 0xFE; + cmd[4] = 0x00; + cmd[5] = 0xA5; + + sitronix_ts_addrmode_write(gts, cmd, 5); + + //BD 03 + cmd[1] = 0x03; + cmd[2] = 0x06; + cmd[3] = 0xFC; + cmd[4] = 0x5A; + cmd[5] = 0x9D; + cmd[6] = 0xBD; + cmd[7] = 0x00; + cmd[8] = 0x03; + cmd[9] = 0x00; + ret = sitronix_ts_addrmode_write(gts, cmd, 9); + + //Transition Complete + cmd[1] = 0x03; + cmd[2] = 0x06; + cmd[3] = 0xFE; + cmd[4] = 0x00; + cmd[5] = 0xA5; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x41; + cmd[5] = 0x4C; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x5A; + cmd[5] = 0xC3; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + return ret; +} + +void sitronix_swite_driver_deep_standby(void) +{ + int ret = 0; + uint8_t cmd[16] = { 0 }; + + stmsg("run %s\n", __func__); + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0xA5; + cmd[5] = 0x3C; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x14; + cmd[5] = 0x55; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + + //mipi.write 0x29 0x60 0x71 0x23 0xa2 + cmd[1] = 0x03; + cmd[2] = 0x06; + cmd[3] = 0xFC; + cmd[4] = 0x5A; + cmd[5] = 0x9D; + cmd[6] = 0x60; + cmd[7] = 0x00; + cmd[8] = 0x71; + cmd[9] = 0x23; + cmd[10] = 0xA2; + cmd[11] = 0x00; + ret = sitronix_ts_addrmode_write(gts, cmd, 11); + + cmd[1] = 0x03; + cmd[2] = 0x06; + cmd[3] = 0xFE; + cmd[4] = 0x00; + cmd[5] = 0xA5; + sitronix_ts_addrmode_write(gts, cmd, 5); + usleep_range(1000, 2000); + + //mipi.write 0x29 0x60 0x71 0x23 0xa3 + cmd[1] = 0x03; + cmd[2] = 0x06; + cmd[3] = 0xFC; + cmd[4] = 0x5A; + cmd[5] = 0x9D; + cmd[6] = 0x60; + cmd[7] = 0x00; + cmd[8] = 0x71; + cmd[9] = 0x23; + cmd[10] = 0xA3; + cmd[11] = 0x00; + ret = sitronix_ts_addrmode_write(gts, cmd, 8); + + cmd[1] = 0x03; + cmd[2] = 0x06; + cmd[3] = 0xFE; + cmd[4] = 0x00; + cmd[5] = 0xA5; + sitronix_ts_addrmode_write(gts, cmd, 5); + usleep_range(1000, 2000); + + //mipi.write 0x29 0x60 0x71 0x23 0xa4 + cmd[1] = 0x03; + cmd[2] = 0x06; + cmd[3] = 0xFC; + cmd[4] = 0x5A; + cmd[5] = 0x9D; + cmd[6] = 0x60; + cmd[7] = 0x00; + cmd[8] = 0x71; + cmd[9] = 0x23; + cmd[10] = 0xA4; + cmd[11] = 0x00; + ret = sitronix_ts_addrmode_write(gts, cmd, 8); + + cmd[1] = 0x03; + cmd[2] = 0x06; + cmd[3] = 0xFE; + cmd[4] = 0x00; + cmd[5] = 0xA5; + sitronix_ts_addrmode_write(gts, cmd, 5); + usleep_range(1000, 2000); + + //mipi.write 0x29 0x4F 0x01 + cmd[1] = 0x03; + cmd[2] = 0x06; + cmd[3] = 0xFC; + cmd[4] = 0x5A; + cmd[5] = 0x9D; + cmd[6] = 0x4F; + cmd[7] = 0x00; + cmd[8] = 0x01; + cmd[9] = 0x00; + ret = sitronix_ts_addrmode_write(gts, cmd, 9); + + cmd[1] = 0x03; + cmd[2] = 0x06; + cmd[3] = 0xFE; + cmd[4] = 0x00; + cmd[5] = 0xA5; + sitronix_ts_addrmode_write(gts, cmd, 5); + usleep_range(1000, 2000); + + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x41; + cmd[5] = 0x4C; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); + + cmd[1] = 0x53; + cmd[2] = 0x71; + cmd[3] = 0x23; + cmd[4] = 0x5A; + cmd[5] = 0xC3; + ret = sitronix_ts_addrmode_write(gts, cmd, 5); +} + +static int sitronix_ts_read_raw_aa(struct sitronix_ts_data *ts_data, int *rawbuf) +{ + int ret = 0; + int retry = 0, retrymax = 0, xCnt = 0, ix, iy, datasize, i; + //unsigned char pkt[80]; + unsigned char *pkt; + int pkt_len = 80; + + pkt = kzalloc(pkt_len, GFP_KERNEL); + if (!pkt) { + sterr("%s: Alloc memory for pkt failed!\n", __func__); + return -ENOMEM; + } + + retry = 0; + retrymax = (gts->ts_dev_info.x_chs + gts->ts_dev_info.n_chs) * 2; + + //wait for header + while (retry < retrymax) { + ret = sitronix_ts_reg_read(ts_data, DATA_OUTPUT_BUFFER, pkt, + pkt_len); + if (ret < 0) + goto END_READ_RAW_AA; + //stmsg("pkt type (H)= 0x%02x\n", pkt[0]); + if (pkt[0] == 0x10) { //header + break; + } + retry++; + usleep_range(1000, 2000); + if (retry > retrymax) { + ret = -1; + sterr("fail to read rawdata header.\n"); + goto END_READ_RAW_AA; + } + } //end of wait for header + retry = 0; + retrymax = gts->ts_dev_info.x_chs * 2; + while (xCnt < gts->ts_dev_info.x_chs) { + ret = sitronix_ts_reg_read(ts_data, DATA_OUTPUT_BUFFER, pkt, + pkt_len); + if (ret < 0) + goto END_READ_RAW_AA; + //stmsg("pkt type (AA) = 0x%02x\n", pkt[0]); + if (pkt[0] == 0x13) { //Rawdata AA + ix = pkt[2]; + iy = pkt[3]; + datasize = (pkt[1] - 3) / 2; + //stmsg("datasize = %d\n", datasize); + for (i = 0; i < datasize; i++) { + rawbuf[ix * gts->ts_dev_info.y_chs + iy + i] = + (signed short)((pkt[2 + i * 2 + 2] + << 8) | + (pkt[2 + i * 2 + 3])); + } + //stmsg("get x_cnt = %d, x = %d, y = %d\n", xCnt, ix, iy); + xCnt++; + } else { + //ignore packets or unknown packets + retry++; + usleep_range(1000, 2000); + if (retry > retrymax) { + ret = -2; + sterr("fail to read rawdata AA.\n"); + goto END_READ_RAW_AA; + } + } + } + ret = 0; + +END_READ_RAW_AA: + kfree(pkt); + + return ret; +} + +int sitronix_ts_enable_raw(struct sitronix_ts_data *ts_data, int type) +{ + int ret = 0, rawFrameCnt = 0, baselineCnt = 5, i, j, retry; + unsigned char ctrl, tmp; + int *rawbuf = NULL; + + if (type == rawdataType) + return ret; + if (type > 2) + return -EINVAL; + + if (type == 0) { + //exit rawdata mode + ret = sitronix_ts_reg_read(ts_data, MISC_CONTROL, &ctrl, 1); + ctrl = ctrl & 0xA3; + ctrl = ctrl | 0x04; + retry = 0; + while (true) { + sitronix_ts_reg_write(ts_data, MISC_CONTROL, &ctrl, 1); + usleep_range(10000, 11000); + ret = sitronix_ts_reg_read(ts_data, MISC_CONTROL, &tmp, + 1); + if (tmp == ctrl) + break; + retry++; + if (retry > 5) { + sterr("Fail to enable Normal mode.\n"); + return -EIO; + } + } + //free baseline buffer + kfree(rawBase); + rawBase = NULL; + rawdataType = type; + stmsg("exit rawdata mode\n"); + } else { + //enter rawdata mode + if (rawdataType != 1 && rawdataType != 2) { + //stmsg("do enter rawdata mode\n"); + ret = sitronix_ts_reg_read(ts_data, MISC_CONTROL, &ctrl, + 1); + ctrl = ctrl & 0xA3; + ctrl = ctrl | 0x58; + retry = 0; + while (true) { + sitronix_ts_reg_write(ts_data, MISC_CONTROL, + &ctrl, 1); + usleep_range(10000, 11000); + ret = sitronix_ts_reg_read( + ts_data, MISC_CONTROL, &tmp, 1); + if (tmp == ctrl) + break; + retry++; + if (retry > 5) { + sterr("Fail to enable RAWDATA mode.\n"); + return -EIO; + } + } + //allocate baseline buffer + rawFrameCnt = ts_data->ts_dev_info.x_chs * + ts_data->ts_dev_info.y_chs; + //stmsg("raw frame node cnt = %d\n", rawFrameCnt); + rawBase = kmalloc_array(rawFrameCnt, sizeof(int), + GFP_KERNEL); + memset(rawBase, 0, rawFrameCnt * sizeof(int)); + //create baseline + rawbuf = kmalloc_array(rawFrameCnt, sizeof(int), + GFP_KERNEL); + for (i = 0; i < baselineCnt; i++) { + memset(rawbuf, 0, rawFrameCnt * sizeof(int)); + ret = sitronix_ts_read_raw_aa(ts_data, rawbuf); + if (ret < 0) { + sterr("Fail to create baseline\n"); + goto exit_enable_raw; + } + for (j = 0; j < rawFrameCnt; j++) + rawBase[j] += rawbuf[j]; + } + for (j = 0; j < rawFrameCnt; j++) + rawBase[j] = (int)(rawBase[j] / baselineCnt); + } + rawdataType = type; + stmsg("enter rawdata mode=%d\n", rawdataType); + } + +exit_enable_raw: + kfree(rawbuf); + rawbuf = NULL; + return ret; +} + +int sitronix_ts_get_rawdata(struct sitronix_ts_data *ts_data, int *rbuf) +{ + int ret = 0, rawFrameCnt, j; + + if (rawdataType == 0) { + sterr("rawdata type was not defined.\n"); + return -EPROTO; + } + ret = sitronix_ts_read_raw_aa(ts_data, rbuf); + if (ret >= 0) { + if (rawdataType == + 2) { //calculate delta, delta = baseline - raw + rawFrameCnt = ts_data->ts_dev_info.x_chs * + ts_data->ts_dev_info.y_chs; + for (j = 0; j < rawFrameCnt; j++) + rbuf[j] = rawBase[j] - rbuf[j]; + } + ret = rawdataType; + } + return ret; +} + +int sitronix_ts_set_rawdata_area(struct sitronix_ts_data *ts_data, int aaXs, + int aaXe, int aaYs, int aaYe, int idleXs, + int idleXe, int noiseXs, int noiseXe) +{ + int ret = 0; + struct CommandIoPacket outPacket; + unsigned short chksum; + int retry = 5; + + outPacket.CmdID = 0x06; /* Set Read Rawdata area command */ + outPacket.ValidDataSize = 10; + outPacket.CmdData[0] = 0x00; //write control + outPacket.CmdData[1] = (aaXs & 0xFF); //AA X start + outPacket.CmdData[2] = (aaXe & 0xFF); //AA X end + outPacket.CmdData[3] = (idleXs & 0xFF); //idle X start + outPacket.CmdData[4] = (idleXe & 0xFF); //idle X end + outPacket.CmdData[5] = (aaYs & 0xFF); //Y start + outPacket.CmdData[6] = (aaYe & 0xFF); //Y end + outPacket.CmdData[7] = (noiseXs & 0xFF); //noise X start + outPacket.CmdData[8] = (noiseXe & 0xFF); //noise X end + chksum = 0; + STChecksumCalculation(&chksum, (unsigned char *)&outPacket, + outPacket.ValidDataSize + 1); + outPacket.CmdData[outPacket.ValidDataSize - 1] = (chksum & 0xFF); + + if (!TDU_WriteIOCommand(&outPacket)) { + sterr("%s: (E)TDU_WriteIOCommand.\n", __func__); + ret = -EIO; + return ret; + } + if (!TDU_SetH2DReady()) { + sterr("%s: (E)TDU_SetH2DReady.\n", __func__); + ret = -EIO; + return ret; + } + while (retry > 0) { + msleep(20); + /* check processing result */ + if (!TDU_GetH2DReady()) { + retry--; + if (retry <= 0) { + sterr("%s: (E)TDU_GetH2DReady retry timeout.\n", + __func__); + ret = -EIO; + return ret; + } + } else { + break; + } + } + + memset(&outPacket, 0, sizeof(outPacket)); + outPacket.CmdID = 0x06; /* Set Read Rawdata area command */ + outPacket.ValidDataSize = 2; + outPacket.CmdData[0] = 0x80; //read control + chksum = 0; + STChecksumCalculation(&chksum, (unsigned char *)&outPacket, + outPacket.ValidDataSize + 1); + outPacket.CmdData[outPacket.ValidDataSize - 1] = (chksum & 0xFF); + if (!TDU_WriteIOCommand(&outPacket)) { + sterr("%s %d: (E)TDU_WriteIOCommand.\n", __func__, __LINE__); + ret = -EIO; + return ret; + } + if (!TDU_SetH2DReady()) { + sterr("%s %d: (E)TDU_SetH2DReady.\n", __func__, __LINE__); + ret = -EIO; + return ret; + } + while (retry > 0) { + msleep(20); + /* check processing result */ + if (!TDU_GetH2DReady()) { + retry--; + if (retry <= 0) { + sterr("%s %d: (E)TDU_GetH2DReady retry timeout.\n", + __func__, __LINE__); + ret = -EIO; + return ret; + } + } else { + break; + } + } + return ret; +} + +int sitronix_ts_exdiff_enable(struct sitronix_ts_data *ts_data, bool exdiff_en) +{ + unsigned char buf[4]; + int ret = 0; + + ret = sitronix_ts_reg_read(ts_data, EX_DIFF_EN, buf, 1); + if (ret < 0) { + sterr("%s: Read EX_DIFF_EN error! (%d)\n", __func__, ret); + return ret; + } + + if (exdiff_en) + buf[0] |= 0x01; //set bit0 + else + buf[0] &= 0xFE; //clear bit1 + + ret = sitronix_ts_reg_write(ts_data, EX_DIFF_EN, buf, 1); + if (ret < 0) { + sterr("%s: Write EX_DIFF_EN error! (%d)\n", __func__, ret); + return ret; + } + + ret = sitronix_ts_reg_read(ts_data, EX_DIFF_EN, buf, 4); + if (ret < 0) { + sterr("%s: Check EX_DIFF_EN error! (%d)\n", __func__, ret); + return ret; + } + + if (exdiff_en) { + if ((buf[0] & 0x01) && buf[1] > 0) { + ts_data->exdiff_flag = true; + ts_data->ex_diff_pac_num = buf[1] & 0xFF; + ts_data->ex_diff_reg_map = ((buf[2] & 0xFF) << 8) | + (buf[3] & 0xFF); + } else { + ts_data->exdiff_flag = false; + ts_data->ex_diff_pac_num = 0; + ts_data->ex_diff_reg_map = 0; + sterr("%s:EX_DIFF was not supported!\n", __func__); + return -EINVAL; + } + } else { + if ((buf[0] & 0x01) == 0x00) { + ts_data->exdiff_flag = false; + ts_data->ex_diff_pac_num = 0; + ts_data->ex_diff_reg_map = 0; + } + } + stmsg("set exdiff_flag = %s\n", + ts_data->exdiff_flag ? "true" : "false"); + if (gts->exdiff_flag) { + stmsg("ex_diff_pac_num = %d, ex_diff_map_off = 0x%04X\n", + ts_data->ex_diff_pac_num, ts_data->ex_diff_reg_map); + } + + return 0; +} + +#define DEBUG_PRINT_EX_DIFF_DATA +int sitronix_ts_get_exdiff(struct sitronix_ts_data *ts_data, + unsigned char *diff) +{ + int ret = 0; + u8 id = 0, x_pos = 0, y_pos = 0; +#ifdef DEBUG_PRINT_EX_DIFF_DATA + int xi, yi, value; +#endif + unsigned short chksum = 0; + + ret = sitronix_ts_reg_read(ts_data, ts_data->ex_diff_reg_map, diff, + ST_DIFF_DATA_TABLE_LEN); + if (ret < 0) { + sterr("%s: fail to read ex diff output data!(%d)\n", __func__, + ret); + return ret; + } + STChecksumCalculation(&chksum, diff, ST_DIFF_DATA_TABLE_LEN - 1); + if ((chksum & 0xFF) != diff[ST_DIFF_DATA_TABLE_LEN - 1]) { + sterr("ExDiffChecksum error : Expect (%02X) != Received (%02X)\n", + (chksum & 0xFF), diff[ST_DIFF_DATA_TABLE_LEN - 1]); + return -EIO; + } + + id = (diff[1] & 0xF0) >> 4; //ID + y_pos = (diff[0] & 0x3F); //Rx + x_pos = ((diff[1] & 0x0F) << 2) | ((diff[0] & 0xC0) >> 6); //Tx + + stmsg("Diff Data ID = %d at (%d, %d)\n", id, x_pos, y_pos); +#ifdef DEBUG_PRINT_EX_DIFF_DATA + stmsg("diff[0] = 0x%02X, diff[1]=0x%02X\n", diff[0], diff[1]); + for (yi = 0; yi < 7; yi++) { + for (xi = 0; xi < 7; xi++) { + value = (signed short)((diff[(xi * 2) + (yi * 2 * 7) + 2] + << 8) | + (diff[(xi * 2) + (yi * 2 * 7) + + 3])); + pr_debug("%4d,", value); + } + pr_debug("\n"); + } +#endif + return ret; +}