From 355957919e72304eadd8572f12b99c51be61e5c4 Mon Sep 17 00:00:00 2001 From: Huan Wang Date: Sun, 4 Apr 2021 17:19:46 -0600 Subject: [PATCH] Add nb1010 driver --- data/autosuspend.hwdb | 4 + libfprint/drivers/nb1010.c | 445 +++++++++++++++++++++++++++++++++++++ libfprint/meson.build | 5 + meson.build | 1 + tests/meson.build | 1 + tests/nb1010/capture.ioctl | 98 ++++++++ tests/nb1010/capture.png | Bin 0 -> 70982 bytes tests/nb1010/device | 301 +++++++++++++++++++++++++ 8 files changed, 855 insertions(+) create mode 100644 libfprint/drivers/nb1010.c create mode 100644 tests/nb1010/capture.ioctl create mode 100644 tests/nb1010/capture.png create mode 100644 tests/nb1010/device diff --git a/data/autosuspend.hwdb b/data/autosuspend.hwdb index 3ee0287..499220f 100644 --- a/data/autosuspend.hwdb +++ b/data/autosuspend.hwdb @@ -135,6 +135,10 @@ usb:v27C6p639C* usb:v27C6p6594* ID_AUTOSUSPEND=1 +# Supported by libfprint driver nb1010 +usb:v298Dp1010* + ID_AUTOSUSPEND=1 + # Supported by libfprint driver synaptics usb:v06CBp00BD* usb:v06CBp00E9* diff --git a/libfprint/drivers/nb1010.c b/libfprint/drivers/nb1010.c new file mode 100644 index 0000000..61436db --- /dev/null +++ b/libfprint/drivers/nb1010.c @@ -0,0 +1,445 @@ +/* + * Next Biometrics driver for libfprint + * + * Copyright (C) 2021 Huan Wang + * Copyright (C) 2011-2012 Andrej Krutak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#define FP_COMPONENT "nb1010" +#include "fpi-log.h" + +#include "drivers_api.h" + +#define FRAME_HEIGHT 180 +#define FRAME_WIDTH 256 + +#define NB1010_EP_OUT 0x02 | FPI_USB_ENDPOINT_OUT +#define NB1010_EP_IN 0x03 | FPI_USB_ENDPOINT_IN + +#define NB1010_SENSITIVITY_BIT 12 + +#define NB1010_CMD_RECV_LEN 16 +#define NB1010_CAPTURE_RECV_LEN 540 +#define NB1010_CAPTURE_HEADER_LEN 25 + +#define NB1010_LINE_PER_PARTIAL 2 +#define NB1010_N_PARTIAL (FRAME_HEIGHT / NB1010_LINE_PER_PARTIAL) + +#define NB1010_DEFAULT_TIMEOUT 500 +#define NB1010_TRANSITION_DELAY 50 + +/* Loop ssm states */ +enum { + M_WAIT_PRINT, + M_REQUEST_PRINT, + M_CHECK_PRINT, + M_READ_PRINT_PRESTART, + M_READ_PRINT_START, + M_READ_PRINT_POLL, + M_SUBMIT_PRINT, + + /* Number of states */ + M_LOOP_NUM_STATES, +}; + +/* + * The Follow Commands are obtained by decoding the usbcap, so it does not expose all the command available to the device. + * Known: + * 1. every command starts with 0x80 + * 2. second byte is the comand, third byte is the seqence nubmer, init with rand, gets incremented + * everytime a new instruction is sent to the device. However device does not care or check the sequence, just echo back + * whatever chosen by the host. + * 3. cmd: 0x07 check, expect [0x80, 0x29...] as response + * 4. cmd: 0x16 ???, expect [0x80, 0x20...] as response. Happens during device init. + * 5. cmd: 0x13 print device, expect [0x80, 0x23...] as response. Response contains the device string + * 6. cmd: 0x38 check finger, expect [0x80, 0x37...] as response. The 14th byte indicate whether finger present [0-255] + * 7. cmd: 0x0d ???, expect [0x80, 0x20...] as response. Happens before capture. + * 8. cmd: 0x12 capture, expect [0x80, 0x20...] as response. After capture read 90 times in sequence to get all the frame. + */ + +static guint8 nb1010_cmd_check_finger[] = { + 0x80, 0x38, 0x01, 0x00, 0x08, 0x00, 0x00, 0x00, +}; + +/* pre capture, dont know what does it do, but appears everytime a capture begins */ +static guint8 nb1010_cmd_precapture[] = { + 0x80, 0x0d, 0x03, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, +}; + +static guint8 nb1010_cmd_capture[] = { + 0x80, 0x12, 0x04, 0x00, 0x20, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, +}; + +struct _FpiDeviceNb1010 +{ + FpImageDevice parent; + FpiSsm *ssm; + guint8 *scanline_buf; + gboolean deactivating; + int partial_received; +}; +G_DECLARE_FINAL_TYPE (FpiDeviceNb1010, fpi_device_nb1010, FPI, DEVICE_NB1010, FpImageDevice); +G_DEFINE_TYPE (FpiDeviceNb1010, fpi_device_nb1010, FP_TYPE_IMAGE_DEVICE); + +static void +nb1010_dev_init (FpImageDevice *dev) +{ + FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev); + GError *error = NULL; + + g_usb_device_claim_interface (fpi_device_get_usb_device (FP_DEVICE (dev)), 0, 0, &error); + + self->scanline_buf = g_malloc0 (FRAME_WIDTH * FRAME_HEIGHT); + + fpi_image_device_open_complete (dev, error); + fp_dbg ("nb1010 Initialized"); +} + +static void +nb1010_dev_deinit (FpImageDevice *dev) +{ + FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev); + GError *error = NULL; + + g_clear_pointer (&self->scanline_buf, g_free); + + g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (dev)), 0, 0, &error); + fpi_image_device_close_complete (dev, error); + fp_dbg ("nb1010 Deinitialized"); +} + +static void +nb1010_dev_activate (FpImageDevice *dev) +{ + FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev); + + self->deactivating = FALSE; + + fpi_image_device_activate_complete (dev, NULL); + fp_dbg ("nb1010 Activated"); +} + +static void +nb1010_dev_deactivated (FpImageDevice *dev, GError * err) +{ + fpi_image_device_deactivate_complete (dev, err); + fp_dbg ("nb1010 Deactivated"); +} + +static void +nb1010_dev_deactivate (FpImageDevice *dev) +{ + FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev); + + self->deactivating = TRUE; + if (self->ssm == NULL) + nb1010_dev_deactivated (dev, NULL); +} + +static void +nb1010_request_fingerprint (FpiDeviceNb1010 *dev) +{ + FpiUsbTransfer *transfer = NULL; + + transfer = fpi_usb_transfer_new (FP_DEVICE ( dev)); + transfer->short_is_error = TRUE; + transfer->ssm = dev->ssm; + + fpi_usb_transfer_fill_bulk_full (transfer, NB1010_EP_OUT, + nb1010_cmd_check_finger, G_N_ELEMENTS (nb1010_cmd_check_finger), + NULL); + fpi_usb_transfer_submit (transfer, NB1010_DEFAULT_TIMEOUT, + fpi_device_get_cancellable (FP_DEVICE (dev)), + fpi_ssm_usb_transfer_cb, NULL); +} + +static void +nb1010_check_fingerprint_cb (FpiUsbTransfer *transfer, FpDevice *dev, + gpointer unused_data, GError *error) +{ + FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev); + + if (error) + { + fpi_ssm_mark_failed (transfer->ssm, error); + return; + } + if (self->deactivating) + { + fpi_ssm_mark_completed (transfer->ssm); + return; + } + + if (transfer->buffer[NB1010_SENSITIVITY_BIT] > 0x30) + fpi_ssm_next_state (transfer->ssm); + else + fpi_ssm_jump_to_state (transfer->ssm, M_WAIT_PRINT); +} + +static void +nb1010_cmd_check_fingerprint (FpiDeviceNb1010 *dev) +{ + FpiUsbTransfer *transfer = NULL; + + transfer = fpi_usb_transfer_new (FP_DEVICE ( dev)); + transfer->short_is_error = TRUE; + transfer->ssm = dev->ssm; + + fpi_usb_transfer_fill_bulk (transfer, NB1010_EP_IN, NB1010_CMD_RECV_LEN); + fpi_usb_transfer_submit (transfer, NB1010_DEFAULT_TIMEOUT, + fpi_device_get_cancellable (FP_DEVICE (dev)), + nb1010_check_fingerprint_cb, NULL); +} + +static void +nb1010_read_ignore_data_cb (FpiUsbTransfer *transfer, FpDevice *dev, + gpointer unused_data, GError *error) +{ + FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev); + FpiUsbTransfer *new_transfer = NULL; + + if (error) + { + fpi_ssm_mark_failed (transfer->ssm, error); + return; + } + if (self->deactivating) + { + fpi_ssm_mark_completed (transfer->ssm); + return; + } + + new_transfer = fpi_usb_transfer_new ( dev ); + new_transfer->short_is_error = TRUE; + new_transfer->ssm = transfer->ssm; + + fpi_usb_transfer_fill_bulk (new_transfer, NB1010_EP_IN, NB1010_CMD_RECV_LEN); + fpi_usb_transfer_submit (new_transfer, NB1010_DEFAULT_TIMEOUT, + fpi_device_get_cancellable (FP_DEVICE (dev)), + fpi_ssm_usb_transfer_cb, NULL); +} + +static void +nb1010_write_ignore_read (FpiDeviceNb1010 *dev, guint8 *buf, gsize len) +{ + FpiUsbTransfer *transfer = NULL; + + transfer = fpi_usb_transfer_new (FP_DEVICE ( dev)); + transfer->short_is_error = TRUE; + transfer->ssm = dev->ssm; + + fpi_usb_transfer_fill_bulk_full (transfer, NB1010_EP_OUT, buf, len, NULL); + fpi_usb_transfer_submit (transfer, NB1010_DEFAULT_TIMEOUT, + fpi_device_get_cancellable (FP_DEVICE (dev)), + nb1010_read_ignore_data_cb, NULL); +} + + +static void +nb1010_read_capture_cb (FpiUsbTransfer *transfer, FpDevice *dev, + gpointer unused_data, GError *error) +{ + FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev); + + if (error) + { + fpi_ssm_mark_failed (transfer->ssm, error); + return; + } + if (self->deactivating) + { + fpi_ssm_mark_completed (transfer->ssm); + return; + } + + g_assert (transfer->actual_length == NB1010_CAPTURE_RECV_LEN); + + size_t offset = self->partial_received * NB1010_LINE_PER_PARTIAL * FRAME_WIDTH; + + memcpy (self->scanline_buf + offset, + transfer->buffer + NB1010_CAPTURE_HEADER_LEN, NB1010_LINE_PER_PARTIAL * FRAME_WIDTH); + + self->partial_received++; + if (self->partial_received == NB1010_N_PARTIAL) + { + fpi_ssm_next_state (transfer->ssm); + return; + } + + fpi_usb_transfer_submit (fpi_usb_transfer_ref (transfer), NB1010_DEFAULT_TIMEOUT, + fpi_device_get_cancellable (FP_DEVICE (dev)), + nb1010_read_capture_cb, NULL); +} + +static void +nb1010_read_capture (FpiDeviceNb1010 *dev) +{ + FpiUsbTransfer *transfer = NULL; + + transfer = fpi_usb_transfer_new ( FP_DEVICE ( dev)); + transfer->short_is_error = TRUE; + transfer->ssm = dev->ssm; + + fpi_usb_transfer_fill_bulk (transfer, NB1010_EP_IN, NB1010_CAPTURE_RECV_LEN); + fpi_usb_transfer_submit (transfer, NB1010_DEFAULT_TIMEOUT, + fpi_device_get_cancellable (FP_DEVICE (dev)), + nb1010_read_capture_cb, NULL); +} + +static int +submit_image (FpiSsm *ssm, + FpImageDevice *dev) +{ + FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev); + FpImage *img; + + img = fp_image_new (FRAME_WIDTH, FRAME_HEIGHT); + if (img == NULL) + return 0; + + memcpy (img->data, self->scanline_buf, FRAME_WIDTH * FRAME_HEIGHT); + fpi_image_device_image_captured (dev, img); + + return 1; +} + +static void +m_loop_complete (FpiSsm *ssm, FpDevice *_dev, GError *error) +{ + fp_dbg ("nb1010 ssm complete cb"); + + FpImageDevice *dev = FP_IMAGE_DEVICE (_dev); + FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (_dev); + + self->ssm = NULL; + + if (self->deactivating) + nb1010_dev_deactivated (dev, error); + else if (error != NULL) + fpi_image_device_session_error (dev, error); +} + +static void +m_loop_state (FpiSsm *ssm, FpDevice *_dev) +{ + FpImageDevice *dev = FP_IMAGE_DEVICE (_dev); + FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (_dev); + + if (self->deactivating) + { + fp_dbg ("deactivating, marking completed"); + fpi_ssm_mark_completed (ssm); + return; + } + + switch (fpi_ssm_get_cur_state (ssm)) + { + case M_WAIT_PRINT: + /* Wait fingerprint scanning */ + fpi_ssm_next_state_delayed (ssm, NB1010_TRANSITION_DELAY, NULL); + break; + + case M_REQUEST_PRINT: + nb1010_request_fingerprint (self); + break; + + case M_CHECK_PRINT: + nb1010_cmd_check_fingerprint (self); + break; + + case M_READ_PRINT_PRESTART: + fpi_image_device_report_finger_status (dev, TRUE); + nb1010_write_ignore_read (self, nb1010_cmd_precapture, G_N_ELEMENTS (nb1010_cmd_precapture)); + break; + + case M_READ_PRINT_START: + self->partial_received = 0; + nb1010_write_ignore_read (self, nb1010_cmd_capture, G_N_ELEMENTS (nb1010_cmd_capture)); + break; + + case M_READ_PRINT_POLL: + nb1010_read_capture (self); + break; + + case M_SUBMIT_PRINT: + if (submit_image (ssm, dev)) + { + fpi_ssm_mark_completed (ssm); + fpi_image_device_report_finger_status (dev, FALSE); + } + else + { + fpi_ssm_jump_to_state (ssm, M_WAIT_PRINT); + } + break; + + default: + g_assert_not_reached (); + } +} + +static void +nb1010_dev_change_state (FpImageDevice *dev, FpiImageDeviceState state) +{ + FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev); + FpiSsm *ssm_loop; + + if (state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON) + { + ssm_loop = fpi_ssm_new (FP_DEVICE (dev), m_loop_state, M_LOOP_NUM_STATES); + self->ssm = ssm_loop; + fpi_ssm_start (ssm_loop, m_loop_complete); + } +} + + +static const FpIdEntry id_table[] = { + { .vid = 0x298d, .pid = 0x1010, }, + { .vid = 0, .pid = 0, .driver_data = 0 }, +}; + +static void +fpi_device_nb1010_init (FpiDeviceNb1010 *self) +{ +} + +static void +fpi_device_nb1010_class_init (FpiDeviceNb1010Class *klass) +{ + FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass); + FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_CLASS (klass); + + dev_class->id = FP_COMPONENT; + dev_class->full_name = "NextBiometrics NB-1010-U"; + dev_class->type = FP_DEVICE_TYPE_USB; + dev_class->id_table = id_table; + dev_class->scan_type = FP_SCAN_TYPE_PRESS; + + img_class->img_height = FRAME_HEIGHT; + img_class->img_width = FRAME_WIDTH; + + img_class->bz3_threshold = 24; + + img_class->img_open = nb1010_dev_init; + img_class->img_close = nb1010_dev_deinit; + img_class->activate = nb1010_dev_activate; + img_class->deactivate = nb1010_dev_deactivate; + img_class->change_state = nb1010_dev_change_state; +} diff --git a/libfprint/meson.build b/libfprint/meson.build index 50d738e..1bd37f3 100644 --- a/libfprint/meson.build +++ b/libfprint/meson.build @@ -181,6 +181,11 @@ foreach driver: drivers 'drivers/goodixmoc/goodix_proto.c', ] endif + if driver == 'nb1010' + drivers_sources += [ + 'drivers/nb1010.c', + ] + endif endforeach if aeslib diff --git a/meson.build b/meson.build index e110b33..3ac2706 100644 --- a/meson.build +++ b/meson.build @@ -120,6 +120,7 @@ default_drivers = [ 'upeksonly', 'upekts', 'goodixmoc', + 'nb1010' ] # FIXME: All the drivers should be fixed by adjusting the byte order. diff --git a/tests/meson.build b/tests/meson.build index 187be5d..48fe7b1 100644 --- a/tests/meson.build +++ b/tests/meson.build @@ -30,6 +30,7 @@ drivers_tests = [ 'vfs5011', 'vfs7552', 'goodixmoc', + 'nb1010', ] if get_option('introspection') diff --git a/tests/nb1010/capture.ioctl b/tests/nb1010/capture.ioctl new file mode 100644 index 0000000..f11838f --- /dev/null +++ b/tests/nb1010/capture.ioctl @@ -0,0 +1,98 @@ +@DEV /dev/bus/usb/001/003 +USBDEVFS_GET_CAPABILITIES 0 FD010000 +USBDEVFS_REAPURBNDELAY 0 3 2 0 0 8 8 0 8038010008000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 16 16 0 803701001000000000000000F7000000 +USBDEVFS_REAPURBNDELAY 0 3 2 0 0 12 12 0 800D03000C00000000040000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 16 16 0 80200300100000000000000000000000 +USBDEVFS_REAPURBNDELAY 0 3 2 0 0 32 32 0 8012040020000000020000000000000000000000000000000000000020000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 16 16 0 80200400100000000000000003000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000010000000001000001E5E5E5E5E5E4E4E4E5E5E5E4E6E7E6E6BEE6E4E5E4E3E5E6E3E4E4E3E5E6E4E5E6E5E5E5E4E4E5E5E3E3E2E3E3E4E4E4E4E5E5E5E2E2E3C9E2E4E3E4E3E3E4E4E8E8E7E8E5E5E3E4E5E3E4E5E3E4E5E3E4E4E5E5E3E4E4E4E4E5E5E5E3E3E2E3E4E3E3E3E2E3E3E3E3E5E5E5E5E5E4E5E3E4E4E3E5E66AE3E4E5E4E5E5E4E4E5E4E2E2E3E6E5E5E4E4E3E5E3E6E6E7E6E4E4E3E2E5E5E5E6E4E6E5E2E2E3E2E3E4E3E3E4E5E3E5E5E5E3E4E4E6E4E5E5E4E3E4E2E3E5E4E4E5E6E4E5E2E3E2E3E2E3E4E4E5E4E3E3E5E6E6E6E4E4E3E3E6E5E5E6E5E5E5E6E5E5E5E5E5E4E0E4E4E3E2E3E3E3E2E4E3E4E4E5E5E4E5E6E2E3E3E2E4E4E4E3E4E2E4E6E4E5E4E4E6E6E7E7E6E7E6E7E8E6E7E7E8E8E8E8E7E6E7E6E7E5E7E7E7E7E7E6E6E4E4E6E3E4E3E4E4E3E3E4E2E3E4E3E4E3E4E5E3E5E4E5E4E4E3E2E5E5E5E4E5E6E7E6E4E5E4E5E6E7E7E8E2E3E4E4E7E5E7E6E6E3E4E5E7E7E7E8E6E5E6E6E6E5E5E6E6E5E6E4E4E5E4E4E7E7E5E5E5E6E4E7E7E6E5E6E4E4E6E6E6E6E5E5E5E5E5E5E5E4E5E6E4E5E6E6E4E4E5E4E4E6E6E6E6E6E6E5E6E7E7E6E5E7E5E5E7E6E5E7E5E5E7E5E6E4E5E6E7E6E5E7E4E5E5E5E8E6E7E0E6E6E7E7E8E8E9E9E3E5E5E4E6E5E6E7E6E5E5E6E6E5E5E6E5E4E4E3E6E6E6E6E5E4E3E4E6E7E6E5E6E7E5E5E6E6E7E7E7E7E8E6E7E5E7E5E7E6E7E8E6E6E7E5E5E5E5E5E5E2E6E5E7E6E7E7000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000030000000001000001E7E7E7E7E6E6E6E6E7E7E7E8E8E8E6E8E9E7E8E9E0E4E5E4E8E7E8E7E5E4E4E5E6E1E5E5E7E6E6E6E6E5E4E4E5E4E3E5E5E6E4E5E4E5E5E5E2E6E4E3E5E5E5E6E6E6E5E5E6E5E6E6E7E6E6E7E5E4E5E5E4E5E5E7E7E7E7E7E5E4E4E4E4E3E3E3E5E5E6E5E6E6E5E5E4E4E4E2E6E6E4E5E6E6E8E6E7E6E5E8E6E6E4E5E6E6E7E6E6E6E6E6E6E6E6E5E5E7E5E5E5E6E6E7E5E6E5E5E5E5E5E4E6E6E8E6E0E6E6E7E7E7E8E8E6E6E7E6E7E6E8E6E6E5E6E6E7E6E6E5E5E6E4E5E6E5E6E6E6E4E6E5E7E6E6E6E2E6E7E6E6E5E5E6E7E7E6E5E5E5E6E5E7E7E6E6E5E3E5E3DEE5E6E5E4E5E2E5E6E5E4E5E6E4E5E5E5E5E4E4E6E6E7E7E6E7E6E5E6E4E6E5E4E5E3E4E8E6E7E6E8E7E7E9E7E5E7E9E6E6E5E7E8E7E7E7E7E6E6E6E7E6E7E5E3E4E6E5E4E4E4E6E4E5E3E7DDE5E6E5E6E5E5E7E3E4E5E4E4E5E4E5E3E3DCE4E6E5E6E7E4E4E4E6E5E4E7E7E4E4E3E5E6E6E7E7E5E4E6E5E4E4E5E5E6E5E5E5E6E6E5E6E3E6E5E6E4E2E2E4E5E6E4E4E4E5E4E5E9E9E8E7E6E6E7E7E8E7E7E7E5E4E5E3E6E8E7E7E5E5E3E4E4E5E3E4E5E5E5E5E6E5E4E5E6E7E7E7E5E7E6E6E4E6E6E6E5E4E094E5E6E6E6E7E5E6E5E7E6E7E6E5E6E6E7E7E6E6E6E6E7E8E7E7E5E5E6E6E6E8E6E6E5E5E7E7E7E6E7E5E7E5E5E8E8E7E7E7E5E7E4E6E5E4E6E5E7E4E5E7E6E6E6E7E5E6E6E6E4E6E6E5E7E6E6E5E5E3E6E8E7E6E7E4E2E4E4E6E6E7E6000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000050000000001000001E6E6E6E6E8E7E7E7E8E6E7E8E9E8E8E8E8E8E8E9E7E6E6E9E6E7E4E6E5E5E6E5E5E6E7E6E6E5E6E6E4E5E4E4E3E5E2E4E5E4E4E5DDE3E4B5E5E7E6E5E5E6E5E1E6E7E7E7E5E6E7E5E5E5E5E5E6E5D6E5A1E4E6E6E4E5E4E3E4E4E4E5E4E5E4E5E6E6E6E6E7E7E6E7E4E4E5E4E6E5E4E6E47AE5E5E7E7E6E7E4E4E5E3E6E4E5E5E4E4E2E3E6E7E7E4E5E6E7E6E6E7E6E7E5E6E6E4E6E7E6E5D4E7E8E7E3E4E5E4E6E6E5E7E5E4E5E3E3E5E7E6E4E3E4E6E6E7E7E7E4E4E5E4E6E7E6E8E7E6E6E7E9E8E9E9E7E6E6E6E4E6E5E4E6E6E7E4E6E6E7E6E7E6E6E5E4E4E5E5E6E5E6E4E6E6E5E6E6E4E5E5E5E6E5E7E6E6E6E7E5E6E5E5E7E6E8E6E4E4E5E5E5E6E5E5E8E8E7E7E6E6E6E6E8E6E8EAE7E9E8E8E8E8E8E9E6E6E7E6E4E5E6E4E5E4E3E5E5E5E5E5E4E5E48B80E4E5E0E7E5E8E6E4E5E5E5E6E2D2E6E7E6E5E6E2E3E5E3E6E8E417D4E3E6E6E6E4E5E5E6E4E6E6E5E6E5E5E7E7E6E7E6E5E4E5E4E5E4E6E7E6E7E7E5E4E6E3E6E4E5E780E6E5E6E4E4E3E4E4E5E6E4E5E5E5E4E7E7E7E6E4E5E4E5E6E1E8E8E6E7E7E8E7E5E5E6E0E5E5D0E4E4E3E4E7E4E6E5E3E4E4E5E5E6E5E6E5E4E3E3DEE2E6E6E5E5E5E4E2E4E6E692E7E6E6E4E6E5E5E3E5E5E6E4E4E4E5E4E5E5E6E6E4E5E6E7E5E5E6E5E5E5E5E6E5E5E5E7E5E7E7E6E6E6E6E6E6E5E6E4E4E5E4E5E6E4E4E6E5E5E6E6E7E7E5E4E5E4E5E6E3E5E5E3E5E5E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000070000000001000001E5E5E5E5E7E7E8E7E4E8E8E9E9E7E8E8E9E8E9E8E6E8E7E659E5E5E578E5E5E4E5E4E5E5E3AFE4E2E4E0E3E5E0E3E5E5E6E6E7E6E3CDE4E3E6E400E1E3E4E6E3E8E7E6E7E4E3E5E4E5E5E5E5E5E6E5E6E6E6E5E7E4E5E4E5E5E5E4E1D8E6E719E5E7E7E6E5E5E4E6E5E4E4E5E0E7E7E7E7E7E678E6E7E7E5E4E6E6E5E6E6E5E6E4E5E4E4E6E3E6E1E5E6E5E6E4E7E6E6E6E4E5E6E7E6E5E6E7E2E6E7E4E6E6E6E7E7E5E6E6E5E7E6E6E8E7E6E5E5E3E2E4E4E5E6E6E7E4E6E6A6E4E6E5E6E5E5E7E5E6E4E4E3E4E4E7E5E5E4E4E3E5E6E7E6E5E7E4E5E5E5E6E6E6E6E4E4E5E5E7E6E5E7E3E4E3E4E8E7E6E7E5E6E4E5E4E6E5E5E6E5E4E4E7E5E7E6E4E3E5E5E6E6E7E7E7E7E7E7E8E8E8EAE8E8E7E8E9E8E8E9E9E8D8E8E7E6E6E789E3E1E4E3E390E4E5E6E5E6E4E4E5E2E6E5E7E6E7E5E5E5E1E3E5030CE1000019E4E3E3E4E5E3E5E7E5E6E6E6E7E7E6E6E6E6E5E7E6E6E5E5E6E5E7E5E69BE4E7E6E6E5E5E4E4E4E7E7E6E7E4E4E4E5E7E7E7E6E5E5E7E7E6E5E6E6E4E4E4E5E6E7E7E7E5E7E6E5E5E4E6E6E5E4E4E4D8E6E6E5E5E6E6E6E4E5E3E2E6E3E6E7E3E3E4E3E6E6E6E6E5E6E7E7E4E5E6E6E6E7E5E3E5E5E6E7E4E5E4E4E7E7BCE5E5E4E5E6E6E7E7E6D6E4E6E4E7E6DDE5E7E6E7E6E5E631E4E8E7E7E6E7E6E6E7E8E7E6E7E7E5E5E5E5E4E0E6E7E6E6E6E7E5E5E5E7E7E8E7E8E7E6E5E7E7E6E7E5E4E4E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000090000000001000001E5E5E6E5E5BEE1E6EAE6E8E9E7E7E6E6EAE6E9E7E6E7E6E7E5E7E3E7E4E3E2E5E5E4D8E4E4E5E4E5E4E4E44599E3E5E6E3E2E1E3E5E4E03100E100000078E5E5E4E4E5E5E6E6E5E5E3E4E5E4E6E7E4E6E7E5E4E4E5E3E3E4E42B0000D6E5E4E6E6E6E5E5E5E3E3E4E5E4E4E6E4E5E4E4E8E6E7E8E6E6E6E6E7E6E6E7E5E6E5E6E5E5E6E5E5E6E6E4E6E6E6E4E3E2E5E6E6E5B7E5E3E5E5E5E5E6E5E6E5E4E5E6E585E4E5E6E5E7E6E4E3E6E5E4E5E5E5E6E4E4E6E6E5E7E6E5E5E4E3E5E5E5E5E4E5E5E4E4E5E5E4E5E4E4E5E6E6E6E5E5E5E6E5E4E4E0E1E3E4E4E59BE3E5E5E4B5BEE5E6E5D6E5E5E6E5E4E5E6E4E6E4E5E6E5E6E5E4E7E5E5E5E5E5E4E5E2E7E6E7E6E8E7E7E8E7E6E7E7E8E9E8E8E8E7E8E7E8D2E7E7E6E5E4E6E6DDE6E22DE3E4E7E9E6E5E7E2E2E3A62278E4E7E4E4E5E4E6E7E078E08B0000001B249DB3E4E0E3E6E5E7E7E6E6E8E4E6E4E8E6E4E5E4E4E4E4E2E6E6851D00009BE4E4E6E5E6E5E5E4E3E5E8E7E7E8E6E5E6E500B7E6E5E6E5B33628E4E5E7E6E5E5E5E7E5E6E2E5E5E5E4E6E5E3E3E6E6E4E5E8E7E8E7E6E5E5E5E6E1E6E5E6E5E5E4CBE6E6E7E8E7E7E6E5E5E4E5E5E6E7E8E6E3E4E4E8E8E7E7E5E4E6E3E5E6E5E6E6E5E5E5E7E3E6E7E7E7E7E7E6E7E5E6E5E6E7E7E4E5E3E4E6E5E6E7E5E4E5E5E7E5E5E5E6E6E5E5E7E7E5E7E8E8E6E7E8E5E5E7E5E7E6E7E4E5E5E5E6E5E5E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000000B0000000001000001E3E4E4E4E6E7E6E6E8E6E8E7E9E2E8E8E9E9E9E8E6E7E1E6E5E4E5E5E4E5E2E47300E3E4E3E4E3E3E4E3D6E1432B0043E6E7E7E5E5E5E5DFE3E0000026000024E5E6E5E4E5E2E4E5E5E4E0E34141E3E4E4E3E3E3E6E4E4E5E4E3000000B3E5E5E5E6E5E6E8E610E4E4E5E5E5E7E8905F001D83E2E5E2E4E3E2E1A600E4E6E7E5E3E5E4E3E4E5E7E6E8E5E4E4E5E4E5E5E6E5E6E5E4E4E4E4E4E3E4E4E4E4E2E3E6E7E6E6E5E4E3E2E6E5E7E5E4E2E5E3E7E5E5E5E5E4E5E7E7E6E6E6E5E4E3E3E3E5E7E5E5E5E5E4E6E6E5E5E6E5E6E6E6E3E5E4E6E6E4E5E6E4E4E5E5E5E4E3E3E4E4E3E4E5E6E3E4E4E5E4E7E6E5E5E7E5E6E6E7E4E6E6E6E5E6E6E4E5E5E2E7E7E7E7E7E6E7E8E6E7E7E8EBEAE9E9E4E7E8E7E8E7E9E8E7E3C0E7E5E6E6E324242B89C7E5E6E5E2E473E4E5050012E5E5E2E6E59BE5E6E589000000520100D0E6E5D4E4E3E5E4E5E4E5A6031B0092E5E3E4E4E2E4E5E3E4E50022000017E3E6E7E6E6E3E10057E3E5E5E6E4E30000039F0CE3E4E4E3E3E6E05B2D05E7E6E7E6E5E5E4E9E7E6E9E1E4E4E3E6E5E5E5E6E6E6E7E6E4E5E7E6E4E6E5E6E4E4E4E7E6E7E8E5E6E4E5E7E7E8E8E6E6E4E5E6E4E6E5E4E5E5E6E7E6E6E6E7E5E6E7E7E6E6E7E5E2E6E6E6E7E6E7E7E8E7E7E97EE7E7E6E6E6E5E6E5E5E5E5E5E5E6E7E6E6E7E6E6E7E7E6E5E6E6E6E5E6E5E6E6E8E7E6E7E5AAE7E8E8E7E6E5E5E6000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000000D0000000001000001E3E3E3E2E6E6E7E6E8E6E6E7E6E7E7E7E3E4E4E1E5E0E0E5E6E6CBE5DEE4E1E07E002B0000DBE2E1E5E4E4E5E300001243E40001E2E1D0E0006A000024000000E5E6E7E8E4E3E3E4E2E3E3E300380000E6E4E6E5E3E2E3E2E3E30000000000E2E485E4E5E00599000EDBE3E4E4E4E3B100000000E4E6E5E5E3E400D2317AE4E1E2E1E3E3E5E4E5E5E7E6E6E5A4222BE2E1E5E4E4E600E6E6DCE4E5E4E0E3E3E3E4E5E4E3E3E1E4E3E5E4E6E6E3E3E2E3E4E5E4E4E2E2E3E2E694E5E4E2E2E3C9E6E8E6E7E5E6E4E4E3E4E5E4E5E5E4E5E4E5E5E4E4E4E2E4E4E2E2CBE5E5E7E5E5E5E5E4E5E6DDE5E5E5E2E4E3E6E4E5E3E3E4E4E6E5E6E6E4E4E5E4E4E5E5E5E7E7E6E7E7E5E6E7E6E6E7E7E9EAE9E8E8E8E8E9E5E3E0E6E3E4E3DFE1E2E2E3BC476D831720191080E4E5E5E27300260000152DE2E3E0E29FE30000007800009BE4E4E4E5E5E4E3E5E4E36F00000010DEE3E4E5E517E2E3E5E50000000083E3D0E7E4E4E2789400AF83E4E5E6E6E5E40000330041E4E4E4E3E5712FE20CE4E4E4E4E3E3E5E4E6E5E6E6E6E3CB5FE5E3E5E6E5E4E7E5E7E5E5E3E3E5E5E6E4E4E5E5E5E5E4E5E4E2E5E4E7E5E4E3E4E2E4E5E5E4B3E6E4E6E8E5E7E7E3E4E5A6E6E7E6E6E4E4E2DFE5E5E4E5E6E5E6E5E4E5E6E4E6E3E6E3E6E6E5E4E6E6E7E6E4E5DDE5E6E7E6E6E3E5E0E7E5E6E7E5E6E4E4E5E8E7E6E0E2E5E5E4E4E3E4E4000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000000F0000000001000001E5E4E5E5E6E6E6E6E7E7E8E8E9E7E8E6E8E090E8E6E6E5E4E5E5E3E5E5E4E5E5E2E4050001000094E1E2E3E2E3D00E4300150064E105B1DDE4DC5D0000000000E0E5E3E2E7E5E5E3E2E3E2DB2200001B01E2E2E3E4E37CE1E3E4E3240000000049E3E5E4E6CBE4BA9B459BE5E4E3E2C90020410000E7E6E5E6E03600B55BE4E5E6E3E4E3E6B1E4A8E5E5E5E4E58B3A33E3E5E5E5E5E5E4E3DFE4E4E4E6E6E5E4E4E5E6AFE2E4E4E3E5E5E5E4E6E6E5E6006AE3E7E0E4E3E3E6E5E4E4E3E4E4E3E6E6E6E7E5E5E347E2E4E4E4E4E5E7E4E4E3E5E4E6E6E4C9E3E6E6E4E5E5E5E7E6E5E5E5E5E4E5E3E4E4E2E6E2E6E7E7E7E675E4E6E8E5E8E6E5E6E3E5E4E4E4E7E7E7E7E6D8E6E5E8E8E8E8E7E6E4E5E9E9EBEAE4E5E59D1D0C266FE1E2E1E1E61B000003000C6F6DE4E5E4E0E1CB0000000C0EDF7E01E1E1E6E5D80000000000E3E4E5E4E4E4E3E4E5E1E1A6DB830E00E5E4E4E4E3E2E3E3E0E2E3870028000096E4E6DE8E00451B0C68E4E5E3E5A80000000000E3E7E4E43A003E0038E4E3E5E5E5E4E449DE4E00C9E6E5E6E0B1B7E7E5E6E7E7E6E673220000E5BAE5E6E7E5E4E0E3E46FE4E5E7E4E4E5E7E7E6E700E3E3E3E5E6E5E5E5991BC5E2E5E7E7E6E5E6E7E7E5E35F20E5E5E6E5E4E3E4E5E6E6E6E5E5E4E5DBE6E6E7E4E4E4E4E8E6E6E6E4E4E5E4E6E7E5E2E3E5E5E4E0E571E4E7E6E7E7E7E6E2E6E5E5E7E6000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000110000000001000001E4E4E5E2E8E7E7E9E6E6E7E8E6E7E8E4E5E7E6E6E4E4E378E29600C9E1E2E3E2B1E2000000DC003EACB5E0E3E21BE00000C20000D2E08315E3E3E3191000002B00E2E5E3E4E4E3E4E0E5E4BCE2E528004C0500E4E4E3E3B3920AE2E3E400002600BCE1E1E30500735D000000E6E5E3E7D800000066E7E7E6E4E300001968E5E4E2E3E4B5DDAC83730E03E3E3E4E3626DE5E4E4E5E5E4E3E3E2000000E3E3E2E4E3E28900E3E4E3E3D6E4E4E3E4E4E4E20CE0E0E3E5E4E2E52F07004331A8E3E3E3E3E5E3E4E4C7AFD4E3E2E4E6E4E5E6E4E4E2E1E5E4E5D4E6E0E4E6E5E4E4E5E6E6E5E4E4E5E5E5E4E3E3DCE3E5E6E5E6E3E4E7E4E5E4E6E4E4E5E6E4E4E4E4E7E6E6E8E7E6E8E7E8E7E3E7E6E7E5E7E7E7E8E7E5E37A43000000789FE3E3E3E1E44C0E000000129D0C99E3E3E1E31000000000209FDFE4E5E4E2C9003A000036E4E4E5E5E5E6BC22070A75E54E4C0E0000001DE3E4E2E3E6E6E6E60E225DB50099E3E3E68500000000000000E5E3E5E61B31007AE5E4E4E6E4260000BEE3C24EE6E8E13E80A82D01D600E5E4E319AFE8E7E5E7E5E6E6E6855900E519E0E4E4E5E6E3E3BAE4E5E5E7E6E6E6E400009D00E3E5E5E6E7E5E564A1D20A00D8E5E6E6E5E6E1CDE6E4E4E6E7E7E5E6E6E6E4E5E4E4E5E7E6E6E6E5E5E6E6E6E6E6E7E6E4E7E6E7E7E6E7E4E4E1E5E8E6EAE9E7E6E7E5DFE7E7E6E6E5E5E6E6E4E5E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000130000000001000001E5E5E4E5E1E6E6E6E7E7E7E7E6E6E6E7E7E7E6E6E5E5E5E51D001543DD89ACE3E59DE1E30000007E493885E1E4E5E3B30A0C004E004CE3E2E3E34CE2A40000032DE3E6E7E4E4E12F0038362BE2E3E43C00002B0059E5E6E6E6E6E5E24C000000003638E1E3E4000000079B6800E3E6E7E5E496000A1700C9E5E60000C0E4000000E2E5E650000007000000E3E5E4E1BEE72DE541C0E5E6E56A00E3E5DBB7E4E4E4E4E5E5E2D6E5E5E3E5E6E4BA00000050E5E5E3E4E5E5E4008500000012E4E4E3E5E4E4B5E4E6E6E5E5E6E4E3E5E50003E4E4E3E5E5E4E6E6E4E5E4E4E6E5E6E7E7E6E6E5E5E5E3E4E3E4E6E7E6E6E6E6E6E6E7E6E0E5E4E7E5E6E5E4E4E4E4E7E7E6E7E8CBE8E7E8E7E6E6E7E5E8E8E9E7E7E8E8E8E7E6E6993E129DE13ADCE7E4E3E35D4E000000000AB7E4E4E4E2570000000000008BDBE11BD25D07170CAFE3E3E3E6E5E007012B001028E5E638001000154EE3E4E4E5E4E2E2E2173A00000E1741E3E10110000A4CBC00A4E4E4E5E5E6000000050AE4E62D0100E4000020E6E7E7E1E2008568200C05E2E6E7E6E3E6E6000CBEE7E5E400E5E33AE4E4E6E7E5E6E6E2E2E4E3E5E6E6E5AC000000E3E6E4E5E4E6E6E5758B8050AF33E4E5E7E6E7E68BB3E4E6E5E2E5E5E6E503D2002DE2E6E6E3E6E5E7E6E8E7E6E6E5E4E6E6E5E7E6E5E5E6E5E5E5E5E5E6E6E7E5E7E6E5B7E6E6E7E6E7E6E7E5E4E5E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000150000000001000001E4E5E5E5E7E6E7E7E8E2E8DDE7E8E6E700CBE7E8E7E6E6E7E5E33307004E002DE4E4E4A1AC312F9DE071059BB5E4E3E2E5435D0700000028E4E3E2E4DD19000000DFE5E4E6E36F0A0000992F00E0E4E000003C0C20E1E4E2E4E3E5E2E1AFE0000115AF89E5E62B47001B00003654E4E5E1E2E2100A00126DE4E7E5E4DE000000002DD2E5E4E100000C1D9D0C43E3E6E5E6E7732207A4E4E4E39BE252A10028E4E5E4E6E3E3E1E47EE4E4E4E4E3DB3643E4E5E4E6E4E5E5E590E5E27E7EE4E4E5E4525DE5E7E6E7E7E7E3E5E4E38B000000E1E4E4E5E4E5E6E5E4E4E5E6E6E5E5E5E5E4E4E8E8E6E6E3E3E6E4E5E6E7E5E5E4C9E4E5E5E5E7E6E6E4E5E4E3E5E4E7E7E7E6E6E7E2E1EAE8E8E8E9E7DCE89DE8E8E7E6E5E6E6E4E300201B0000004728E4E4E3DD000000A1439DC0C7E5DFE6E40E000000001573E2E4E5E3125D1B00E4E3E6E6E3E42B000000000020E2CDE2201B12003ACDE1E2E3E2E4E2E4E00A00000015D6E6E322003615197C50E0E3E5E2E5010000000AE2E3E4E5E63A000C00E4E6E6E4C9014500000300DBE7E6E8E3E5E61549E2E4E5E5E5E6E600E3730AE6E4E6E08EE4920AE5E5E5E3000EBE475FE5E6E4E6E4E5DFDEE6E2E6E5E4E5E6E673E5E7E5E4E4E4E6E1E6E4000C007528E5E5E5E4E6E6E7E5E6E6E6E7E4E4E5E6E6E7E6E6E6E7E6E1E4E5E5E4E4E5E4E6E6E5E6E6E1BA07E6E7E6E5E4E5E5E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000170000000001000001E6E7E6E5E7E6E7E7E8E8E7E9E7E9EAE8E7E7E6E6E6E7E7E7E4E3E2070010000000B7E2E2D8DCC7590000CDE1D4E0E4E2E2E483000000002B0AE3E2DCE0450E05058BE2E150E4E3520105050320C5E2E1940107000043DCE2E4E5E5E4E3E4E320105B2094D2E4E2E0E2011252000071E3E5E6E43100000000E5E4E4E7E4E22815031D00E4E2E4D8AF002B4100E5E6D6E6E5E1E5E30E3600E5E5E3E4780A120300E3E6E7E5DDE2389DE5E4E5E00000963A2DE1E4E4E2E4DF68DC077EE5E4E4E1E43850E3E5E5E4E4E4E5E6E5E6E426DDA60AE3E4E4E1E4E6E4E5E5E478E5E5E4E6E6E5E5E5E7E6E7E6E4E4E5E6E6E4E4E5E4E5E5E4E5E4E1E5E1E4E6E4E5E5E5E6E7E7E7E7E6E7E7E6E8E8E7E8E7E8E8E8E8E992E9E7E6E7E8E4E0E5050007E33E6DE1E3DDE289E4E32F00282FE1E3E2E3E3DBE41B000000010085E5C289780000A6E2E14717B3E443490A00000064B5E5E20E003100003ADFE5E3E4E6E37E623E3C4307B3E5DEE4E00E00120C4C0CDEE5E2E1E500000E0043E3E2E4E4E5BA002B00190057E5E4E6E4000000002FDCE6E5E6E5E6E700000071E4E6E57510070152E7E8E8E8BC3AE2D2E6E5E4E60000E2AFACD0E4E2E5E2E66F3C5FE1E4E0E6E3E3666A9B339BE6E5E4E6E4E4E4E49D901BE2E4E2E3E6E7E5E7E5E2E5E2E1E4E4E4E6E7E6E7E7E6E6E7E6E6E6E7E6E6E6E5E7E7E6E7E5E5E5E6E7E7E8E7E4E4E5E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000190000000001000001E4E4E5E4E6E6E6E5CBE5E7E6E7E7E7E6E7E56DE6E4E6E6E5E4E3E2830C007C1564DC24E2E5E4E3E357000E01030A20E0C789B7E2C54300071BE0E0E383E324006FE4C5597E00A48500000033000085E326E30000000528996FE2E4E4A4E1E26F00100700177EE5E5E16A0000000A4E625FE2E00000000000E3E5E6E6E54C00000000001BE3E5E3E2002B012F50E1E3E4E5E0E20073000000E2E2E5E25728CD31E5E4E4E54CDFE400E3E4E4E100000A3CD8E5E3E6E4E05B5B000CE3E5E3E4E31278A4C0B3BEA8E5E7E4E4E4E2E38B3807E1E4E4E4E6E4E5E5C7BCE5E6E3E4E5E4C7E4E5E6E4E2E4E4E5E4E4E5E6E5E6E5E5E4E5E4E5E4E6E4E3E4E4E5E3D4E4E5E7E7E7E8E8E7E7E7E8E7E0E8E6E5E6E5E5BE2BE7E2E4E4E3E4E3E50020000000382062A4E2E2E1A48500050E000A0A22E3E4BE451D20D60A05E0C9E2D09D6DDC7CE1E207152B94E1315F1D261952E4E1C5D2362F0307057AE2E4E5E6E2E2E3541D0533240010DBE6E5000001001700E0E3E6E55F0C1010E57E8590E6E473240000000000E3E5E5E6E459431DBCE1E8E0E6AC570000000000E4E5E5E178943C17E2E3E5E0B1E40000E5E4E55B50E0594978E5E6E6E1904EB77300D6E6E5E3E42001A6949FE5E5E5E7E5E6E5E5E4E2789BE4E4E5E5E4E5E5B1DE8EE2E4E5E5E4E4E7E5E6E5E6E7E6E7E6E5E4E6E5E6E5E6E3E4E5E4E6E8E6E1DDE7E6E5E3E2E3E6000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000001B0000000001000001E5E5E5E6E8E7E7E7E5E6E7E6E8E7E9E8E7E2E4E5BCDB33C2E3E2E0E22D00000001287C9FCBE1BE940000000000016431E1E3965B00171724E2C7E0D8E0D6E14CE1E1E16A000762E233002200000CCDE1E1DF07000000000064A6E0E1E4E3E12B10280000ACE3B7E4E2000000003C0119E3DFE2680031901900000064E2E3E2AF00000052E3E3E4E1A43A070100A6C7E3E3DC228B0000000000E2E5E3E278000083E5E5E4E5E5730085E4E3E100895FAFC5E4E3E3E2457852AF28C7E4E4E2E310002641C2E5E4E4E3E296E3E3E5E4E5E2E3E3E2E4E5E0B1AC4CE3E3B1D6E6E5E5E4E2E5E4E5E5E4E3E6E5E5E5E5E5E6E5E3E6E3E5E5E3E3E4E4E4E5E3E2E3E5E3E7E7E8E8E7E6E7E7E7E5E6E6E7E7E9E8E8E8E5E400360C1749E1E4E1DF0000BA2001055252C2E44E000000002B0022685BB5D2A8102F3622C2E0E2E3E49657E5E3E4E1C0430547E4E0855D00000028E2E2E46F3E0000E20033E575E5E5E4E4E2432F1D00006D0578E11B000000190071C5E5E7CBE0E2000000000068E6E6E4C00012002D26E4E5E6E50300E4E3E6E58BE6E2C0E6E10A5D3C0000E1E5E5E6002B7A41E5E6E4E6E03E87E5E6E4E2E3E4E3E4E1E4E44159E26D5BE0E6E6E3E3E1DBE5B74E59E5E6E6E3E01DAAE3E6E5E5E5E6E5E4E6E6E592C9DC9FACE4E6E5E5E5E6E7E6E7E6E6E5E5E6E6E6E8E7E6E7E5E6E6E8E7E5E5E5E5E7E7E7E6E0E4E0E4000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000001D0000000001000001E5E5E5E5E6E6E6E2E8E6E7E7E6E7E7E8E8E7E6E40000000CE1E3E3E1E20E2B00052652432D31E2A6E00700006600382DE1E1E5E3002F7A00004E4536E2E35DE5E6E3876F000005AAE3E01200003A2FC9E2E5D015000000001DE46AE3E2E4D8E22F000000003A0003E4780000004E3100AAE5E4E4E4E4000000050000DDE53E00000043220026E5E6E5470045C2E2E6BE6DE4D8E2E76622E10075E2E4E5E4DBE400E2E2E5E5E4E4E5E2E3E4E2032F36E4E5E4E6E0E34EE3DEE3E4E6E5E2DB0E015D7512E5E6E6E5E6E2207AE5E4E5E5E4E6E4E5E5E4DFC0AAD845B5E3E6E6E6E5E5E3E2E5E4E5E5E3E5E4E6E6E8E7E7E7E7E5E7E7E5E4E5E6E6E5E4E6E5E5E5E4E7E7E8E6E5E6E6E6E7E7E6E615E7E7E8E6E7E60000000000AFE3E3E5E4E35F01002600150001D0E3D83A000000000C49E0E0E3D600000000001B0552E1E3E2E5E4E0150300000000E3E34300A83300D6E1E3C05D2000000000AADBE5E3E49F6FE50C00E200000C194728017A003A0000737EE4E4E3E400000000000000E7D0380049000000003AE4E4E4000500E30E00A4E4E6E5E400689D000CAFE5E20022001BE2E3E4E6E4E2E5E5E4E6E60E5900E1E6E5E4E4E5E3E4E4E1E4E5E5E6E347B54C0A83E7E6E6E7E59207E0DBE6E6E1E6E3E5E4E1E46F50DEB5E3E5E4E6E5E5E5E6E6E6E6E6E6E7E7E5E6E7E8E6E5E6E6E6E6E4E5E6E7E7E6E5E5E4E3E4E5E6E4000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000001F0000000001000001E3E4E4E5E7E6E5E6E7E7DFE5E7E8E7E7E9E9E5E200000000E1E2E2E0E3E3730C0015000C052DC2A67EE03C0700000C2B6820E3E4DC1922000000000162E4E5E4E0E25D0000000000B5E43E00120A36E4B3E3E3E3C90E152F7812BAE2E4A6E3D2E3100000000331E3E2E1E37A4303003600ACE3E3E8E6E400000000CDE6E6E5E700B72D94000E909DE7E38919E2E0050000C9E4E4E3874C0000B5E2E7E2D005E3DCE5E4E0E2C236103CE4E5E5E2007868E6E6E494003E0596E2E5E5E5E3E3E3E492E3E4E3E5E7E4E0545FC533BAE5E4E5E5E5E4E6E5E7E5E5E1E4E4E4E6E6E5E4E3E3E5E4E6E6E4E6E5E0E4E6E7E5E6E6E8E5E5E6E7E6E6E8E6E5E3E4E5E2E5E5E6E6E6E6E7E6E7E7E7E5E6E7E8E8E6E7E6E6E8E7D40000000000E3E3E4E0E53C001031000AB7E3E4E3E3B1920038222654A8E3E32B6F31000000000017E2E3E3E549E1450000000000E462000012AFE3E1E1E3E1E30C260A683AE1E0E3E3E4E3D6E1014E0001002212D8CD2FE10100010500E3E5E6A6E6A1280017030094E1E189E410002B00B1D2C5E5B145E2E4030000A4E4DD00E20000001DE5E5E5E5E4337AE5E7E5E67ADB4500DCE5E5000000E3E3E6E4503E9B49A8E4E4E0E30000008EE5E5E6E4E5E552E264E4E39DE5E5E6E6E5E6E5E5E2E6E7E6E7E6E6E6E5E5E5E5E7E6E8E7E5E5E6E5E7E7DEE4E6E6E6E3E6E6E6E6E5E4E5E5E0E5E5E3A6E5E4E3000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000210000000001000001E5E6E6E4E8E6E7DDE7E7E7E5E6E8E8E7E7E6E8E8E4E3E05F001280E6E3E4E390382419004CB5E2E392E080780C1D000A2D75E3DFE3BA2020013E000000E3E3E3E5DD1D000000000000BCE347006D260057E0E5C95B5F0022000000C2AAE1E3E4E6220A170C20360A00E1E4E6002F00E10000E5E5E322E4220000032250C2E0D8E4E5000000B375623EE4E5E0E5E000000003E4E4E30700C9000543E3E4E215196659E4E3E57E2D0C5BE3E44700000092E4E6E36A0015E3E1E2E4E33300A80000E4E6E4E5E3E4E6E3D675E2E0E3E3E5E5E5E6E4E4E4E3E6E5E6E4E5E6E4E5E5E5E4E4E4E4E4E7E5E6E5E6E6E7E5E7B3E5E6E5E5E5E6E6E6E5B7E445E8E4E0E2E3E7E7E7E7E7E6E7E7E8E8E7E7EAE9E9E9E7E6E6E6E7E6E5711DE2E3D2E3E5E4D4A4240E54032224E1D8E46887BE2B00071B00D8E2AFD82F00890000003AE2E4E1E1BE5D2FBE710E0031ACE49F547115070E54E5E6E249050500000000E2E0E4E4A83E00052010001D0E68E5E4E30000E000105DE6E6DEE6E6360015000001E3CDE4E41D0049310AE1E5E6E6E5E6E50000001DDEE6E50A000500260059E3D4228E508E59E7E4E5005FE2E5E520170000DCE6E6E603C74799E6E5E5E30003000000BEE7E7E4E5E22DA1E2E0E3E3E6E6E7E6E7E6E5E6E5E5E6E6E7E7E6E8E5E5E4E5E7E7E6E5E5E5E4E6E6E6E6E4E7E7E7E9E8E6E7E6E7E5E7E7E6E6E6E6E0E3E5E4000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000230000000001000001E4E4E5E5E7E6E5E6E8CBE8E8E9E8E7E8E8E9E9E8E7E4E4A67CC062E2E4E2E4E3E34731000019076AE0E2C964122B100000001BE1E2D264000000079FE2E2E2E3E203E1E39D00000000C0DEE2200C0015BCE4DEE4E5900A0000001000C094E4E4E3990000007A0000B7E2E4E466000300000ADEC5E6E5E6E50000003C0007E0E4E4E2DE017C57008E24E2E4E3E4E500002FE4E5E494E4B500003E0110DF470031A4000E99E287001D87E0E568220AE2E5E5E3E4E5E21099E0E6E5B7DBC5505BE2E5E5E6E4E1CD8BAA89C2E6E5E4E5E6E4786AE3E4E3E4E3E4E6E6E6E7E5E5E5E4E5E1E5E3E6E5E6E6E8E6E3E6E5E7E5E6E6E6E6E5E5E5E5E5E4E4E1E6E5E5E5E4E7E7E8E7E7E1E6E6E5E6E7E6E6E7E5E6E6E7E7E7E7BC52416FE4E296B5BEE3E0E3DC0C010000013ABEE4BC6F0000001900008589E4713601001933BCE4E4E49FE4E3C552412F1B030033E3E49600000A002FC7E6B5415949000000170E38E6E6E6BC000000000022752628E2E30C0033120564966FE5E6E32F0E000C000092E4E6E7E8331D24052DAAE5E5E4E4E4D07C0031E2E5E6E5193C2845000CDEE500E3E50578C0E345003A00E4E5570050E4E4E5E5E6A854472DE5E6E6E4E341070071E6E5E5E220C7A6DDE3B7E5E5E4E4E5E3E2C759925FE4E3E1E6E7E7E5E4E5E4E6E5E6E7E6E5E5E5C5E6E6E6E5E7E7E6E759E5CDE6E6E6CBE6E5E07A7AE5E4E5E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000250000000001000001E4E5C9E5E7E7E8E7E8E6E7E6E9E7E5E9E4E6E6E6E3786D57001BE1E1E2A1C2E2E1E400000000000000E0E3942600000000158026BEE2CD4500419062D0E0E18EE4E3E4DE667C0000000ADBE0E20C000000008EE4E34C92152415281D0700E1E2E5E500000000000000594EE2E224003C006603527AE2E4BE570A00102D47E3E4E5E5E562001D072054E2E1E3E4B7A817001983E4E3E54599A85BCD0C9DE422DB005D7CE4E40E280C002FE4E4D805E0E4E4E4DE7AE1E3C7E5E4E592646F318EE5E6E5E5E5D89FC09DE2E3E4E3E4E4E5BE64E3AC5F7AE4E4E4E3E3E4E3E4E3E4E4E5E5E5AFE4E5E4E6E6E6E6E6E5E5E5E6E5E5E5E6E6E4E4E5E3E4E5E6E3E4E4E3E7E7E8E7E7E6E7E4E6E6E5E5E5E7E3E7E6E5E5E4E5E0E20A0031001DD2E5E4E4E4E1AA4E000000000071E3DB622F000A36000E0CDCE0B5A63E12B3E2E3E4E2E3E6E6E6B3C73C00001536A8E36A4500100E00ACE3E4E42D3E002F000E22D4E3E4E5E4E2E37A45000000220389D099809F0017000A0EC0E4E41B010000010ACD8B00E2E5E2151B00E3E5E5E6E6E30AA67EBC572290E4E4412403750000E2E3E38B000028E5E347151231B1E4E4E5E5E6E5E3E4E58EC766C9E5E4E23E33C754E4E4E4E3E3CD1BE443BEE5E5E4E7E4E4E44EE6E0DDE4E7E6E5E5E6E4E8E7E5E3E5BCE5E6E5E7E4E4E5E3E7E7E6E8E5E1E6E5E6E6E6E7E7E6E4E6E4E3BCE6E5E5E6E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000270000000001000001E3E5E5E5E7E6E6E6E7E7E6E6E8E8E8E7E5E6E4E5E4E4E4AF00000000996AB5E1E1E1DE0000000101103ED6E2E14300000000031538DDE24C03003CE0CDA1579BDEE3E1A6E187070E4EE3E3E4E2E36600001952B1E2E4D40700120000017CE5B7C7E3E1E419000000000328DBE390E13E6D0000000054E6E4E42600280528000001C7E357018E0141E6E6E7E4E478002FA42D073CE3E5E000224C2800A8E5E5E47826DCE5E46D0385AF71E4E4E5E4E5E4E3E39F2B2600BEE2E5AF3826E545E5E3E5E4E69D120750AFE4E4E6E4E4E200B32FE245E1E4E5E4E0E3E2E2E2E4E4E3E2E3E4E3E4E6E6E4E5E5E6E5E5E4E3E4E5E5E4E6E5E5E5E4E6E5E6E4E1E2E4E5E1E6E7E6E7E6E6E6E6E6E6E6E6E5E6C5E5E5E6E5E7E56FE45200191D38929BB1E2E2E3686F000A000E3A4C62E4E25200000C364E00173CA178BA20009DE2102022E0E4E2E5E6527ADF17E1E2BAE4E0DE500005E1E2CBE6AC261000752400ACCDE2E3E3E49B7128261703281294E3E2E3E3A60E030000248EE4E2750000005707002217E3590A47E52FE5E3E1E4E3E222CD3C3600571DE6E31900A62057E4E4E5E27EE2E2E3E4E4E2E00071E5E5E3E5E5E4E6E36F2B0057E5E6E4E08B006A41E1E4E7E6E3E2D01DE3E4E6E6E6E6E2DC00E32B9243E6E5E4E4E5E2D0E2E3E0E3E3E3E3E2E3E4E5E3E6E6E2E5E4E6E6E6E3E5E4E6E6E7E7E6E6E5E7E7E7E8E3E5E0E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000290000000001000001E3E4E4E4E7E8E7E7E7E8E6E4E9E6E8E6E3E5E6E6E6E5E4E4E00A17000054DD9487E58BDD00002BB7202694E3D4E1360000122B00197EBCDDE27A009F520031005BD8E3CDE04E4E310020E2E5E5E1C29D0010992B5DE3E280010C0000005DD8E3D0E4E3E2E27A192D001D45B5A4E5E0BAC717007A000068E3E4500000000000000031E3C9BC000000E5E53CE3E2009B190315032F2666E3C70005668BE3E4DC0003001DE1E2E4E4E4E4E4E5E2E5E4E4E5E4E4E23E526A78E4E5E29DB100CBE5E4E5DB1089E16DE3E6E6E4E4E5E4474517E1E4E5E4E3E4D6BCE380E4E0E2E2E3E3E5E4E6E4E4E6E6E4E3E5E5E4E6E5E4E4E3E5E6E4E8E6B5E6E794E7E6E5E4E4E4E6E7E7E6E6E6E7E6E7E7E7E6E6E6E6E7C2285BE6E7E6E1E5C9380000000C5B9BE2E4E2E30A051983DBDD8BE2E371D2360000002B0054DCE2D86AE266005B2D0775E4E4E5E383BA1D0007E0E3E3E4E3AC0000003E75DBE3E3E02401051003E0E4E2E5E4E4B5AC3349000010A4E483D050201500241B0112BAC7E119123C0A000000E1E5E475380341E4E289E3E3DCE10A03226D00B3E5E3E3E5E5E6E5E55078490571E1E5E5E6E5E6E52443E4E5E5E5E4E6E7E6E59F874EB1E5E54E59B1E4E4E4E26A6464E2C7E5E6E5E4E4E483E5E04E33E5E5E7E7E5E7E5C7E3E5E6E8E4E6E5E4E5E4E4E5E6E5E4E4E3E5E6E8E6E7E5E2E1E5E5E8E6E6E6E6E5E6E0E5E6E5E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000002B0000000001000001E3E3E4E4E7E7E7E7E8E6E8E8E6E8E8E568101BE7E7E6E6E5AA3300002F0017E1CDE1E4E3E143003633D8A8E5B1E1A69F120105150319A8B3E56AE5450CE36419128BE2E5E47C9678000C2F7EDEE3BA620E36001033D4D2E2785D7300052D5DA1E1CDE4E4E2E026121728871750C2B7BA20001200002405413CC21D00660000003600E5E7170EE0D2E5C2E2E4E2E3E10000E3310020B5C0E2E5E5E7E5E49626E1005DA1E5E5E4E5E5DB9D8B36A8E3E3E4E4E6E2E3E5E387E1E5E6E4E2E3E4E4E4DDD80E0CE1E2E5E5E5E5E4E3B5E0E27A94E4E4E5E4E4E6E3E1C7D4E0E4E5E5E3E1E4E2E4E6E5E4E3E4E5E5E4E5E5E4E4E3E4E6E6E6E5E5E5E4E2E4E2E0E3E4E3E5E6E6E6E7E5E7E6E8E6E6E6E6E8E7E40E0119E7E6E5E3E32B943600000000E4E2E3E3B76D240019033154B7E3E1E4E0453E0A0E001003E3DDE2E2E138010024C7E1C5E3E5E1D84900000059E4E5541B0500381210127EE4E22BB13C0E071000B7E5E5E5C7CB244C00A60A004900C0E8000047006400000317E2E2E0E50E0E001220DEE5E4E3E6E728573ADCE5E5AC5F0000410C07E5C9E3E1E2E3E4E5E2009200ACE4E5E5E4E1AF03244333DBE5E6E4E3E4E5E2E5E4E6E5E4E5E3E5E1E5DFE4E30590014EE5E5E5E7E5E4E6D8E4BE3AE4E6E7E7E8E6E7C000070CDFE7E6E5E5E4E3D8E5E6E7E6E6E7E5E5E6E7E7E7E7E6E6E4E7E5E6E5E6E6E3E6E6DEE1E5E4000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000002D0000000001000001E3E2E4E4E6E6E5E6E7E6E7E6E8E8E8E6AFE3E5E4E4E6E190E2E19000001589C0A887D8C9920000000012478315E2E2C58926004300330087E2E4C9E1E05200003A6DE0E3E2E0D80000E100C5C7E3B72D00032F05000000E3E5E200100007000028E5E4E7E1ACE4364E2619000083ACE30A000000AF2D6D3C2FE1E4E5E6DFC7520000E4E7E6E2E5E092E185E4E645C20A4E05030700A8E443E3E5E0E4E66A94310043E5E5E4E3E3E5AC751722E6E5E4E5E4E352CDE3E0E3E5E3E5E5E2E6E4E4D2E05438AFE3E4E3E3E4E2E4C0854185A1DCE7E4E6E4E4E2660124E4E4E4E4E3E2E4E5E2E4E6E5E6E5E4E5E5E4E6E6E6E5E3E4E5E4E6E6E5E3E5E4E5E699E4E5E6E5E8E7E7E7E7E7E7E9DBE8E8EAE8E8E300050A5BE0E6BC4CE5E5D06D103A1296E16F38E2C5AF000000000080D8E4E1E3B10100000020D0E1E3E5E3B1381533261D5743DFE3E4DB0000000341D2E4E3E2121500C5002B00E4E7E34345000E00000022AFE3E5E2E1E3E2412800856880E6E2E10C00001200050EE4E5E5E3E40000000064E3E6E4CDA4E2E4DCE5E4E4E152891241500054E8E5E3E6E4E5D61B0073203EE2E5E4E4410EC7E23107E4E5E4E4E3E52D832D75E5E5E5E5E5E3E5E5BE8038C0C0E5E5E6E5E6E6E5E4E0E44562C9E6E6E4E5E2E2E19928006DE6E6E5E5E5E5E4E6D4E5E5E6E5E6E6E5E6E7E5E6E6E5E4E2E4E5E6E7E6E6E6E6E2E2E4E4E1000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000002F0000000001000001E1E5E5E4E7E7E6E6E7E6E5E5E9E7E62D00E57A12D0E0E6E6E45F00DF00190001058780E4AC1B0000000000319BE0E0E3E1010C0000432BB1E4E3E490542D0000002438E27CE1B55F0000001BE5E1E3E45D100022000000DBE3E2C2360300002D000026E4E5E3E2E3B51D3600005DE2C7E3B10300000100100022E5E4E3E0001500000041E5E59212E3E438E1E4E2DF5D45240C125D002DE5E4E6E4B1170057004373E2E4E2E2E001E0990085E6E4E2E4E4E43A6AA49BE0E4E3E4E4E4E5E5E3C215418BE3E5E4E5E6BE6D59E46433E5E6E2E6E5E1B5E3E2E2D066E2E6E4E3E5E4E5E4E5E6E5E5E5E6E5E5E5E4E3E5E4E4E6E6E6E7E2E5E4E3E6E6E7E68EE5E5E4E5E6E6D2E7E6E6E6E8E8E8E8E7E6E8332200050305E6E5E6E4DE03120000AA00001B00A8E29F20000000001B9F31E3E390E226033157E1D2E5E4E4C045052400005D38E1D4E2BE50BE2D31208EE4E3E3E15D000C0003529DD8E3E3DB17000000002DA6AFE4E396E15F5F2220EBE5E0E3E39F2F491915056415E27554E3E50500000000D2E3E46200E6E12F8EE5E5E3A8E7E600100C0700E6E2E3E4E3002D8928527AE1E2E7E778D2BE240E33C5E4E5E5E4E3DB59E0711BE0E3E5E5E5E2E3E4E4B39DE6E6E6E5E5E5E6D6E559E5E5E5E5E5E5E4E1BECBE3E2CDE5E3E5E2E3E5E3E5E4E3E4D0E690E6E6E5E5E6E7E4E6E5E6E5E4E6E7E6E8E7E4E3E5E4E2DEE4E4000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000310000000001000001E2E4E4E4E7E5E5E6E6E3E5E5E6E7E70000003CDD3A966DD2E2E2C90000010000001924E2E2960A0000000000003180E226E173030700CDE1E2DBAFE49B7E03000000105DDCDBAC7C3E36000C005BD0E2E77107000022007AC5B762D4D40000520000BC7CE0E2E1E0E1E07A0003E77EE2BAD65B9D00003801263C01CDE0751500002415E1E4E3E399E0E14E6FA8E6E5E6E501001B001D1043E4E5E1A6750000004C2D36E4E3E21073501B00B7E3E2E2E3E5E41228E2DBE0E1E5B7E5E4E0E2E3C0C026E2E3E4E2E4E31066E59468E3E4E3E3E1D800B18EE4ACE1E2E3E2E4E3E4E3E5E5E6E6E4E3E5E4E6E6E5E4E4E2E3E5E2E4E5E3DDE4E5E4E5E4E5E2E5CDE4E4E4E7E8E6E7E7E7E7E7E6E6E7E6E6E8000036E2B5E2E0E3E5E5E3E4E20A000000597E99E0D094C23600007107000AE05FE3B3BC00282407DCBE8936E1AF6A3100000003037EE1E5E05F200000000CC2EBEAB1030000101D5B92EA9F28D6363E000000105D2D9D7C68A6411712458EE254E3E2544E0000122B2899DF9FC5AAA61B380015E09BE3E5E5E5E3003320AFDFE4495959832649055FE2E5E3E4546410000317E4E2E4E5E4E50C0715C9E2E4E4E5E6DD317C54175DE6E5E4E0E7E0DFBAE4DFCBE5E3E0E5E5E42D6A62E2E2E4E6E4E6E389DBE5E4E0E4CDE5E4E7E3E4E3E594E4E4E4E1E3E5E5E4E5E6E5E4E4E3E4E7E6E6E6E4E4E4E4E5E5E4E7E5DEE6E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000330000000001000001E2E4E3E4E7E7E6D8E5E7E6E6E6E6E61903389994E1E1CB36E068E2A11500317A1D1573E3A8DBDE33000C0000002426D2E1C9E0000000009971152D99E19B620000120C262BBCDDC0E1E6003A000EBEE5EA5D7CC900000000E5E8E9890066122D000000265DDBE0E6E478004C001500DB83E3E1BA5401005941A6E2E012E2E4870001122BE2E4E3E5E3E324E09BE1E3E4E5A800100A203C22E1E4E4E4E149030700A8E2E4E4E4E40000000068DFE3E2E3E37507472DE0E2E4E3E3E4E48E66E4E3E6E5E4E6E3E4E41B263E8ED0E3E1E3E5E4E268039FE4E2E3E3E4E4E4E3E3E4E4E3E4E3E2E3E4E4E6E4E5E4E6E5E6E6E4E5E4E5E4E4E5E4E5E6E4E7E5E4A1E4E4E5E7E7E7E6E6E5E6E7E7E8E6E0E7E8E3000000E1E4E3E0E3E3E1E1E0E07E2B01000000AF36C2DE7C0000000000000AE1D88E0043000026000000007AE00A120000000000D0E4A1E6DBE200000000D6E1E9EBE79400000000D6EAE1E580364C000000010017E6E8EBE3E215005B2D000CA4E2E3E24500002BE022000041DB90120024000043E3E5E5E4E5B5C0E6E6E6E4E5E501576F179901E4E3E4E4E33E260007CDE5E5E19F00000001E2E4E3E3E4E457000080E1D8E2E4E4E4E5E5E4923ACBE6E5E5E5E4E4E159E010C7E3E5E3E5E3E3E4E3520049E4E4E4E5E4E5E6E4E4E2E2E4E4E4E6E4E4E5E5E5E6E5E3E2E4E3E5E6E5E6E3E2E3E5E7E7E7E6E0E4E1E6000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000350000000001000001E1E4E4E5E7E6E7E8E7E6E3E6EAE9E7BE00070000334EBAA4DDE2E0E2C99BE11D28000052E0E29F2B00000020000000001DE2E0B7800A28150000646FE1E25B000000000000E5E1E1E2BCD800000022E2EBEBE8640E2412036F9080E7E37A00050000000028C5E094CBD499000000170089E1DCE1150000000A28962DC503430A000305006AE2E6E5E6830019E1E3E5E4E4E12B2B00000012E5E4E3E4E21200410047E5E4E2730000AC2200E1E4E4E55F0007260AE3E3E4E4E4E33EE0E1003AC0E5E5E4E4E6E55400E1E4CDC0E5E4E5E5E5E2E3E4E450E5E7E4E3E5E4E7E4C5E0E1E3E4E5E4E3E3E4E3E3E4E3E6E6E3E3E1E4E4E4E6E6E4E4E5E5E5E5E4E2E2E5E4E7E8E7E8E6E7E7E8E7E7E7E9E7AAE9E07505710057D815C9E2E3E5E4E0E2AF280E0C9D2FE47CE20700000E0000001200E4E35296E08B00001500126FE368DD00120000000059B7E0E2577E1B003871E1E8C773070A000007544E7CE48747240000000000501BDEDEE8E0000000504CBECBE2E5E96624002F1B1B433EE2E101004C000EA1E3E4E2E04E4507006ABAE6B70710156A4131004CE6E7E4520A000000E4E2E3E3000043000000E6E6E6E7E5311B0022E2E5E5E3E6DC00332400B1E4E6E7E6E4E7E51BE10007AFC9E6E5E4E5E4E38EE026E6E7E6E5E6E7E552668EE6E6E7E7E6E6E4E5E6E6E5E7E7E5E396E3E6E6E3E5E6E6E4E4E7E7E8E6E1E5E6E6000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000370000000001000001E3E5E5E5E7E7E7E6E8E8E7E5E5E8E6E8E500000010006D246F9FA4E3E3E4E3C0E33E005F1DE3E05092000000000A0373A4E3E2577AE0E10007AC000000E1CB2F6D00BA00000001C7E3DCDE661D1759DBE5E3E89900000001006FE1E1E4E4E2C7335F3A00000000198EA6A8281500284100BAE4E5EBEA62001726000017DBDB000000000015E3E5E3D05D26006AE5E1E6E4E30000000A0000E4E1E3E4E21D150000C2E0E4E4A42F002D009450E5E5E4E3002F1B4307E4E3E4E4E3E412E4E500E4E4E4E4E5E6E5E5E4003CCBE4E4E4E6E5E3E4E0664EE5E0E4E4E6E5E42BE2E1E2E2E3E6E4E4E5E5E5E4E6E5E5E6E6E7E5E6E3E4E4E6E5E5E4E6E3E6E7E3E6E0E5E5E7E7E7E5E5E6E5E6E6E5E5269FE7E7E9E4150E0A71E09678E2E1A65BCBE0E16D330C0A008BA47105000000001001004CE3E0D49BD89F0000002D1200B5E3E212000019170005E1E4E0BE1B000005B7BADBE5CD00002D000147E0E6E6E4D8243A1B73D2000000E0EB9FD052384700000041B1E5EBE99289B5000000003CC50000E5000000E0E6E5AF781759E7E6E6E7E6E5DB01002200226FE3E1E5E5A6382043E4E1E2E3E4E54147859B64E3E3E3E4CDE09DE4E4E5E4E5E6E5E6C2000000E3E6E7E3E5E8E6E5E6E6E4E5E48EE4E6E65DAC225FE4E5E5E6E6E6E5E59BE7E3E6E6E3E6E5E5E6E4E5E3E5E6E7E4E6E5E6E6E5E6E4E6E7E6E6E6E6E7E7E6E4E4E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000390000000001000001E0E5E3E4E4E2E7E7E6E7E9E7E5E8E7E6E7E503150000A100050085D0C9E2E2C2E180D6545DA4E2DCD02B0E0000000000008ED694E3E30001000000000E1BE0E205003112002494EBEAE03A000000000043E2E9E500000000002D15E77EE36D281507000000034389E6E5E1E3E3751D00000C4CE2CBE2AF9F781B1003781B7C000000001D2FC5E4CB070C5B643AE3E6E5E6E5E8E50096009612E5E4E45D833A246F15ACE4E5CD1017450045E4E3E2E4DF3C8E3E1BD4E4E3E6E6E6E138410738E2E6E6E6E5E685E3E4E4E4E4E3E4E2E1BA38D0857CE4E1E2E49DE5E5E2E2E4DED0E6E5E5E5E6E6E7E4E4E2E3E5E5E5E4E5E5E3E4E6E4E4E4E3E4E5E5E6E4E5E7E6E3E6E7E6E7E7E6E6E7E8E9E7000015E8E7E79F1700190100000041E3DE8E667E9FE1AC193892BA9FE17C030000000000006F24E3E5E56A680E2B22070A7EE5C2525D360A005041E2EBE0BE0000E10301E4E7E75400000028386200DF15E4E31700150000473838B3E1DBB3E3BA9F0020000092D2E7BEEAAFDCE3942633003E96004C453822E4E5E3313A283A66E4DF054C2B223E002D00332880E3E48E0000229405E7E5E6E6498B0E4105E1E3E5E5E478E0872B57E4E4E4E5E37A472D49E5E5E7E5E6C03A0307DBE6E6E6E8E5E5E5E2433C36E2E6E6E7E7E7E5E1E3CD94E4E5E5E3E2E4E6E4E6E7E5E2E5E6E8E6E7E8E6E6E6E5E7E7E6E8E6E7E5E7E5E5E4E3000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000003B0000000001000001E3E5E6E6E3E5E6E6E6E6E7E5000000C0E7E7E70000033EE500006FE1E48BE24E2D80C26FB3C24CDB5DD42800BE0012C70096E1E3D4E5E00005000000000E7ACBC71200002B0A17E0E6B5E0190000001D64E9EBBA000000000007758362EAE5DB00000000001564474CE56F1DDF0E008000000059E6E2EBC0DEE1803C004100E10A450054E2E3E459500E54DBE3E30000005D002F00E000333EE4E3E457363C00005DE2E4E5E6E5330031E0E4E5E6E5E63AC00028E5E7E6E7E2E4478B003CE3E4E6E5E46205E3AA01E3E5E6E3E5E5E2E6E37EDDE7E6E3E5E4E4E42D00B5E3E1E5E5E5E5E4E5E5E4E4E7E5E2E6E4E3E4E6E5E4E3E4E3E4E6E5E6E5E7E5E4E4E6E4E4E7E7E7E7E6E7E7E3E5E6E65B000083E6E8E8A10003001500202D8EE080E25F0585E2E3A8E15DE2DC54E2190001001B264EBCE3E3787A1900000000000517E3E390000064070C33E1A8E3E1000000009BE7E4E3050010000028504E75E9E79B242D030000121D0000D878DBE2000000150020A6E9E4E2CDE01B000036310022E400006AE1DDE4E4E29F7C38ACE300E4472247260E9D001D4CC0E3E1E20003B3000054E3E4E412000050E6E6E7E6E45743E4DE3AE3E5E5E4E2E219000041E1E5E7E6DF945D8E0C8EC9E6E5E8E5E6E6E5E6E4E5E6E4E4E3E45400E3E55FE3E3E3E5E6E4E5E4E4E5E4E6E6E6E5E5E4E4E7E7E3E6E5E4E4E6E7E5E4E4E3E5E5E5E2000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000003D0000000001000001E1E3E4E4E6E6E7E6E6E7E6E600000000E2E0E5C2593600003E288041E2C2D0A84E90877EBEE1DDE1BEE199E10000003328E1B1E2E0E0800000002400000052C2E4A68000000000005B62E4E3330000D0E2C0E4CBB5AC22E3000000000C85E7C2928017070057000000B5E58592D2000000009B68E5E3E2DBE200107CC20000E2E56A26E7E3D0E0E4E41B00E0E4E626D07A262083002B000083D4E1E1DE0000E400001DE3E4CB00A44E0A43E4E5E0E2126F3A0A0AE4E5E6E6E27868BC003EE2E2E2E1E22B28E3E1AFDEE6E6E5E5E4E6E5E2E4E5E6E6E5E3E00A12E03350E2E2E0E5E1E4E3E4E4E6E5E4E4E5E4E6E4E5E5E5E4E4E5E3E4E2E7E4E5E4E3E5E522DBE3E6E6E6E7E6E7E6E7E6E6E417006F1980E4E3E443190000000E6D718BBAE119191D660CD8E2E2E3DEE092640038663C80DBE2E4DCD8101B000000002D003E6ADC712220000000000E50E9E7E171151D0010CBE2E2991500010A00000000E1E38B332400380000000022851DDC9F170000000A8083EBE2D0E2E31B22006A1285E1E2E3EAE7E2E3E1D028283EE2E8C9070A20DBC954753C1000E5E4E5DC22226800002DE6E5C70105003349E5E4E6E5E54C2431E5E3E4E3E2E3685B6D24E1E3E3E6E5E47E5F595728E7E6E5E6E73EE1E5E5E4E5E5E5E5E5E4E0D4E317E0E5E4E5E7E5E6E6E5E6E5E6E6E7E7E6E4E3E3E4E7E5E5E5E5E4E5E5E6E6E6E6E4E4E3E0000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000003F0000000001000001E2E5E5E4E6E6E6E6E7E7E7E8E400177EDBAAE4E7ACA6000000000012C0E2E30000380E0150BC6DDBE2B3685924381D9017E2E2E5C0E0E394DD57001000000C01CBE27A5F008B380024E2E1EBE95900000000387C2B9466000010000000E1A6E4E4E300000000710000104185BCD0781000200092EBE1E3E0E0E26A000000992026C2EBC0BE49DD6D942FACD6EAE6B1E3E343E4000073288B3EE3E3E3BC3AAC00220A41E2E7E25417002BB3C2E5E5E4E08E5B17E4E4E2E5E4E5E092E5E4E4E2E4E5E5E1E226945922E0E6E7E666B1BCDEE3E4E5E4E5E5E4E3E5E3E2E4E4E5E4E6E5E5E5E5E7E6E8E5E6E6E4E7E6E4E5E4E4E4E5E5E1E5E5E5E5E4E4E5BCE4E5E5E3E4E7E6E7E7E6E7E9E8E8E8E74778E5E4C7CBE3E33E00000015000017E2C2150007008B034E204178E185E1E13E2FAC077C7EE1DCE4DDE5E1E13E00005D1768D6895931000E01246292E1EBB35D0000002B1B00456F9654071719000100BEE4E5E50E000000000000000000B1E8E245001792DCEBA8E0DFC5E28000000C909D28B3C9EBEBE2E4E5A83AC57C64E2C2AFE6C200001B00000096C9E5E4E2BAE3BA000545E7E4902062E5E43CE4E5E3E5175D1092E4E3E4E2E3E31010C2E6E5E5E6E6E7E7E5E3544CE4E6E5E4E4E2E666E4E4E5E6E6E6E6E6E5E2E5E4E4E5E5E5E4E6E6E6E3E6E6E5E6E6E6E7E8E5E5E4E5E6E6E5E6E8E1E5E5E8E7E7E77EE371E3000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000410000000001000001E3E4E5E5E6E6E4E4E8E9E8E9E77E00000041E3E7E30503000000000C00C9E3641B241B00000C104E89DE5971125D07120EE26F079DE4E4E4D0B7002B0000000036E1DF891900000005AAE5E90019000000190003E57385730075000033000000E3EB544900000000000000000087E13A000019C7E5E345E0BAE2EB64001500E2E4E0CBE0E5E1E3E2DC0EE05FE2BABE0C38120A0059593E009FDEE5E4E3E2E0E30024C0E4E5E30571C57350E7E4E3410100642F71E3E5E3D29B99CB5DE4E4E3E6E5E35D5B0EE4E5E5E4E1E2E073960E85BEE4E3E3E5E4E4E5E5E3E4E4E4E3E3E3E3E4E5E2E6E5E5E6E3E5E4E5E5E6E3E3E6E6E7E7E5E5E4DFE6E5E5E6E3E3E4B7E5E7E7E7E5E6E6E2E8E8E7E7E900000A00D0DFB7E5E1070000000000A1E2E0E200000005120C0059CDE0CBC989521003DFE1121BA12D94E4E200000005330000008EE3E2450E010000BAE2E4DE2F000000430000E8199B2D3A00000000000000E2E6E55D00000700000500229228E1A6003C00E31B45159FD8E396870003000CE4E3EBEBE8E6E4E568890ECBEAE2E4E3000000000000001B80E2E4E3E4E4E5BE171536E4E5AF100EBE2489E4E4E50E0EC0206496E4E5E6E5A817003CE4E2E4E4E6E399D6E5E6E4E5E6E5E4B766D038285DE4E3E5E4E3E2E4E7E2DEE4E1E4E5E5E5E5E4E4E4E3E6E4E5E4E6E4E5E6E5E7E4E5E4E6E6E7E4E5E5E6E5E6B1E5E2E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000430000000001000001E2E4E4E4E7E7E7E7E8E7E8EAE1B100000000BEE09B2F00000000005B9FBA2B57050000003841000062C5E2E3D07E9D196F891D00000036E2E27500000062000000E1E28BE1B5008E1722C7E3D4BA9F5F003A3E008B7C3671B5000000003C0000A1E8E93300000000AA411B00006AE17A1BE6D6E7003E49A6DBE3E792AA00000024E5E9EBEBE6E4E500001000170EA8E3E4D6360E001233C9E4E3E3E4E3E2E3E320CDE4E2A47810500C20C5E6E3E33A470000E1E6E4E5C73300AA0092E4E3E4E4E47347E2E4E56AE5E4E4E494E5E54C8BBEE3E4E2E3C50050E2E3E2D2E1E2E4E6E3E6E4E2E4E3E4E5E3E6E6E689E7E5E7E6E6E7E7E5E4E3E2E5E5E5E5E2E2E2E3E5E7E7E5E6E6E7E2E9E8E8E8E9E80503E059206AE547012B0000002D3875B54ED033000000000019005BE3E157E0E07EBE0A0015310E00CDE19D000000000003E2E1E2E2E1012600000036E1E03A9B31007A64500E28B168E500000000170000BC0001E900000000000000000096E26A001D9226190112AFD6E5E86F6F3C003305EBE1EBEBE4E3E3E3010000004390DFE3E3E50028C9E6E1E6E4E6E2E4E3E4544C7CE6E4E5E436DB3600E5E6E6E1D685159FE5E6E6E4E2960000008EE5E4E6E3E23E94AFE4E5E5E3E5E4AAC2ACAAE0D4E4E5E3E4E068E4E112DDE2E5E3E2E2E3E6E5E4E4E2E4E4E3E3E5E6E5E4E5E6E4E6E7E7E9E5E5E6E4E6E6E5E7E5E3E3E3000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000450000000001000001E2E5E5E5E5E5E5E5E4E5E5E6E7E5E7E8E03A1524E3E43A68000012100047D8E100075200000000000E8EE1E28BE185E4A8AF4CB55D002F9BA4E119000003001B3373C7E4E319006F000375DCE0C7E1102BC54920000000C0E00000000C000000030096E40000000000000000007EDBE1923EEB3819623371E0E4EBEA1B00126D0000D4EBE8E4E3E1E0101D00052B3817E4E457312F454CE4E5E6E6E2E5E7E6E7E3E2E4DFE4E3E3E0E200E3E3E5E5E5E1E5E5E4E4E6E5E6E4200001E2E5E5E46D1B0000C7E4E5E4E3E3E3E4E3E58971E4E5E5E4E2E152DC6A00D6E4E3E2E2E3E2E3E5E5E2E3E4E3E2E2E2E3E3E6E5E2E6E2E5E5E6E5E5E5E5E2E7E6E5E7E6E6E3E4E6E6E6E7E6E6E6E7E7E7E7E7E8E8E8E77E0C41E2E5E68B00030A05009D71C90A38680041000A0000AA57BCE5E4E3E5E16FE33A0C2BA1E3E0E2E2520005005F009DE3E29D1900000000E4E0E5DEE1AA6F0E050A00003AE8E6DE5B1D0000009D501BE6E9000000004107AA224C24E0E5809B3A410012000003E4EAE82B2F0000001DE3E5E3E5E7E9E5E5E000007C572BE1E29F073617009BE554E4E4E3E4E40C00339FE5E6E5E34347E4E3E4E5E3E6E6AFE3E3E2E7E7E6E70520A6E4E3E5E5A622E32807E2E5E5E6E6E685E4E45438E6E5E6E4E4E1AAE11733E2E3E3E2E48594E5E5E5E4E5E4E5E3E4E4E4E5E7E6E7E8E6E6E8E6E7E6E6E5E4E6E6E6E5E4E2E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000470000000001000001E2E4E5E5E7E7E7E6E8E7E8E7E5E6E7E7E8E7ACE6E4E6E5DE85000000002D50C000CB47002012333C490E002D7EE3C0E5E2E1105F100005E3E1D4DE41000000470000E3D4E1D40007002645E3E2E0E0E2158524DF0005A4E2E5E1360E1B00000071D4E1E94E2B20050E000A0C4C506AE2E2E5D8E74E000000E5E3E450E3E1000A00A89BE3E2E3E380E20043900026E0E3E0755B5252120C00B1D6E1E2B7E43100DB0050E3E6E7D05700AFE5E4E4E3317C20E2E5E5E3E4E69D1919E6E7E3E4E4122817520012E4E4E4E6E559902857E4E5E5E5E475AAE2DE38A4E3E5E5E4E2D896E4E5E4E5E5E4E4E3E4E4E5E4E6E5E6E6E4E5E4E5E7E4E5E6E5E5E4E5E6E4DFE5E4E6E7E7E6E7E6E6E8E7E7E7E7E7E7E7E6E4E1E0E3DFE3E4AF1700000012284592DC663E000E0000001B927AE1E4E4E4E5E1A65B0000002D52E4E46A171000000000E1E3E3800E66244771AFE2E0DDE83E503A220087E0E3E7E3E22B000100243A59C5E775AF9F313E2000000073D4AFE8E8E6DF05000003EAEBE6EBE1C0802F002B523A71E4E2660000E22F00003A6690E3B520001D0000005980E7E5E6A13EBC1771E3E5E55F45339024E5E4DC33264966E3E4E5E5E59D1D57E6E6E7A4E6E1380C7350E2E4E4E5E7E580E0D092E4E5E8E5E6E5E1E4D6E1E6E2E6E4E5E4E4E2E4E6E4E5E3E4E3E3E4E4E5E4E5E5E6E5E7E6E5E6E7E7E8E8E4E7E7E7E7E5D6E6000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000490000000001000001E3E6E5E6E6E7E6E6E7E8E5E7E6E7E7E8E6E4E7E7E3D4E3E3DE45003C000E6A22BEE1B1010A0000870054A8B5CDE5E5E689B7E1360000000A0EBAE3DF750007001B1B05CBE2E2E0457C471D2B1285D8E7D0410031BCE1C9E5EBE4E233000000244C9D5FAF92E0BE0328000000000057E7E7EB3E000C000000CDE9EBEBB5C968107E2F38009DE5E7730028003E001900A4A6E3E3220312E6920000E1E1E2DF57A68E3328E4E4E48771E2E25DD4E6E48B785DE3E5E4E2E3030C1536E3E5E3E4E4AF9FC94783E4E5E6E6CBE0E6B5E3E4E6E5E6E6E5E689D054E2E5E5E5E4E4E4AFE3E6E3E5E6E3E5E4E5E3E5E3E4E6E6E6E6E6E5E4E4E4E7E6E6E8E5E4E5E5E4E5E6E5E7E7E7E7E7E6E7E2E5E7E6E7DBE8E803E5E7E1E1E5E4E3E3E1411B005B719DE1E0D4C91D000000001D174CE3E2E6E5CD5B5700006200001278E1E473830C0510203194D8E25BC9150E00150062E0E2AC83154E78D4E4E5EBEAE5E2E4E03600361B19AFE357890A000C0000000007E5EBE45B0ED00A0A2F26E2E8E6E2E1E1009F52102BDFE1E5C9101700193103E49F85E52836000C5B12001792E1E4E16D337E3C17DBE4E5E6BEE6E16894E2E65F1794E3E5E5E5A10000006AE1E4E5E4E33CBA5FACE2E5E6E6E4A42857BA85E5E5E5E6E6E7AFE58533E1E1E5E5E3E6BAE4D2E5E4E3E4E5E5E4E6E4E4E3E4E6E6E6E7E5E6E4E3E5E6E6E6E6E6E7E7E6E6E6E6000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000004B0000000001000001E1E5E5E5E7E7E7E6E7E1E7E6E6E6E6E6E5E5E4E29FDE49E2E1E3E1E28075B1E2E4E3E43322001200005B0068D8E3E1E2E4E319000000000000D0E2E39BB50C0100280C1252E1D4E28900000019BA96E0E2CB450300D4A6E4E5E6E6E5E0E3E08B9F190C3CC2D06D1B00000000005447E2E8E4D8000000000038E0E4E3D8E2E10C000026C9C0E2E41964000001001700E4E2E5E04100000701000A4154E1E4D06F730180E2E28BE4E3E5E52B2BE3E4E3B7E3E5E6E4E4010031004C52E3E4E4DB00310000E4E4E5E5E5899DE44EE5E6E7E8E5E4640EE3D2E2E4E3E3E4E3E2E1E0E2E2E3E3E4E3E3E3E4E6E6E4E5E5E6E5E6E7E8E6E6E4E4E6E6E6E7E6E5E6E5E5E6E3E7E7E7E8E7E5E6E7E3E7E6E7E7E7E8E557385219A628DBE2836F49A12B789675E1E03A5B12002F73AFA4E1E2E0E2E3E2E16D9400002800001D948EC7E17CA1000000173368E3E4990000850015D0E3E2AF15000C0001E0E4E0E4E5E441B1E3E20728E2E3E1E39D000041000022504CE2E531150C0300003864C9E1E5E55D524E641064DEE6E7E3122D0007E500001DE3E27AE200BE8EAC002BCBE4E6C0E57322B7E5E2E3E5E5E4E3E47300E1E4E4D6E4E4E4E5E45B00000092E2E5E6E6E40ADF3E28E1E7E6E7E2E4E79D6DE3E5E6E5E7E6E7DF5700E5E6E3E4E4E4E3E3E4E3E3E4E4E5E6DCE5E5E3E4E1E6E3E5E5E7E7E5E6E6E6E5E3E6E7E6E8E6E5E3E5E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000004D0000000001000001E2E6E6E6E6E5E7E6CBE6E62BE6E5E7E7E34531192003DFDED8E1BE000000102803AA5038002F00190049B189E3E3E1ACE1E3CD3C00050010001B3EBCDDB7A42F012DD236007AE2E2E03A000000013C73E1C7C222200A006250E1D0E4E3C70C1700B580E3DBD0B5E4D8000000A622C7E073D2E1A843001B28177CE2E1E3E5D6A1174741A694DBD89DE5E20000000A171592B5E1E4E2E13600A6477EE3E54CB57C201BCBE6E5E4E4E4E2E4A6171599E4E3E6E0E5E3E5DE00003AE3E4E3E5E696103A0089E3E4E2E4E0E0E5A457E5E5E5E5E6E49999E3E4E5E4E6E5E5E5E3E3E5E4E3E4E4E3E4E4E3E4E2E1E1E2E4E5E5E6E6E5E5E5E6E4E4E6E4E4E5E4E7E5E6DBE5E6E6E6E7E7E7BAE6E7E6C9E5E7E6E9E5BC004C000071E078DF50000000000A00D2A801000C003A0059629BCBDEBC73DEE3E3E32F2600000000008B45E2E09D0038E3310743DDE0DB6A000A12052443A8E26F5F0000000028E1BCDCE37C0000000000DFE6DFE0E3E0CBDB1924B7DBE5E36DE58515AC1000151B24B7E1E399C06F2620D29DE3E4E3E4D20C570010157AE7C0DCE6E3E3E3DCE2000EE4E2D85007006866E2E3E1E4E5E5C91D3115E0E3E5E5E5E6E5E43C2B542D17E4E5E3E2335F0036B3E2E3E1E6C58968D483E5E5E4E5E6E200CBA1E2E3E3E3E5E3E3BA525DE5E3E4E4E3E5E6E4E5E4E5E3E5E3E4E5E5E4E6E6E6E6E6E4E7E6E5E6E4E4E4E4E4000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000004F0000000001000001E3E5E7E6E7E8E7E7E3E7E5E4E6E4E7E7E3E500172B00385DE2E3411D0000002D43D8DF001038002D0E68E0C9E14C730E416AE2C7E25412000000005DE2E1835B8000000019AADEE2DEAAAA22151700E392E138000000920038E2E4E15D361500470000948BE1E1E1E1DFE1E3C2E0E2E4D87EE4E3AC170000001DC54EC0E4E3DDA133077A7CE2E4E3DD7A0A2B1D5000001BDC64E3E4E4E4E22B0041E147E43845000000AFE4DBE4E3E5E44C001DC9D0E5E3E4E4E5E5D2C7E1D4E4E6E2E4E4E1BA785068E4E3E32D640024E3E3E2E4E5E4E5E4E2E06AE0E2E4E5E4CDE3E2D2E2E2E6E3E4E6E4E0E3E3E3E2E1E4E3E3E3E5E6E6E6E7E3E5E4E6E7E6E4E5E5E5E5E4E5E7E7E7E8E7E4E7E8E8E8E6E652E6E8E8E4001500000022DEAADE0000BA570059A1E4E4265F0000009FE1E3C9782B3615C0E2E3A41D000000A10094E19BBCE3430E000000473AD089CB2F0000000E71E3DD6600000000005778E5E25D120017B7170000005FD4E4642F80E2E5E2E5E3E3E2E4E4E300260000173C03E3E4E6E550494C1B243EE5E2E28B150C00123E010EC752E5E2E5E0EA2B0000D0E57A5B1B002B01BEE4E4E2E0628B5D0038E5E5E2E3E4E5E3E5E5E5E3E4E4E3E4E6E2E3DB807CE5E5E6E5A8BC9F0033E4E4E4E3E24926008B24E3E3E5E4E322C7BEE4E5E6E5E5E5E4E4E1E3E5E4E4E4E2E5E5E6E5E5E5E4E0E8E6E6E7E7E6E5E5E6E5E4E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000510000000001000001E1E4E4E5E5E6E7E7E6E7E7E7E03307E7E8E8E0220000002D90E3E18B00000000003CC96D57190047ACE1DDDC9F41000E004E59E4E42800000000006AD4E1E2DB3A280000000000E380DFD0006F005422DFE27500030000005452D6E554751B000000000000338096893E00E266E1E3E1E0AC66E36200006200000A9BE4E4A4C9BC055726009DE6E5DC52013C000000006FE0E1E2D000787E830000B79BE33C5B891745E3E5E5E4783A0E012D0EAFE3E3E2E3E3E2E6E4C55FE3E4E3E4E3E4E4E1E1E4E5E4E4E35D12DC0143E3E4E4E5E5DD8EE35089E6E6E6E5E3E2B1E4E4E4E5E4E3E3E2E3E2E2D2E1E4E3E4E4E4E6E5E5E5E5E5E5E4E5E5E6E5E5E5E5E3E4E5E5E5E5E6E8E8E7E7E7E8E7E7E63E03E6E8E5E717002205667AB7E3E1000C00AFE1DEE389264C2D716F3675E1787822005D7E36E2E3AA000000000100B5E1E2E4E11B33000000363CE2E3AC5724050A9DE2E359E35F00221D4C68E0E4E18771070000960000229BE199000075786DE2E3A49B2DDBE1260000000000D0E4E6E65D8500001B38857CE3E38E00000105000C31E0E4E5E1200000000A7517E2E29DE0946619E5E0E5E1B38000AC9900E4E3E3E2E3E4E36F5F59C5E5E5E5E4E7E5E6E1E5E6E1E6E4E5D071DD17C5E4E5E5E5E37CE3E5D8D8E5E6E3E5E5E399E2E3E4E4E6E4E6E5E2E3E4E3E5E5E4E3E4E6E4E5E4E5E3E4E6E6E6E4E6E5E6E4E6E4E4E6000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000530000000001000001E5E7E6E6E8E7E8E7E8E8DCE6E8B1BAE6E7E6E72D002F3C1D0CE0E1E47822003C0059E4D29F994522000024E0E1475712121BACDBE2E0B5030000010A6F3AE4E178262D0100031728C073E068005B3A057ED489E3A4190C1200B3E249E6C2311500000000263C0CE05B00006A75E2ACBCE56AD6E2E0CD2B0000010012D2E4E5B3BA0A12000012A8E3E4AA003300C2000020E5E4E28B2D0000006F7A00DDE478AC68203EA8E4E3E1E3C5E33A0500E4CBE1E4E6E5C03A7538A6E6E6E6E6B5003E15E4E8E5E6E4E3E4E2E5E5E4E6E5E4E3C7DEE3E4E5E6E7E8E7E4E3E5E4E4E3E5E3E5E7E4E3E3E2E1E3E3E1E2E2E5E6E6E5E6E4E6E6E6E7E7E7E7E7E6E8E3E4E4E5E5E7E7E7E7E6E7E6E9E7E8E2E7E7C985E8E7E4E207051B1533E6E4E35D1703220E5792E06FA44100002F1B2DE28E2F2F00073E9DE2BCC0B30A00005D243671E1E08EAF030000331B00E1E5DB89E0261226E3E3E3E09462002D2F78D0DEE45B07000005000017B1DFE2071D053EE34C00E0DEE3E5E41519000000003689E5E5360500200000269BE4E5BE941D00100005E3E0E0B100410047310000E28EE6E47305124596E4E5E3E4E3E371472FE5E0E1D4E4E32F000028E287E4E4A60000001DE3E6E6E6E5E6E7E5E6E5E4E7E7E6E2E0E3E0C2E5E3E4E5E6E5E5E3E6E6E4E6E4E4E7E7E3E6E4E3E4E1E3E3E5E4E5E5E6E5E5E5E5E4E5E7E6E6E6E6E7E6E5E5E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000550000000001000001E4E6E5E5E6E6E7E5E7E7E7E7E605003C5BE1E2D0318900000033DEE2D050152B0533AFE3D85D153A2F0C1717C7BE522D410E3E36D6E2E2940000005900033ED6E49496380E310A3E529BE1E1B12424030159E3B39B94170000006ABCE1E4A1900500002B001712A668E27C0043337A1B2F8BE1D6E3E1E0000000001B41B1E3E2430090000017E2C5E5E310680050200A26E3E7E1A4E1000E000000E2E6E5E2C5B33AB71BDEE5E5E2E1529D26031D90E5E5E6E633006D0E9DE4E5E6E60AE10C85E6E4E5E6E68E49D4E5E6E5E6E7E4E4D092E4E5E7E5E4E4E5E3E3E3E4E3E3E4E4E5E6E5E3E6E4E4E5E5E2E3E4E6E6E5E7E5E6E4E6E6E7E5E7E6E6E6E5E6E6E6E6E5E6E6E6E8E6E7E7E7E7E6E6E300001920E2E3E2E1D000000000DFA87A0741360A1B38E3E39B00311B904E07318752220A100A7E94E1E3AF4300002B000712BAE3E12801002B3319A1BA87E0DE50001000C5E3E380A80000B7000094ACE3E0572D502824000100D00790381BD8000000002447E2E1E3E100000000000033E3E2D65000010007AFE3D0E46A0A5441170E00DFE4E5DE240500001200AAE3E4E3E23A41544703E4E3527E0312E50054D2E3E6E6E69D3E3E66E3E4E7E6E700575F015DE4E5E5E445921DA4E2E5E7E4E4E3E4BEE3E4E6E6E5E6E5E4E3E3E3E0E3E5E3E5E6E5E6E3E3E2E2E4E3E5E4E5E4E4E5DFE6E5E4E6E6E6E6E6E7E6E7E6E5E5E6000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000570000000001000001E5E8E7E5E2E7E8E6E8E4E5E57C00000E78C0E5E6E12F000100009BCDA40A017100003CAFE3BA0C070054000036E33A4717000015C7C0E5E12B6200032028009FE1E36F579B010E7822BE80E4CD2015E30007CBE2E2E124000000002B80D6E1A63A190000000000AAA1B3E2E3E0D000E10000001DC55BE336000000247A6285DBDBA40000000057665DE4E4C0D8000500571BBAE5E194012424490EE0C0E3E3E22400000059E1C29417500126DE80E2E3E6E6E6E6DF49E4E5E5E6E5E4E5504C01DEE4E3E45D5F5924E0E3E5E5E3E5E41B9FE5E6E5E6E7E4E5E4E5E4E5E4E4E2E3E5E5E4E4E3E1E2E1E3E5E5E5E4E3E5E4E7E6E6E2E4E6E6E7E6E6E5E5E5E5E6E5E4E7E7E6E7E6E7E4E7E5E6E500E1000000E2E4E3E100000000005BE2C5000064000524E0E3E21045000000241DB147000092000047E0E2A8A4850C1D00009BDBA4E0C5DB9F170115000C43E3E00000000000DFE1C959C90700001DC0A6E2E2D8C7AC00015D0000C9E0E1E0E1000000D0001000D0D8E2E1E3E4E2002D78B7E2E3E490151900053AA6E2E49478261505008B0185E6EA66D633336F4700CDE5E5E7E38320001BE2E2AF6F5073D287DDE3E0E1E2E53C547CDEE3E6E7E7E8E6D2A47CE3E4E4E56D201000A8E5E5E3E6E4CD68E03EE2E4E8E6E5E5E5E2E4E4E4E5E1E5E4E4E3E3E4E3E5E2E4E4E5E4E5E4E4E4E5E5E4E3E5E5E6E5E6E6E7E6E6E5E6E3000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000590000000001000001E1E5E4E1E7E6E6E6E7E7E7E7E3050010B5C783E5BC960003000A0052E14C003C00A60024D2E1DBA4C700002007475F00000000006FBC75E2E1DF26331700491BA4E1DEE000660000000071E1E03E000000334CDFB3C9801D00001D3600DD68E11B33000000003EE0E1C9E2E0D405003800000022C9E0E0E3E3E283192B50DFE2E2B11D710043005D73E3B12B000700E20003DDE7EBC257734C5062629BE2E4DF3E717A5B7CDCE2E3503E87E405E4E2E2DDE1DD33D257E5E5E3E4E3E4E4E5B57AE4E4E4E6A4311900E1E5E5E2E16AAFE3E043DDE3E4E5E4E3E2E3E5E5E3E5E4E3E3E5E5E4E5E4E3E4E3E4E5E5E4E5E5E4E5E5E5E4E3E4E5E5E5E6E5E5E6E6E7E6E4E6E8E7E7E8E8E8E7E6E6E3E7E2E76A125B4EE5B57A0000005B006FD09038000503002BE0E39D94A42B07011D75DDC9282F12002BD2E0E2DB1BB3620000001D002FE2C5AA380000410A01E1E3E03C00000117E0E3E1E1A600330C365DCDE2E1E0A105000000036ABADDC2E0E15B0031012B009673E3E1E3DEE1BC004E3EDDE2E0BC0000000300BC50AAE30A173E3CE56603E1E2E9EADCE5E2DDDCE3D8E4AF3807CB000028D4E1C007DE9D8B96E6E4E5E5E6E894AF5FE3E4E1E2E4E4E06AE5E4E5E5E5E6DBD6DB00E6E4E5E468A8E3E4E3E3E4E6E5E4E3E3E4E3E2E2E6E5E6E6E4E5E2E5E3E4E6E3E3E2E3E3E6E5E6E7E6E5E5E5E5E6E4E6E7E7E7E7E6E3E5E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000005B0000000001000001E3E5E4E5E6E6E5E6E6E7E5E5E8AF9F000000C9E4E5E3150000050000D8CD4E4E96123EDDE3E37131000000000075E1C07838AC0005B5B7E4E3C70E0000000000006DE0E3E3B52D00000C24E1E0D2E22B2D19129DE3BCE0E00C1B0038C5D8E1E1E15B1D0000000A1D4ECBE0E0D800002F00001959E2D0339D00003ED400009FE2E2E12F96000000200062E39D220000E4BA0047E2E6E87524A4E2E0E2DBE3D6E1E3E3E2E3E4E6E4E2E059C250383EBAE1E3E436383CCD52E2E3E4E3E4437383E3E3E5E3C0A4E3496AE4E5E5E4E7E4E5E3E2DDE5E3E3E3E3E1E2E3E2E3E4E3E4E5E4E4E2E3E2E3E4E1E6E3E4E4E4E5E5E5E5E6E4E5E6E3E4E5E4E4E6E6E4E5E4E5E5E6E7E7E7E7E6E7E7E5E5E5E9E7AC0E8E000CE0E190E25D00000000A8874C38105B31E0D0E152070E03000A008EE0E2924141100050B5E1E1E1AC07005000244141E2E5E2D62B032417073CE8DFE19600282633E1E2B3005003030A28283AE0E26D2F00000000014171E6E3A6000000000038A6737EDD280C0000E1B59B85E2E2E3E11D00001D018075E3DF3805016D0003D4E3C7D23E0C0E2249DFE0E4E6E5E4E4E4E3E5E6E6E400E0E31924E0E4E2E5B30E1700AFB5E4E5E6E519193333E1E6E6E5E13126A868E4E4E4E4E2E5E5C954E1E2E3E6E5E5E0E4E3E4E6E6E5E5E7E6E5E4E4E1E4E5E4E5E5E3E4E6E6E6E6E7E7E7E7E9E6E3E7E8E6E9E7E6E6E6E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000005D0000000001000001E4E685E5E7E7E7E7E8E7E7E6E9E5E53C43010A22B5E4D2780085000087E4000A01E2E0E2B3641B0054050500005233E4E36A361900008EE4E4E4D08B101B003A07A6C9C5E4891736005F2283E1E33A0000000199DBE29BB7A6050000001B0080C9DED65F0007000E2490E3E2E0DDC003000107385DE3E39F00011210E2DCE1E1E3E4E5000068800028D0E6E4DE011200730075DFE2AC0C1D0015284CE0E4E5AAE1E3E6E4E4E5E4E5E2E3001983D8E4E5E43354D62226E6E5E5E4BE00003610E4E5E5E5E4DE9F009BE6E7E0E4E59DE6E5E3E3E4E4E6E6E5E7E3E3E3E4E6E5E4E5E5E5E6E6E4E4E5E4E6E4E4E3E5E4E4E5E7E6E6E6E5E5E4E5E6E5E7E7E6E5E6E2E5E5A4E5E7E7E7E1E6E7E7E7E6E9E8310020030E17E2E3DB0500000001D200003164D6E0E0646D00000A05002B59DEE48E7A6600000017A1DCE1E252202233000052AABEE5E30E000054053A64E4DB00640000E3DDE3E1E49F17000E000CAFC0C7C21200000020DB00E37CE2E1E2A8903600003A24ACB1360000000092E2E3E1E1E4E4E30000000001C7E2E4DE26C533E1D44331C7DCA4C910A10045BEE3DC503A7EE3E4C7E3E4E5E6E5E12243E2E4E2E2E1C5000010E5E5E5E3A10A80412FE4E5E5E5629BE2A810E6E4E5E2AA6F00E1E4E3E5E5E6E5E4E4E4E2E6E4E5E4E5E5E5E5E4E4E6E7E6E5E5E6E5E3E7E5E5E7E7E5E5E5E5E6E5E5E5E5E7E7E5E2E6E7000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000005F0000000001000001E483E594E7E4E6E7E6E4E6E6E9E9E9E600203E0066E2E3E2C707000000E220265DC5E0E18389E0A605002010458BE3E3E2E1750000287C5FBECB80CD73E05D0A001B2F03D8E3625B00000000BED89B00000000D8CBE4C7968B2F000000000036D2805400001B000000BADC68B380CDDFC20000000589C7240043000000C771E3E3E2E2E3BC241000005950E3E1B3DFE1E3E41D3ECDDEC72B360000BCE3D012072D52CDBAE2E0E3E5E3E5453CB5ACE3E3E0680CE52819E3E4E3E3262400B7E0E5E4E1E3E30A12002DE6E4E3E27EA4E447E4E3E3E4E7E4E5E4E6E3E5E4E4E4E4E4E6E5E3E6E5E4E3E4E2E4E3E4E4E3E6E4E5E6E4E5E4E7E7E5E6E5E5E7E5E6E4E6E6E7C7E7E7E7E7E6E8E8E8E6E6E4E6E17319152D1DE1E396AA5F00336DA120330045E1CBC77EE4DD75000A00006FAFE4E3DB170A0000196F68DCC5E2A4BE52010019016475C9734E0E07000000E2852F0C001D1B20E1E3C0DE960007000C3ABAE0E1A41B032B2FDB31E10033A1E354E3710005000000E0CD00010C0000009971E5E5E6E5E5D80E001787E1E3E37CE1E3E1E09BC95FE3E183545920E2E2960059A6A82D71E4E4E5E3E5E3E26843D4E3E2B38BE0B14E78E6E6E4E5572283BA57E5E8E5E4907CC987E3E5E6E3E2E5B3E5E1E4E6E4E4E5E4E5E3E5E4E5E4E4E4E3E3E5E4E4E5E3E3E3E3E4E6E6E6E4E6E5E6E7E6E5E4E6E7E7E7E4E5E6E7E6E5E5E4000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000610000000001000001E6E6E6E6E6E1E3E5E6E7E6E6E7E5E5E4E4D60000010000C9E2E1E268DDE12D001DBE2403624CE3E1E2A63C7A208390DCE2D88000781D0036DEDCE1C0E1E1C0AF280000000000E09F1200000012CDE600004E0100D2C0E0C9A49F0000000000010000DC7A8E263AC9E194B3DFBCDC0000E10000E2000000CBAA0E01000322193EDFE2DE87000000E2007CE3DDE2DCE2E3E2E19D7A8750DBDEE3E2E2C7C75B000E000038E3E2E3E1E5E7E5E5E4E1E2CBE3E6D6411B855289E4E3E3E5416AD2E4E4E3E4E2E3E2A6E5E5E4E0A1D4E4E3E4E4E4E4E5E2E4E3E6E6E5E5E5E4E3E3E4E4E4E6E3E4E3E4E3E4E4E4E5E4E4E5E4E3E8E6E6E7E6E5E6E7E4E5E7E5E5E5E5E5E6E8E8E8E5E5E7E6E8E8E8E8E3E5E4E2E1E1000000001719BAE0E0E2E2D65D5054903C280000E2DFE1B36F2424240E24E0DBD62B00000087493CDEBCD8E49092000000A4002696E0DC0A0000009BE9E1B5000000ACA1E3B7E201000000000000004EBAE0BEE3E1DF99A4CB6800000005174E000000000087E23E590A00000A00A8BEBCB73A0E000000385FE1E4D0E5E4E43C005915AC6AC2E1E4E4E2E30515360071E3D2E2CBE8E4E3E3DEE3E3E2E4E4E6E038E49000E4E3DBE4E500009BE4E5E3E6E1E2AFC0E6E6E5E5E5E3E487E4E6E6E5E6E5E5E4B1E5E5E3E3E2E5E4E4E5E4E5E5E4E2E5E1E4E4E4E3E4E5E5E5E6E5E6E6E4E5E7E7E7E5E5E6E7E5E4E6E4000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000630000000001000001E3E4E5E4E7E8E7E7E8E7E6E5E6E6E4E6E400000000000049A694E17392E23A45B7470A1D714EE2E0E09F570E0010003AD8E39F0E000C0C9B90D6E1C26DE3E073000000000092E2E2D2D05B0010DFE7E72F000000002F62E0C54E00000043000000150AE00052BAE1DEBEB53A4C0000008764000000000110A805000000000000DDD2E18B9F4E2D00498EDBE1E4DBE3E5E3E34C15416DCDE338E2E17C6A6433665B80E4E1E3E6E4E4E4C2E1E4E4E5E4E9E4E2E09F8092E0E3E5E56607A110AFE1E2E6BCA8E2A4E0E3E6E7E8E5E2E2E0E3E5E4E5E4E3E3E0E2E2E2E2E2E2E2E1E0E5E6E5E5E6E6E4E4E3E5E5E5E5E5E4E5E5E5E5E4E5E3E5E5E5E5E4E5E6E4E6E5E5E7E6E7E9E7E7E7E6E7E4E522E2E5E4E2D6280C000010001538E3A6CDE3E2E0E4D010260E1B26BEE3D06D0789C700015BDEE3C5280E241B43DEE1030E7EE2835015243E284350E1E0E0E5E2E1E6E6E52000000000C201E0E3E2A10000000300000075E2C778E4E3E3E2E2A6645F000000002D6D00150024E1E205005900003C59E5E4C728001900E1E3E3DFE0E5E4E1B57A0E0012B7E3E4E3E5DED2E2E4CB6DB5DFE1E1E4E8E5E88545DDE3E5E5E2E3E6E6E6E500E0E3E4E5E454AFB515E1E0E7E6E5E4C7E4E5E7E4E5E4E2E4E5E3E6E3E5E5E5E3E2E2E4E5E4E5E2E4E1E3E3E4E5E6E5E5E5E6E6E4E7E6E6E5E4E5E4E5E6E6E6E6E6E4E8E6E6E5E4E6E4E4E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000650000000001000001E4E5E5E4E7E7E7E8E6E6E5E6E05FE2E9E1E4D850000000000012E1E15496E1E2E3E324010000004EE2D0000000330005A1B3E1C966380AA48B5DE1544C20E1E39B0C71003E2D0A90E1AFDFDEA875E5E2AA00000000206DE1BED2E1C0000000000712005B57DFE4E5E2E341A6DC000000009FDF380E000075E1E200000000011000E0E159D06F9D3143E4E5E5E3E4E2E29BE1E1576ABCC5D6E3E2E3B3CBB1227C7ED4E512E3E5E3E5A46F000089E4E4E3E3E1E2E4E4E3E5E1E4E4C543190EC9E4E5E4E5DBE1E1E1E3E6E5E26AE1E2E0E3E4E0E6E5E3E4E2E5E1E5E4E4E4E2E2E4E2E4E5E4E4E4E4E6E4E6E4E5E3E4E3E3E4E4E5E5E6E6E4E4E3E5E6E6E3E4E3E6E6E7E7E7E8E6E5E7E9E6E8E9E6E4E6E3E3E100DB1907E00A0036C0C9C9C9E4E3E2201B0000005DE1E3E23C00000500123AE2E3E2451B0020A6E1E0590000B3E2E10015006A201D2D6A3E2FE2E2E2E0D0A4000003103366E3E2CD269400000A120000498BACE1E2E2E2E396001B00000015D0D60E000A00B7D8E32F030700000031E3E2CBE5C91D4C73E3E3E4E7E6E4E2E3CB5250891DE0BAE1E4E3E443C06880E4E4AAD2EAE4E6E5E5D8050000DFE3E4E4E4E5E5E7E7E6E5E6E58E8747C0B1E4E6E6E5E1D057E1E4E6E6E6DBE4E1E4E3E4E5E5E5E4E1E3E4E5E6E5E6E5E3E4E2E2E5E4E6E4E5E6E5E6E7E7E6E5E4E6E5E5E5E6E5E0E5E5E5E6E6E8E6E3E3E3E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000670000000001000001E7E7E7E7E7E6E6E6E7E7E6E7E32BE4E6E4E2E03A00008700007CE0E2B3E1E3DCE2E141000000332BE3E3964E001B201252B3E1DF38240E332BE1BC5B001000DDE5C9A12D0C245B4E004CE2E19FE2E2D29B00001B005B5B71E2E18EA45B00000A5200000047E3E4E2E2E3E08B2803000020E3E2DE283A3C17DFE1AF2D00000000001DE3E0E27E31314326E4E3E5E0E0E4E4AA593C87876D31A8E3E8E3E3E3E296E1E5D4E0E6E2E3E4E11D262241E5EBE2E4E2E4E7E4E5E5E4E3E3E1A18BB3E2E4D6E0E07A49A4E4E7E6E6E5E3E3E1E6E4E3E4E6E6E6E0E1E3E2E6E6E5E3E2E3E4E6E5E6E3E3DCE5E4E4E5E5E4E5E7E5E5E3E5E5E5E6E5E6E7E6E7E8E7E6E4E5E5E7E8E6E7E6E2E6E0E8E7E9E7E4E1BAD0E6E2E4AC1D0100000033AC5BE2E3E2E1E2AA26000083005B96E2AAA612681B0E0312E4E4800AB30028E3521900000000E1E2504E000A00000000A1E17AE2E5DB41000000363C47AF68E30AAF0E00000749004C0019B3E2E2E5E3E16600681B0300E1E4E32F871B01BAE1E262002D500010A6E0E0E24500000005C2E4E4E4E2E3E2E2E20000387C2271D8E09B7AE28EDFDEE1E2E3E3E3E0E224A150DE1BE2E6E2E4E3E4E7E6E6E5E3E5E7E48BDBE2E2E2E5CB68E6E226E3E5E5E4E0CDE5E0E5E4E2E5E4E5E6E2E4E3E6E4E5E6E4E4E5E5E4E5E5E5E3E2E2E2E3E4E4E4E5E5E5E3E5E6E5E4E7E6E5E6E5E5E5E7E4E5E4E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000690000000001000001E5E6E5E6E6E6E5E7E6E5E6E5E645471080E4E1E4E1333E000020003ADCC7E3D68BE32800000A0078E3E2D0E09B43002B002DC2E3E107000001E42D0050800000A6E4E1434E000062000022929DDDE2C900570000000E662B49C2E0A66D3C0087000000151DE1E2E3E5E2E17C003C100C207CA4A48B3C38246FE2E40100000000007EDEE29603007100009DE3E1D8E2E3E3E3AF00A110E3D8CDD66645E02F28E3E3B1E3E3E4E2E38907B1E1B766E0E1E0E1C507E2E4E5E4E4E3E4E5E4E5C2E1E0E1E420AFE200DEE4E3E6E0E290E4E4E5E2E4E4E5E2E4E3E3E5E5E3E4E3E2E3E2E6E5E5E5E4E1E2E3E2E5E5E6E4E0E2E3E3E5E3E5E5E4E3E4E2E4E5E5E4E5E5E5E6E6E6E7E8E6E7E4E8E8E2E8E2263E28B1E2E6E4DC5D003617BC6252E0E1E062E2757C1D541962CBE3DCE4E2E4E16A050062B3E1E3B34C506FE219030000001203E2E3E2526400000000037AE0E4E2E02B38000000105D00B3D0E1CB66B10700003C20001B78E3E596E4E138152812173ADEE0DDE0C28BE2E4EBE69B000000000047E3E2E20000000000E1220CA4E4E3E5E5E441001549D280E0A4E0C7C059DCE26690E3E6E5E3E23A64E5E15DE4E4E4E29D5BC9E4E7E3E5E2E4E5E5E5E4E2E3E3E56ADB5B5DE4E3E4E13CE3E3E6E3E4E3E2E4E4E6E6E5E6E4E4E5E2E3E4E2E4E2E3E6E6E5E0E3E5E5E6E5E6E6E1E5E5E5E6E6E7E6E5E6E5E6E5E6E7E6E4E5E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000006B0000000001000001E7E7E8E7E7E7E3E8E4E7E6E7E58B331033ACD2E2E4E1A6D8002F0CE2E336D0E19BE3E25F0C07283E10E0DEE2E2E2C000000017E1E5D6751566E09B3C000500000ECDE1D2E028170E007E5BDDE1D6DFE08524056A000000B7D071DEE1261038000000001700E0E3E3E4E47E621700000089E1E3E375623C664CE4EBBC00002D00000089E5E2CB2F0017C9470078E0E5E4E6E6E6E50A1724319BE4E3CBAC9401E2E200AFE3E6E6EAEBBC00002D45E5E5E6E4C2C233D4E5E8E5E2E4E5E4E4E5E6E5E2E5E4E1D8AFE3E3E5E5E699E5E4E4E3E6E6E7E5E6E4E4E5E5E6E6E4E6E4E3E4E3E5E6E6E3E3E5E4E5E6E5E5E7E1E4E4E6E5E6E5E8E4E6E6E6E6E5E7E6E4E6DCE6E7E7E6E6E2E6E3E6E6E8E7E8E600000017C7E0E2E3E21500D000D626E2E2E2E1B3E2660001000105A6C5E31DC01900000000009BE1E0A4E3E1B550003E00100059E0E0E2DD62281B0C032BE3E5E2E2E2B700000000319F00961BE07AE0DE0000001B2600C5E2E0E3B51245000000000AAFE2E0BE0A00153187EBE017001533004C0ADCE5CBDFBAE6E1C07A66E5E3E2E1AFDBE7E3E02D59E0E5E4E389E1E1E0E36231E5E4E3E0B100732B1BE8E4E5E4E2C7000731E5E5E5E3E5E5E5E1E2E3E3E7E6E8E5C7B3E2E4E5E2E6E5E5E1E3E6E4E5E5E4E5E5E2E2E0E5E4E4E4E4DDE3E3E2E5E6E5E2E4E4E5E5E6E6E8E6E6E6E6E8E7E7E7E6E5E5E6E8E7E7E2E4E2E3000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000006D0000000001000001E4E4E4E5E7E6E6E6E7E7E6E5E7E67500000000E2E1E3E1280019DFDE000094C96A877E3C2417077CE1E262E16FC01700E138000100E1E2E0E3E2B7D25F1973001D0EC5E11DCDCB710026004EE2E2E3E0E3A8310000172F00001D50C28E0010000000E3E100B1E3E038AAB5592F0000330043D6DFD466A43E1BE1E9E2E4000000000010BED8E2E071DCE4B1C7E6C2E4DFE2783EAFE4E338226FAAE25B80E3E8E2030E54DBE4E4E9E017382000E8E3E3E4E6B1497A92E4E6E5E5E4E5E1E4E4E5E5E2E3E2E4E4E3D2E3E4E4E4E3E7E6E5E4E3E3E4E2E4E4E1E4E4E4E3E4E4E3E1E3E4E4E5E5E5E2E1E4E4E3E5E5E3E2E4E3E3E5E5E3E8E6E6E7E4E4E5E4E5E4E4E49FE8E8E7E6E6E5E2E7E7E7E6E4E6E500800052AF12E19BC003202800000085E08368B70000000022A8E254E2E4DF4C00000000001BE0E18BE5DFD610000003642466DCE3878E0000000000013AE1E2E1E06A71413805C9C70050CDA4E2BA52BE310A01000085E4E10031E2AFC764000E7E2BDBDBB587C96422E0EAE38B17003C002080DCD2DDE4E7E9E2E26DB568E4E2E3AA3A33E4E8E2837EAAE4DFE4E9E6AF173E54DEDFE6DEB303C5594ED0E4E5E4DDB1D2E317E6E5E6E6E5E4E4E4E5E5E5E4E4E5E5E6E6E0E1E6E5E5E6E4E5E5E3E6E4E4E4E5E5E4E4E4E4E3E7E5E5E3E1E3E4E3E6E2E2E1E3E3E5E6E5E6E2E4E5E4E5E6E7E8E5E6E4E6E6E6E8E4E4E4E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000006F0000000001000001E6E6E6E5E7E7E6E7E9E8E7E7E8E5E7200000005BC2E380E1852D9B0043593371E4E5E14100994100003A6A71E3E16A156400010003A6E3A1E3E3C5C503032B12001DDDDBE5E2BE410000000017C9E0E3E2E2B7CD261D28075BDEBEE2E2E0E06D2800000010E4E5E22043E1E2E224000000C0DDE3DE687A590068E3EBE4C2C510000103A6C7E14726E9E5E1949BE1E2E2E5E3E3E447B1666D52A8E290E7E5E4E47110035489E2E1C026B5BA1DE2E3E39DC9C9AC4E10E3E7E5E2E664AFE4E3E3E4E5E3E5E5E5E5E5E6E4E4E5E6E7E6E6E5E4E3E4E2E5E6E4E4E2E4E5E2E2E3DDE2E5E5E6E6E4C2E4E4E5E5E6E6E1E4E4E7E6E4E4E5E6E5E4E4E6E5E6E7E8E6E6E7E5E6E5E5E7E8E7E8E8E7E8E6E6E5E8E6E507001B2FB383E3A6B7E152000A1D836DE1D03800280E0020314CE4E0E2E0E15D240C0015D6E457E1E3E4E1C7540300001B73E2D850E3DD3A20000012E2DCE1E2E392A8313A00121B224CE1E3E20C3A0000000000BEE200008700E14E628926038EE3E5E38B002D223CE37ADBEB908E2800DFE2EBEBBA45E1CBC0000E5DBEAAE29FB30A0ACB00E4DEE2E4E487E4E3E100008EE6E6E4E5E4E46DB39DD2E4E4E4D6102478A48EE5E7E4E496E4E0E1E3E3E5E2E6E3E6E6E4E7E5E4E5E6E5E6E4E5E6E7E7E7E6E4E2E4E2E5E4E6E4E387E3E5E3E6E6E7E1CDE6E5E5E6E6E6E5E5E6E3E5E6E6E6E5E4E3E5E3E5E1E5E3E4E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000710000000001000001E6E7E5E5E5E6E7DDE6E6E5E5E6E6E6E6E3DD0052002F5BE1E1E4E3A42610207E80ACE2832600000A89A8227CE4E1D8D2520E003E000AE08EE3E3E1C25F120078000062E3D8E192893E001528265FA8A68EE0C7AFDE05000503479F10E0E192A6002200009BE310010087C5DB92330C00001BE3E5E2AC0C3C432BE2E2EAE871280000E2E4E9EBEBE3E4E3E21985C7E0E4E4C2661B0EE4DE4EE4E4E2E3E4E4E27C001931C5E6E4E4E2E57AD22883E3E7E5A83E49E36DE6E7E7E3E55DE3E5E4E5E6E5E4E4E3E5E2E6E8E5E6E459E6E5E4E2E4E5E6E5E5E6E4E3E5E5E5E5E3E4E4E2E7E5E6E6E4E2E0E2E6E5E8E7E6E2E5E7E3E5E5E6E6E69FE6E6E6E7E6E6ACE0E5E7E7E7E7B5E6E9E7E7E7E6E7E6E7E1E6E2E01503102DE0E0E2E3E4E0001919717333E5A61B36412B001D3807E2E4E4E33C121B1900286DE3E2D2E3E34500000CD6004CAFE5E2AFA6E1682401001264D6DFA8E0450017017C151D87E1E5E5E0AFDE0E002BACE324000000E0E3E26A26190071E0E3E3E2E01D0C4CB3E5E6A1660000000549E6EAE4E4E1E2621D5045D4E5E0C26D056401017EE3E3E3E5E6E5BE1B000500B549E5E7C7CB2DE4121DE1E3E4D8E5E5E4E3E3E4E7E5E6E5E2E4E1E4E3E6E6E4E5DDE2E5E5E4E5E4E5E6E4E6E4E3E6E4E6E5E7E5E5E3E5E5E4E4E4E2E0E4E5E7E4E6E5DCE0E3E7E7E6E5E6E4E4E4E4E7E7E7E6E4E6E7E8E7E8E4E5E5E4000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000730000000001000001E5E5E6E6E7E6E6E7E5E4E5E5E7E7E7CB94E326000059A1E2E2E1E2E20A000C002638E2DB382B265000120ADF87E3D2E0E22F000000002DE180BEE18E6449000100070319E3E0E03AE08B2400000A0049E0E0E3E18B80030000008BCB0CE4E2B30C20A1007AE100001701808BE4D41D15000096E3E4E2DD4E2466C9C0EBE4A40000000000DDE3E2E5E1190100001BE0E0E2D6AF223A07CDE4E3E5E2E3E3E5E2D8524C5B33E5E2E2D271714900AAE4E4E1E4E520E20047E3E4E2E4E3C5E3E3E3E5E5E2E4E3E6E0E4E7E5E4E5E6E6E4E3E4E3E4E5E5E5E4E3E2E4E6E5E5E3E4E2E1E5E7E5E5E2E5E3E3E5E4E3E4E4E4E4E3E3E5E5E4E6E6E4E6E3E5E6E6E6E4E6E7E7E7E7E7E6E5E6E7E7E7E8E6E6E2E8E6E464005022B5A1E2E0E3C03C00000005263852E3A8E17E2200002226923896E3E4620000E2000531C949E5D4D2D010002B2400007EE2C5D2C9176200000100335DE0E4E3E3E16F220000008722D0E3E045284178E350001068227AE5E28B24000031387AE9EBE33A28016D85E9E12D00E517016D9BE8E9EB501B43C90033E4E1E3E1E15B1971E2E3E4E3E4E2E6E6E6E5A194AC54E3E4E4E4D8B785E6E3E4E4E6E6E5E3D2E2A4E7E9E6E5E3DEDFD4E5E6E5E56FE4E3E6E8E6E7E5E4E6E5E5E8E7E4E6E4E6E5E2E2E3E4E5E7E6E4E5E1E4E5E7E6E7E5E5E4E5E5E4E6E6E6E6E3E6E6E6E8E7E7E6E5E5E5E5E6E6E5E5CBDF000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000750000000001000001E7E7E7E7E6E7E6E6E8E7E7E7E7E7E7E6E4645BE24101D2E2E4E2E4000000000000156DE2E4453C1710000C0E3C28E3E4BEE252000000364CAC17B7E25FC924121B2D0343E0E3E5C0A4543824002400003638E2E2E15B3C0000000000002BD6E3E19626BCB1E2000C1B1D5BE2E1E1C70003000033E6E6E0001B100019D0E3312F150A92459BE5E9B75B0E00000038E0E3E5E6E5B73CD2D4DFE4E3E3E3E6A1E3E3C72887E2E4E5E4E3E0E1E0E4E5E5E5E3E2E2E5E5E07EE4E5E5E4E5E3E1E1E4E3E7E6E5E5E2E4E6E6E7E7E4E8E6E3E5E7E4E5E5E6E6E1E1E4E3E2E3E4E5E4E2E4E4E5E4E6E4E4E6E6E4E6E7E8E4E4E4E3E5E5E6E6E5E5E5E5E7E5E7E7E5E6E5E7E7E7E6E7E7E7E2E7E6E6E7E6E9E7E8E9E4E400380145E3E5DFE1E164000000000054E0E3B3E380450024004E0592E2C99FDDA6001D100045B3E271E3E4E2E18500000E3E28DFE4E15D9F2B3300000E9F5033E3D2E3E12F00030000006AE2E2E2E53E0589E4288BE300003696E4E3BE5700000000E0DDE2570015000028E09417E2D8B3D2E1E6E6E0AF7826000015DDD2E4E349C9BAE5155BE3E3E4E3E5E0E0E8E4E37EE4E5E6E2E3E1A6CBE2E6E6E5E4E5E6E5E5E4E4E4E7E5E236E5E2E3E3E4E4E4E5E5E6E7E6E7E5E4E5E6E4E4E5E5E3E5E4E6E6E6E5E3E4E4E6E6E5E4E3E5E2E6E5E7E5E5E6E7E6E5E7E5E5E6E5E5E4E5E4E6E6E5E5E5E4E4E5E5E3E4E4E4000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000770000000001000001E5E6E5E6E6E7E6E4E7E7E7E6E8E4E4E7E78E073100E1DFE3E0E2E32D15000C0000002BA8E3BE8038010E20280003E2E2E2E3D426000000001D8BBEE2D0E1837C001B004E0036D4E4E299683E0A364141AADCE3E2E1E12B00000C0000005BD6D2E1E289BE5D0E1000000036B7E0A46600002F000089E4E30E0100000196DFE275505450E2DEE4E4E0AC315B00455FE6E1E0E25764E2CB03C9E4E2E4E4E6E0E1E4E5E6E3E7E6E7DDE2E3C783CDE5E5E3E4E59FE3E4E0E3E5E6E6E6D0E1E2E4E3E4E6E7E5E6E6E6E6E4E4E4E5E6E5E5E4E4E2E4E4E4E3E1E1E4E4E4E5E6E3E0E3E3E2E4E5E4E4E4E4E0E4E6E3E4E5E5E2E1E4E6E6E7E5C9E5E6E6E7E7E7E5E5E4E5E6E7E7E7E6E6E6E7E8E7E7E8E5C5DDE6E4E4592426C0E2E1E5D0D0A8BE2600070E2F4E9DD4C2733C493600280A75E5E3E2E1D22D0700031B2B5B599DE0CBA873000000000047E0E4E3E3E25705DE00753A5066E3E4E385750045001D17127359DEBEE3E3E42F4500003E0054D8E545220000190000E4E0E42D28000001E1E6D63A662B22BAE3E3E0922015000CE1E3E2E5E3E6E4D4007CC741D2E1E4E5E0E2E3E4E3E6E3E4E4E4E4D064D0E0E4E6E3E4E5E5E6E2E3E4E5E6E5E4E5E1E5E4E5DEE7E7E5E4E2E4E5E5E5E3E5E8E6E5E5E6E6E6E7E6E4E1E2E4E5E5E4E4E49DE4E3E5E5E5E5E5E5E6E5E5E6E5E5E6E6DBE3E3E5E5E5E7E5E5E4E6E8E8E7E4E3E5E6000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000790000000001000001E4E5E5E5E8E8E6E7E8E7E7E7001780E1E2E1AF100EE32DDFE1E3E2E2C79B68001541806AE06AE1002600150000055FA6E2E1DE33200A242DD62F99DFE3E3E0A143005D00002D80DFE1BE2D0C050A001D003AE2D4E1DE9F965D929D1B0043280054E4E2E2E4E23300000E00E0E2E3A49D0000170A89E4E4E13A5B28005285D6E3A1E2E6E0E4E1E1E1E2330A221983E3B5E6E5E4E1E1B1CD2D28A8E2E35FDFD400E38BE4E5E5E6E6E4E2BEE55BE6E4E0E2E4E4E3E3E2E3E2E4E6E5E5E4E2E3E5E7E5E5E5E2E3E6E7E7E5E4E5E5E1E6E5E7E3E4E4E3E6E5E3E3E3E5E6E5E4E2E4E3E5E5E4E6E5E4E6E4E5E5E5E5E6E6E5E6E5E4E5E6E5E6E5E5E5E5E5E6E4E3E5E1E7E7E7E6E7E7E6E6E8E7E7E7000726E0E3E4E371E2E31D0000E0E1E0E1E17A1B000141503183DD006F0E541200430EA64CDEE1CB01200012000E2FC7E1E3E4DD6F00000003B52DAFE3E10A001200780000AAE08EE273E1E02D6F1715002B3126C2E2E4E3E3E1752000010054E0E2DD3E22000000B5E4E6DF6A6D9403260094E3E5E5CBE2E3E3E5E3E23A002F0064E2E4E3E4E4E10000330094E59BE2E4E0362B0000E0E5E5E4E3E5E3E3E536E2E5CBE5E3E6E45BE2E4E5E7E7E2E3E7E4E4E6E5E7E6E6E3E3E4E6E5E7E5E6E5E3E6E8E4E4E3E6E4E6E5E5E4E3E3E5E3E2E2BCE1E6E6E5E6E5E5E6E5E6E6E7E8E5E6E3E4E3E3E6E5E7E7E6E6E7E6E5E7E6E5E785000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000007B0000000001000001E6E7E7E7E7E7E8E7E8E8E8E80038990000E3B59DE36607E30115E0A4E5E2A417001B1D22D0D2E4E46F000001000C00196FE4E683942F10071B19003347E29BE2570E00003E1268B7E3E2C0E2800000240083A8BAC2E389C0332200B5031B0000CBE4E4E4E4ACA1260000283EA6E4E3E34500100A1DE2E1D0B7850045286DE1E3E1DDE3D0E5E2E3E300006800267CE2E5E8E6E1E40000850068E4E2E4DBE2680AE200E3E4E5E2E6E5E412E5A6E5E1E1E5E3E5E3E40EE3E5E7E5E3D8E4E3E4E5E5E8E6E8E2E2E5E4E5E6E5E6E4E6E6E5E6E6E5E6E6E4E5E5E2E4E4E5E3E5E5E1E5E6E6E6E6E5E5E6E7E1E3E5E4E7E7E5E6E5E5E6E5E6E6E6E5E3E5E7E6E5D2E4E4E7E8E8E8E8CBE7E8E8E8E8E700001B000000E4E56DB10012000CA6AA47DCB39B0A0000153A83B3E7520A0E003A0E102B3A75E4E3E0430000BE0C0045E1E2DEC0AC0E000300384EE1E5DBBE83150003001DAC5DB7E2E4A4BA9090380000260000E3E0E2E2E13A00000024000099D6A64C03200019008E47E1E2872B0000005D43E1D0E3E4E6E4E6E48000001219D8E3E4E3E4DF5400002B0000E1E4E4E3E4E000002654E3E0E4E5E4E4E5E7E4E7E6E3E6E4E4E2E7E5D0E6DDE4E2E4E6E6E5E7E7E6E0E4E6E3E7E4E6E4E5E4E3E7E6E6D0E4E6E4E4E5E6E2E4E6E5E7E6E4B5E4E7E4E5E5E5E8E6E6E6E4E6E6E7E6E7E7E7E5E6E7E8E5E5E5E6E6E5E6E7E4E3E4DD000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000007D0000000001000001E4E5E6E5E7E4E7E7E7E7E7E8E7C900010000E5E5E3E40007001D906DE0E0A8B70020000A0024AFE38726001D000000000399E2E3C5E10305E483125F07E3E4A69B264C00000015DED8DDE0711B0C0064000199E0DEE3E296E1DD7133DE005F00D8E0E3E4D6E100008019000000D0E100200000000043B3A6E380C200006D030089E3DDE6E5E2E3E3E1DBD0E0E4E5E5E1E7E5E5E2BE780E0005E3E0E0E2E2E3000A00E4E2E1E4D2E3E6E3E8E7E5E1E3E4E4E4E3E3E4E2E3E1E2E5E6E5E5E5E6E5E6E5E0E3E6E6E7E7E3E3E1E3E4E4E5E7E4E6E4E5E5E4E4E6E5E4E5E0E2E4E1E4E5E6E7E5E5E4E2E3E5E6E5E5E6E4E6E7E5E6E5E7E7E6E7E7E4E7E6E7E6E5E6E5E7E8E7E7E8E7E7E7EAEAE4E9E600000000C9E4E4E2E23600003143E1D8E0E2D8000A1DAF2489A1E1E32D2F0380071905389685E3ACE083380500010A92E1AFA180BE2D000000001DE38BE3E1A496621900CDA671E2E2E4E3E8A4381D0059E9DFE0A8E3E5E0DD0000000000416A92E3000012B7000064D6DFE0D46A1B28150010E154E2E4E6E5E57E28688B41E4E3E6E5E3E6E5E371851B24DEE5E2E3E5E39D2DBAC2BCE6E4E4E7E5E4E5E7E7DDE4E6E3E0E3E4E6E7E4E5D4E6E5E3E4E2E3E6E5E6E5E7E3E5E5E5E5E7E7E5E6E5E5E3E3E5E6E6E5E4E4E6E5E6E5E5E4E5E4E6E5E6E6E5E5E7E5E5E5E5E5E6E6E7E6E7E6E6E8E8E8E8E7E7E7E5E6E6E7E7E5E7E6000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000007F0000000001000001E4E5E5E6E6E4E7E6E9E9E9E8DC00000000B3E4E3E3E2A8260E24006283E0E347895033E2662D5FE0E1C21B050015012D5B66B5E3E2A883192819010778B3E3E1E0DF6400669B002431E0E2A19FD0924E000000195DE3E0B3E254C53800106DE2D0E3D8E3E2D0830A000012C53C00E1E20007000000432DE4E2E3592896171957DEE0E2E5E5E2D4240000001500AFE3E3E4E4E6E5E6E0685B3CE1E3E4E2E3D66428B7C2E3E1E2E4E4E4E5E7E6E3E4E2E4E2E5E4E2E4E5E0E4E3E4E4E4E4E4E5E4E8E7E4E6E4E4E5E6E7E6E3E5E5E4E4E2E4E3E3E1E5E4E5E6E6E5E0E5E3E7E6E6E6E6E6E4E4E5E4E4E3E4E4E6DEE2E5E4E6E7E7E7E5E5E4E4E5E5E5E6E3E4E4E1E5E6E5E6E8E7E6E8E7E7E8E8E900000000E3E4E4E2E1E3A4430E2B2F47E1E1A82819D0D6E35F4141E3E147875D45192D006689D4E1E199070001000000E0E3E1E3E4470000E3000031C0E1E4E2B50000005B000015A4DFE1D69FE22003B7AAE3BEE2E1E2E59DBA940E280003BAC510AF334E0C00000E0EB3E3BA9B450E260000A4E3E3E3E5E3DC9D9201240CA6492BE6E4E01D7C7805002643E1E2E5E5E5E0CDA8E2E3E7E6E4E6E47854E4E5E4E5E4E4E5E5E5E5E6E6E6E6E6E6E5E6E5E5E5E5E6E5E4E7E5E5E6E5E5E5E2E1E6E8E2E7E4E6E4E4E4E1E6E5E4E3E3E3E1E3E3E3E5E5E5E5E1E5E6E5E5E4E6E5E5E5E0E1E4E4E4E4E5E5E6E4E7E5E8E7E6E5E6E6000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000810000000001000001E6E7E7E5E7E7E8E8E6E7E5E7E5DB000007E3B1BCE1E1DC752D0000011D94E0E39200265BC9E0E27166E29F9996170059003399E0E5B5DC19000100000031E0AFE4E4DD100000007E0E2DCDE4E1D86F00008E0000170C6FE19D78803A0A7E87E0DEEBE0DCE1E2E2E39F12000ED2C7E1E2BE6D000C000C00D2E2DD1BA6BC1B00000000E4D2E4E5E3D02817B1E40026C5ACE4E445BE7A00D0D200C5E1E4E6E4E1E4B3E3D8E6E5E3E5E59B0CE2E6E5E6E3E5E5E5E5E6E4E5E1E3E6E6E5E5E3E4E3E5E7E7E8E6E6E6E7E6E6E6E5E6E5E5E6E5E6E5E4E7E5E3E7E5E5E5E4E1E4E5E5E6E5E3E5E5E4E4E5E3E3E5E5E7E8E4E6E6E7E6E7E7E7E6E8E5E5E3E6E4E6E5E6E6E5E8E7E5E9E6E7E9E8E8E8EAE6E6E7E5E5E417BA90E0E1E03C00A82000C58BB7E0B5246A6DE2E5A666E0E1E4785B00310017AA2FBEE4DBCB26009200000E00A8E466E480476A2B5247E0E3E4E27C9F73002F285747E3E1C0C7E592B10A45B5204CE8DE80E3E4E5DB000000000EC7C7E1DEC7052F000000A8E3E1AAE1E26F5D0000E100E2E5E1E0B7002801262443DCE2E2E55D9B5422E31B00AAE3E3E5E4E2E08585A4E5E4E6E5E4E4D2E1E3E6E5E7E6E3E4E6E6E6E6E4E5E6E4E6E5E5E6E6E6E6E5E6E4E4E5E7E6E5E4E5E3E5E6E5E6E6E6E6E6E6E4E5E5E6E5E6E5E4E5E4E5E5E5E5E7E6E2E3E3E4E4E5E4E7E6E3E6E4E4E5E5E7E6E5E6E3E4E6E6E7E4E694000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000830000000001000001E6E7E7E8E7E7E8E0E9EAE9E8E6E7E8E9E3CD0C99E1E3E3E000000100001B9092E3E33E0E000062E0C5E5E3E08E7A05000010002450E1E2E27E311D0000649D83C5D8E3E32D1B05E3E2A457E1E5D2E2993C7E157C36E3E2E4EAEBE8A83126E36FC7D4DD5FE0E3E4E000008B00E2DBE0E1DE7C543126000066C2E3E2E25B4C000000C50AD0E6E3E2E0262B0033504757E4E0E6E3B74900000020E2E4E4E4E4E3CDD0C7E3E7E6E5E6E4E2E2E199E3E5E5E4E5E6E6E5E6E5E6E4E5E4E5E5E3E4E6E3E4E5E6E5E5E7E7E7E5E3E6E4E8E7E9E8E5E4E2E5E6E7E7E3E5E5E7E2E5E5E5E4E4E5E4E5E6E6E7E6E7E5E6E6E6E6E5E4E5E4E6E7E7E6E5E6E7E7E6E6E7ACE6E4E5E4DCE6E6E7E6E7E8E8E8E9E8E6E8E6E51B89E32DE2E1E3E2B1013C2219649BE2D8E0170E000390E2BAE4E3E0A84100006D0A0785B3E3E4A4963100002FC7E1E1E6C7E2D66D4C267EE3E1E2E3E4E5E4DE4E6A7A36C2E1E5EBEBEBE2178EDF90DE00008071E3E5E531000E000073E5E3E5E2E23E1931287AE2E2E3E400310000121D0C5FE4E1E05F784778D000B1E4E2E2E583E1E4543A0A0C85E6E4E5E4E4E171AFD8E5E6E3E5BEE431E5E4E6E6E5E4E7E5E6E7E5E4E4E5E8E6E6E6E2E4E5E6E6E6E7E5E7E7E8E7E6E6E6E6E5E6E8E6E6E4E5E6E8E6E4E7E6E3E5E5E5E5E6E4E7E7E5E5E8E6E6E5E5E6E5E5E5E6E6E6E6E5E6E8E6E5E6E5E6E7E7E8E7C0E6E7000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000850000000001000001E6E6E5E7E7E7E6E6E8E8E8E7E4E3E5E2E33C49E2BCE1E2A6E00A00333CD8E0D2E3E0B57100A4200AB5E2DBE2E2CD4E5B0300005771E1BEE3D6C5070C01153190B5E2E2E3457C24102F1BE2C9E4E4E4E2B77C4E28209D66E2E4EBE9EBE4E0C019009B414543E1E5E59F5B100000288BE5E5E4CB0000000071E4E5E2E3B7D615003892A6E2E4E3E1850C8B0712005FE3E2E4E4DF9FE1C7E141A8CBE4E7E1E4E3E3E4E5E3E5E3E3E4E2E4DEC7E5E6E4E4E4E3E485E4E3E4E4E7E6E6E7E5E5E4E6E5E5E2E6E8E4E5E4E6E6E4E5E6E7E5E6E5E6E6E6E7E5E4E6E5E5E5E3E6E6E5E6E5E4E5E5E5E5E5E5E5E2E3E4E4E8E5E7E5E3E6E5E6E7E5E6E5E7E6E6E7E4E5E5E5E5E6E6E6E0E5E5E0E7E7E6E8E2E4E6E6E4B34CE2E0E4E4E1DF0E220000059B54B7E0E0949903001B129BE2E2E2E2E1B524831B220A2D5DE3E371262B032D8EE0E1E3E1D8DD663E0000008080E2E5DCCB226F9D4C00E078E1E0E9EBE33C6400AF00E1E047D075E3DF006D00470000E0C06AE366000A100000E3ACE3E2E3E252031724A883E2E2E59F9B380A57004EE5E5E6E5E3E2E47C2FA1E2E3E1E5E5E5E7E580E3E2E5E6E5E7E3E6E2E3E5E6E6E4E4E3E5E4E4E3E4E6E6E2E2E6E6E4E5E6E7E6E7E6E6E5E4E5E1E6E5E6E6E7E6E5E6E2E6E4E5E6E6E6E5E6E5E5E6E7E6E6E6E5E4E4E6E8E6E6E6E5E1E6E4E6E5E5E5E5E2E6C9E6E6E6E7E6E5E6E6E3E5E4E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000870000000001000001E4E6E6E6E7E7E7E7E7E6E7E7E7E7E6E4E47C00544EE1E2E2E3890012000015CB80D6E08B31104E0000384EE4E4E0E1E2495F19001BD4C9E3E2E0640087B764D6D6E5E4E2E3E136005F2B0078ACE2E2C0BEA1050000478BDDE2EBEBE2C26A1B12E133903AA1E0E2DBD0E71D0000000000E1E0E3430026003CE0CBE2E3E1070C0C1092E2E2DCE2E0AA9FE000000C12C7E1E4E3E3E3E33336C2E5E4E5E3E5E6E5E589E3E0E6E5E5E4E2E5E3E4E4E6E4E4E4E5E7E6E6E6E4E7E6E4E6E6E6E3E4E4E4E7E5E5E6E5E4E5E7E3E4E4E6E8E6E5E6E5E6E4E5E5E1E5E4E5E5E4E5E4E4E4E4E4E4E3E6E4E3E4E2E6E5E6E6E6E5E5E6E4E4E4E6E6E6E5E5E7E6E5E6E4E4E4E2E4E6E7E6E7E7E3E7E7E7E8E7E7E6E3E5E200007A1BB1E3E3E34E52220C4C2059BE96E2E2BEBC593C005D2066E6E5E266E0470C5F1BB3E5D2E5E37C509B2D73C9E3D4E4E4C0D6D63C000087E28BE4E4E0E39F0000802B89AF2DE0EAE645DEE5E1E4E9B71010E1E2E2EBC79900E40000E0E2E6E08B002200171DE5E4E4BC0000E20033DEE4E1E4E6E3E2E317473643E1D0E4E4E4E4E571B30AE6E5E5E7E5E4E4E4E164E4E5E4E3E3E0E4E4E5E5E5E6E4E3E2E6E6E6E6E7E7E7E3E3E4E4E5E6E5E5E8E5E6E7E7E6E5E5E6E6E7E6E7E6E6E5E6E5E7E7E6E6E4E6E5E6E6E4E5E4E3E5E6E5E0E6E5E4E5E4E8E7E6E7E6E5E7E6E6E7E7E7E6E696E7E8E7E7E7E5E6E5E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000890000000001000001E2E7E7E4E8E8E6E8E8E7E7E7E7E6E8E6E1BE4C542F50DEE3B5D8640024E171419DC2E3E092DB3673282F3C9FE0E4E371005D99360057BEE0E4E278E4D81959AFC7E2E4E5E2E0CB6F00006AAFE2D2E3E2E18E8E034E0000599689E7E45D73E5E5E4E4789D00336AE2EAD0EB000000006AE2E15D1B2022E02036E3E4E6E21B00000049E0E1E3E2E1E5E58B8B2415AFE4E2E6E4E6E6E43C000ED4E3E4E6E4E4E3E3E3E2E3E3E6E5E5E4E3E5E7E6E9E7E6E6E4E5E4E4E6E6E6E894E7E8E7E5AAE5E5E7E6E7E8E6E4E5E5E6E5E5E6E6E6E2E7E7E6E6E6E6E7DDE5E3E6E6E7E6E4E4E4E6E7E7E7E7E7E7E6E6E6E7E7E8E6E5E6E5E6E6E6E6E6E6E4E6E5E7E8E6E6E6E5E5E8E8E7E7E7E7E7E9E9E7E8E7E6E6E7E1E1014112ACE1E3E2E05996D847572073E352E0E3DEA67A542F1B4EE3E6E5E4331D5422000515DFE5E1CBE3960A411DE375E3E3E5E2E1365B6FAF12E1B3E1E6C7E378100124000078DBAFD4DE9283E4E4BE5B1D0017ACE4E9EBE98700001BD6E6E5E149009680199268E6E38E714122711D31E5E5E4E6E6E4E4A11B24E5E7E4E6E3E6E6E252C512E4E6E7E6E3E4E3E4E79FE3E7E7E3E4E4E2E4E5E4E7E4E5E2E4E5E4E5E6E6E8E7E6E4E7E6DFE6E6E5E7E6E6E9E8E6E6E6E7E7E8E7E7E6E6E6E6E7E7E5E6E6E4E6E5E5E7E5E6E4E6E4E6E5E6E5E4E5E4E4E6E6E5E8E7E6E4E5E7E7E7E7E7E8E5E7E5E6E5E7E7E5E6E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000008B0000000001000001E1E5E6E5E7E3E6E6E8E8E7E8E5E5E6E6E3E20E17832675E2E4E147E3E16A280054E1E180E5E5E05D3A500E4178BAE4E57C07892B0A590000E6E1E1544C3C5283498BE3AFE6E3DCAA0112E05B49E0B5E1E1E43C000000000028E396DDE2E2E4E4E65990000000E3E5E4EBEB80002FDEE2E5E9E4E0496D0E1B2DE1E3E3E3E2007A2D3815C7E6E3E5E5E6E750010000E3E2E3E4E5E4E2E0E3ACE5E4E6E6E5E0E2E3E3E319E4E6E4E3E5E3E5E5E5E5E4E6E6E5E4E3E2E6E5E5E7E6E4E6E6E7E5E6E4E5E5E6E5E6E6E1E7E8E8E7E7E9E6E7E9E5E5E6E5E6E6E6E5E4E5E6E5E7E5E2E5E5E5E6E6E7E7E4E5E5E6E7E7E6E0E5E5E6E7E7E7E7E6E7E8E7E7E7E7E7E7E6E7E4E7E7E4E7E7E6E7E8E8E8E8E8E9E8EAE2DB280A1243DC8EE2E2E2E3E2E14C3C01B3A4E3E5D6E37831DF6F1B28E1E2E2E3504C1531E20015E1E4E3DF8745A82F45338EDEDFE4E383D2492F50A4A1BAE4E5E894E00000000C3175BAE2E4E4E5E5E4240000004949E2E4E4E5D207A1D6E5E0E4DDE4C92222000EE2E5E5E4E58B5F005210E4E4E5E4E4E7AA9F19000003E1E5E5E5E6D0E3E2E3E4CDE4E4E5E5E5E566E215E6E5E4E4E5E6E6E6E5E7E7E7E6E7E7E7E6E6E7E5E6E6E4E3E7E8E6E5E5E7E7E7E7E6E6E5E7E6E6E5E6E6E5E5E6E8E8E7E7E5E7E5E6E5E6E6E5E4DDE4E4E4E6E5E6E6E5E6E6E5E6E5E7E7E6E6E7E6E6E5E6E6E7E6E6E7E7E7E5E7E6E64C000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000008D0000000001000001E3E6E6E5E8E9E5E8E7E7E6E7E8E8E9E8E5E5C70A1DE1E2E4E3E55BE4E1DE80124322E0ACE2E2AA8B9B2B3C1920DFE4E4E2C0BC000C0033001BE5E1E5E2E173BE244E3378DEE5E4E3BE17243300E0AFE1E3E5E0D8BE712020542F41E7E2DCE3E3E46D6A00640A85E4E4E619000000E1E5E3E4E5E3E00C78E364C2E3E5E471014E00E5E3E5E4E4E5E4E4360700E3001DE5E6E4E8E1ACC7E08EE6E7E4E4E5E4E4641DE0B3E5E4E5E5E4E4E5E6E6E7E6E6E7E6E4E5E6E6E6E5E6E4E3E5E6E6E6E4E5E6E6E7E6E7E0E5E5E6E5E6E7E6E3E5E6E5E5E5E4E8E5E6E4E5E6E6E6E5E3E4E4E3E5E5E6E6E5E5E5E6E6E5E6E6E4E5E5E7E7E7E7E4E5E6E6E8E7E8E7E2E6CBE7E4E5E6E6E7E4C7E7E9E9E9E8E8E9E8E9E6E415940000A8DFE2E26D78E2E27E0131289FDDA6E5E4E3000000000136AAE2DEE4E34E07389BAA45E3E3DDE1DEE1B312002F7EBEE4E5E4544C26001B43DD64E5E4E3851DAA5F547CE031A6C0E3E4E3E6E37E173A1728E0E6E40000000028E3E4E7E2E2E003E5E743A6E3E3E45D451D00E3E4E4E5E5E4E4E5E3C205000083E4E6E6E5E6E1D8E1DCE2E6E5E6E6E4E6DD3CE5E5E5E3E5E4E2E6E4E6E5E3E4E3E4E6E7E5E6E7E6E7E6E6E7E9E8E2E3E4E5E6E7E6E8E5E6E6E6E7E6E6E6E6E4E6E6E7E7E6E6E8E7E5E7E7E6E5E7E4E3E5E5E7E6E6E8E5E3E4E5E8E8E8E9E7E6E7E5E6E6E4E6E4E6E6E8D8E7E6E6E6E5E5E6000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000008F0000000001000001E5E7E7E6E6E3E6E7E8E8E8E3B5E4E2E6E4E3249FB70019DF6FE2E5BAE2E2DD9B92001D3C3650E2E10C19004E0000529FE5E0E2CB785D05CDE0E1E4E4CD9BC9000000310078E4E5E1CBBEBA0000033EAFE3E3E6E49643734E3AE3E4E4E0E6E6E0E7E4D40700006AE3E6E60019E3006DD4E5E6E3E0157A7CE200B3E1E3E2C9222B0185E5E5E6E4E3E5E6E7E631004CE3E5E8E5E8E6E3E3E3E1E6E7ACE8E6E4E5E5AAE6E5E6E6E5E6E5E5E4E6E5E5E5E5E6E6E6E5E6E8E7E7E7E8E7E6E7E5E5E5E5E7E7E6E7E4E3E4E5E7E7E7E6E6E7E6E7E6E7E6E5E6E7E4E6E5E7E5E6E3E4E5E6E6E5E6E6E6E5E7E7E7E6E5E7E6E5E7E6E2E5E6E7E4E4E6E8E5E6E6E7E8E7E7E8E5E6E7E6E7E7E8E7E8E8E8E8E9E8E8E6E4E3E200001D26E18BE2E5E3DBE4E1B700E300945FDEE0D2AA57000000001547C2DCE0E52D0C1BAFAFE185E5E1CBD69D7A246F49E1E2E4E3E0E217000031906D89E3DDE3E3D2E27131CDA1C9E3E3E4E3D4E20707000E00E1E6E6000000009DE2E4E7DCE39F4538284CE6E6E6E5C57C94E4DEE4E4E7E6E6E5E5E1E3DDE7E6E7E7E6E4E6E6E4E4E36AE4E3E4E4E4E4E4E4E4E5E6E8E6E5E4E6E7E6E7E6E5E4E5E5E7E6E6E5E6E2E4AFE6E6E7E6E7E3E6E7E7E7E7E8E4E6ACE5E7E5E6E6E6E6E6E6E6E5E7E7E7E5E6E6E6E8E7E6E4E4E4E3E6E6E6E4E5E3E4E5E6E6E7E5E7E6E6E8E6E5E5E5E5E4E6E5E5E6E6E7E6E4E5E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000910000000001000001E5E6E6E6E7E8E7E7E7E5E6E6E5E4E4E4E2E3E07A430EC7E1E1E2E4E3E0B5E1C9002854386A87E1DBE349000000000028E0E2E4E0101B9B6D2FAAE3E2DCE0D62B47640AC2E3D4E2DFE7E57500000AC983E3E4E4DEE4E4E0004C9DB380E4E4E6E5DE380C00000007E2E4E6E10000107AE3E1E5DFE0E3E5AF22DBE4E5E59BE11522E4E6E7E6E6E6E5E5E5E6B7E1E4E4E6E6E4E6E5E5E2E3B17AE3E5E5E1E4E4E3E2E5E5E6E7E5E6E5E5E5E5E5E6E4E4E5E6E4E5E5E4E5E8E5E6E4E7E5E3E5C2E4E6E6E5E4E6E3E4E4E6E7E6E7E7E3E6E6E4E5E4E5E5E4E6E2E4E5E5E6E6E6E6E7E7E6E6E5E4E6E6E4E6E7E5E7E5E6CBE5E6E8E6E6B1E5E7E5E7E6E5E7E6E7E6E5E6E5E6E5E7E7E7E7E6E9E8E8E9E5E6E4E4E3E3E3E23C2087E3DEE0E2E2E2E3E4DF052D053C33A8E3E57E7E00001700000A45E0E2575F012D330CE1E5E4E3E0E1943E99242DBCE3E4E3E3D8E2A8E375B1DCDFE1E5E4E3E1E3D26492E1E0DEE2DEE4E2E31901360E5B57E6E5E5527E1B0773E4E5E5E4E1E3E51994E5E6E4E5E59236E5E5E5E6E7E7E5E5E4E4D290684CE6E6E6E6E6E5E4E4E3E5E2E3E6E5E7E5E5E6E6E6E3E8E8E7E6E8E6E5E6E5E7E6E7E9E6E5E6E5E4E5E7E7E6E6E5E5E6E5E4E6E6E7E5E4E5E3E5E6E6E6E7E7E6E6E2E7E6E5E5E7E6E6E5E5E4E4E4E4E6E5E5E6E5E5E6E6E5E4E4E6E6E5E6E6E5E5E6E7E5E5E5E5EAE6E7E8E7E7E9E7E5E5E3E4000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000930000000001000001E4E6E6E6E6E6E6E7E6E7E7E7E3E3E3E2E2E0E2E0800000808E80E0E1DCE1E2E0AC477A54263C87E39FC5470000001B2B4EAAE3E1DFE2474E19DDE2E4E0E2E14C153E3E0000648BE3E3DCE3DB7580DEE2DEE4E4E4E6E5E44719100794BAD2DBE4E4E0D047074719E3E3E5E2E02B244322BCE3E4E2E3E0000012C5E3E4E4E443DBD0E587CBE7E6E5E4E6E5DBB75750C2E5E6E6E7E6E4E3E4E2E5E5E3E4E2E3E2E3E2E4E2E2E5E5E6E6E5E4E3E2E3E3E5E6E5E5E3C9E5E6E5E6E7E7E7E6E6E5E5E6E6E5E6E7E4E4E5E4E4E2E2E3E5E3E5E6E2E5E4E3E5E6E6E8E4E4E5E3E4E4E4E4E6E5E6E6E5E5E5E5E7E8E5E8E4E3E4E4E5E4E2E4E6E4E6E7A6E5E696E5E6E7E7E7E7E7E8E7E7E8E7E8E9E7E8E7E6E2E6E2E2E1DC20A8005BE0C9E3E1E39FE4E3E352D46D2641C59DB5E36A173C125B4C5DE0E4E5BEE1BE1041158EC0D8E3E0E19B2B0E000000ACE2E4E2BCDBAC83D4E2E3E3BEE3E4E1437AE4E400E0E1E4E3E4E5E5E2BC00415BDFE2E3E4E10024CBE5E4E4E4E2E4E40500006FE4E5E2E2E4E3E5E468E5E5C7E6E6E6E5C0B5E0E5E5E6E5E5E5E5E4E5E5E3E5E6E6E7E4E4E4E4E6E5E6E4E5E5E4E7E6E6E6E5E8E6E8E8E5E6E5E3E5E5E5E6E7E4E4E5E6E5E5E6E7E7E6E7E6E3E5E6E4E5E5E6E3E3E6E5E5E5E4E4E5E5E6E5E3E5E6E5E3E4E4E4E6E7E7E9E6E6E5E6E6E5E6E6E7E6E3E7E7E7E5E5BEE8E0E7E3E7E7E8E8E6E6E6000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000950000000001000001E5E7E7E2E7E8E4E7E8E8E7E8E7E7E8E7E3E2E3E26DDE246FE2DEE4E4AC2FE3E3E2E2C0C05F2DC971BEBEE4B58E4E2F991599E5E7E2E5804500057AB3E1E3E3E29BB1071B1B1568BAE6E3E3E2E12F33B5D0D2E4E5E3E02F10523C05E4E3E09DDEE8E5453619005BE4E2E5E4E1000019DEE4E3E5E5E4B500E500BCE5E6E4E4E5E4E3451049E4E4E6E4E4E5E6E6C9E5E5E6E6E6E6E7E6E7E7E6E3E6E6E5E6E6E5E5E4E5E5E5E5E4E6E7E7E6E5E6E6E5E5E5E6E7E6E6E5E6E5E5E6E6E6E6E3E4E5E5E5E6E6E6E4E5E5E5E6E5E5E5E7E2E7E8E6E5E8E6E6E7E6CDE6E7E5E6E2E4E3E3E7E6E6E7E3E4E4E4E6E6E0E7E6E7E7E8E7E5E6E5E6E4E8E77CE7E6E6E7E6E7E5E5E7E7E7E7E6E7E6E7E7E8E7E6E4E6E5E2DBE2E2E58B3301E0E0E5DC311290E3E6E5E3E38EB3999FDDE3E4E3434C473310A1E1E1E6D6E2B5009B4789DCE5E4E0E2C53A00000122CBE3E0E3E2BCA80C50B1B1D8E5E5E3D4DF57361DE3E3E496E3E5BC47E4010000E4E6E6E6DC00000000A4E4E4E5E4E4100000E1E5E5E5E5E5E4E33C0090E6E3E6E3E5E6E6E5C0E4E6E6E8E8E6E8E6E7E6E7E4E5E4E5E4E4E4E4B7E5E6E7E5E6E7E7E6E6E6E3E5E5E7E6E5E3E4E5E6E6E7E5E9E6E6E8E5E6E4E7E5E6E6E5E4E6E4E5E5E4E5E4E6E6E8E7E4E6E6E5E6E5E6E6E6E5E6E7E1E5E4E6E7E5E5E6E5E4E7E6E7E7E8E7E6E6E6E7E4CD6FE4E8C9E8E7E5E6E8E7E7E5E7E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000970000000001000001E4E6E6E6E6E6E7E6E8E9EAE8E3E6E6E7E3C7E2E3E3D8BE1703BAE1E238174EDEE3E5E4E3E04EE3E2E4E4E3E55BAA5F3E014968B7E2E1BA5F7C8022DC92E3E3E3E5E03C68000022AFE4E3E1E4E38E83B352E1D0E2E6E3E2C97CE2E4E4E27E8796E0E387E0003C0073E4E5E5E400004700E4E4E4E4E26803000052E4E3E5E5E5E4003C0003E6E8E9E7E3E5E4E2C752E4E5E6E5E5E4E5E5E5E4E6E5E6E7E3E5E4E4E6E5E3E4E3E4E5E6E7E7E5E6E6E5E5E4E6E6E6E5E6E7E5E5E6E4E4E4E2E6E5E5E6E5E4E4E4E5E5E5E4E6E5E6E4E0E4E4E7E6E6E7E5E4E3E5E5E4E6E4E4E4E3E6E6E3E6E5E7E6E6E6E5E4E2E4E6E5E7E6E4E4E4E6E5E3E6E7E8E6E7E7E6E550E3E7E8E2E8E7E8E7E8E1E7E8E6E7E6E8E4E1E0E2E1E2E178195094E3E5523AE1CBE0E3E2DF417343DCE2E3E1E3E273995D224EBCE0E4E5E6D0385B286AC794E0E2E290DCE13A0C78E1E4E5E5E3E462265D3AD6E2E1E3E4DF22A4E6E5E6E36D9FDFE5E6E4E2000000E3E6CDE4E4000C0524E6E3E4E6E4E4752B00DCE4E7E4E4E5E35207053AE4E7E5E6E8E6E7E6E4E5E5E6E4E5E6E5E5E5E7E7E6E5E5E5E6E5E3E5E6E5E4E7E5E4E7E6E9E8E8E8E6E3E5E6E7E7E7E5E7E6E6E6E5E4E4E4E5E5E6E6E5E3E5E5E5E5E6E7E7E5E4E5E5E6E6E5E6E8E6E7E4E7E5E6E8E7E5E6E4E1E1E3E7E8E7E6E6E5E6E6E6E2E6E6E8E7E6E7E5E6E7E7E7E8E6E8E7E8E8E8E6E5E7E6000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000990000000001000001E3E6E6E7E7E7E7E7E9E7E9E9E5E7E5E7E4E4E4E5E2BCE02200DCE3E4C0BEBA8ED6E3E3E1D89D73BAE1E4E0E3E5E1B73859526AA4ACE4E5E02D6A62B7DCE196E2E4A49BE1662F3EDCD8E5E4E1E468A8E0E0D85F90E3E4E4E092DFE2E3E1DF505BE5E5E590000000BEE5E6E5E3A4150024E3E5E6E6E6E443129BE4E6E5E6E5E4E5E4755B5422E4E6E7E6E5E6E5E4E4E4E4E7E7E8E7E7E6E6E5E4E4E6E6E4E6E5E4E2E3E5E4E6E6E6E8E6E5E4E5E6E5E6E6E4E4E3E1E5E4E4E4E8E5E6E6E6E4E3E4E8E7E5E5E4E6E6E7E3E5E4E5E6E5E6E6E6E7DBE4E6E7E6E7E6E1E5E5DCE0E3E4E5E4E5E6E5E5E6E6E7E6E6E4E5E6E6E6E4AAE5E3E6E5E5E5E6E6E5E5E7E5E4E6E7E7E8E7E7E6E6E6E8E7E7E7E5E6E6E8E3E4E3E2E600A1E10AE0E6E4B5D68389E4B5E5E4A1E0C75BE1E5E2E3DCE196963820192B50DFE5E3E06F2FC5E2DCE5E4E2E4DFE2310700DDE2E3E6BEE5E4ACBAE1D492C7E4D2E3E5DFE4E2E4DCE2C5C9E2E5E5E6E199E1E7E7E5E5E5E43600C2E4E5E5E4E2E31500E4E7E5E6E5E5E5E5E38EDD261DE5E7E7E6E4E5E6E4E3E4E5E8E7E7E7E8E8E6A8E5E6E6E7E5E3E6E2E8E7E8E4E3E6E6E7E7E5E6E6E7E3E7E7E2E5E5E3E9E6E7E6E5E4E5E5E7E7E8E7E7E6E7E7E5E5E6E5E8E7E8E6C9E6E6E6E7E6E6E6E8E8E8E8E6E6E6E6E7E5E6E7E3E4E5E5E7E8E5E4E7E7E6E6E8E7E7E7E5E6E7E792E6E6DDE8E7E9E7E6E4E6E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000009B0000000001000001E8E7E7E7E6E7E6E7E8E8E8B5E8E5E5E8E4E4E4E3E3E152C7DBA8E5E3C08EAAA6BEE4E4E4E138A6316DDBE3E3DFE7CB33072F33A1E5E6E6E79985A1E03E73E3E2E6E4E4E51B380103D6E1E5E6E5E4BEAFC9DCB1D6D0E3E4D2E5E5E5E5E4E5C5D2E2E4E5E3E522432BC7E5E4E5E5E04547E6E5E6E6E6D60000E6E7E7E7E6E6E5E5E633280028DCE5E5E7E7E6E6E5E7E3E6E7E6E8E7E5E6E6E6E6E5E4E5E5E4E4E4E6E7E6E6C5E6E6E6E8E7E7E7E7E5E7E6E5E6A4E6E5E6E6E6E7E6E4E5E7E8E7E7E5E5E5E6E7E8E7E7E4E2E4E5E6E5E6E5E6E7E7E6E8E7E5E7E6E7E7E5E5E5E3E3E6E4E3E6E6E6E7E6E7E7E6E6E9E8E8E7E7E7E7E4E9E8E7E7E7E7E7E6E6E5E7E7E7E6E6E7E7E6E6E6E8E8E8E8EAE8EAE8E5E6E5E3E4E5E4E4E0E3E1E5E28E8B0078E3E1E0E5AABE9DB3E3BEE4E2E0997ABE0543C5E2E5E5E5D83E59502407D8E1E4E4E4DEA4000510E0E5E4E5E4E5E0B7549F6FE5E1E6E5E3E4E4E4E5E3E4C987E3E3E6E59B1B413EBEE6E5E8E5E3E0E4E6E7E8E6E5E30050C7E5E6E8E7E6E6E4E7E65DE50CE3E5E6E4E6E6E7E7E7E7E8E7E6E6E7E6E5E5E6E6E7E5E5E4E5E5E6E5E5E6E5E8E1E6E8E8E7E9C0E7E5E7E7E6E6E5E6E5E7E7E7E6E5E6E7E5E5E5E7E6E6E5E7E8E6E7E7E4E7E7E7E7E5E5E6E7E5E6E7E6E5E6E6E6E7E6E8E4E5E5E5E7E6E5E6E7E7E8E7E6E6E7E6E9E8E8E8E8E8E5A6E6E7E7E6E8E7E8E8E6E4E6E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000009D0000000001000001E4E5E2E5E7E8E7E8E6E6E6E7E6E5E6E4E5E4E4E0E5E2E5E3DFE2E2E2C7D099544C7AE3DFE3D6AF454CC9E4E4E6E0D085506A925FE2E2E4E3E3471DE062ACDBE3E3E3E6E4E0994E59E0E4E0E4E3E3E29D80D296D6E2E5E5E5E6E6E6E6E3E231B1E5E5E4E2BA269B00E0E5E4E5E6E4E3E6E6E7E4E7E6E6E6E200E3E5E1E3E5E5E3E4E600E49BE1E6E6E8E7E8E7E5E5E5E5E6E6E7E8E6E5E4E6E3E5E5E4E7E7E6E6E6E7E7E7E6E5E5E3E3E3E4E4E5E6E5E6E6E5E3E3E6E7E6E7E7E6E7E7E6E5E6E6E5E3E5E4E5E6E6E7E3E2E4E6E3E6E5E3E3E1E4E3E7E5E7E6E5E3E4E5E6E6E6D0E4E6E4E7E6E5E5E6E4E2E4E6E7E7E6E6E77CE6E9E8E7E6E7BEE5E6E6E6E6E5E6E7E8E7E7E8E7E7E7E7E7E2E6E5E5E4E3E4E4E2E3E2E2E2E20000E2E3E2E4E2473EA4DEE4E5E4281D9DE2E3E2E4E3BC5F547A5492E4DFE2E3E3AC9289A4BEB5E3E2E5E4E3E2B35757DEE3E5E6E4E4E4E1E4B3E2E4E5E6E7E7E5E3E4E5E0B1B1BEE3E5E6E47C47201596E6E4E5E6E5C0E5E6E7E6E7E6E5E5E00EE2E3E5E5E5E5E6E7E6C52F01E4E6E6E6E6E6E5E5E6E6E6E5E5E4E5E6E4E4E4E5E3E5E5E4E5E6E6E5E6E7E7E7E6E7E7E5E4E6E6E5E5E6E7E5E4E6E5E5E4E6E4E5E5E5E6E6E6E6E6E6E7E9E8E6E4E6E6E5E6E6E7E6E7E6E5E6E7E5E6E8E8E7E7E5E6E6E6E7E6E7E5E4E4E5E4E6E7E7E7E6E6E8E8E8E7E8E7E6E7E7E7E6E7E6E6E6E8E7E8E5E6E6E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C02000000000000010000009F0000000001000001E6E5E6E6E7E7E7E8E7E7E7E6E6E6E6E5E1E2E2E2E2E1E312000057E3E3E0C99D5F00E4E3E2E575000075E1E3E1E06A4C179DBA4520E2E5E4E4D0E3E13EA4E4E1E2E2E4B5E1E3E2C9BAE4E3E0E7E2E5E4E215DB8EE4E4E5E5E5E4E4E6E32F0C71E7E4E6E5A119200043E6E7E5E3E292E3E3E3E5E4E4E4E5E4E4E5E1E5E3E1E2E5E7E6E3E5E5E4E5B7E8E7E7E7E7E5E5E7E4E7E6E7E5E7E6E4D0E5E4E4E5E5E4E6E5E4E6E5E8E6E2E6E5E5E5E4E7E6E7E7E2E5E4E5E6E5E6E6E7E7E6E6E5E5E5E5E6E4E5E5E6E4E5E6E6E4E5E6E8E6E6DFE8E5E5E8E6E8E6E7E5E3E6E4E7E5E5E5E3E5E6E4E6E7E9E8E8E7E8E7E6E7E7E2E6E6E6E7E5E7E7E5E6E6E7E5E9E8E7E7E6E6E7E7E8E6E8E8E7E7E7E6E2E4E2E3E6E4E4E4E2E3E4E00000BCE4E4E4E4E16FE2E2E3E3E2E3100043C7CBE6E5C98EB7E3BC0C28DBE2E3E4D4E250C741E1E2E5E5E6E7E6E5E6E5E4E0E2E3E6E5E2E3897E7800E2E6E5E5E6E7E6E5E410E433B7E4E5E6E2D400E000E6E6E6E5E4E4E2E6E6E7E7E5E5E3E4DFE4E2E3E507E5E3E5E5E5E6E7E2E6E7E7E7E7EAE6E6E4E4E7E7E5E5E7E6E6DFE6E5E8E7E7E6E6E5E5B1E5E5E6E7E6E2E4E4E4E4E7E6E6E8E4E5E5E5E5E7E6E6E6E6E7E7E6E4E3E6E5E5E5E4E7E6E5E6E7E6E8E7E8E7E6E8E5E2E3E5E7E6E6E5E7E6E6E6E4E5E3E4E6E6E4E6E3E7E6E6E7E7E6E6E6E6E7E5E6E7E7E7E9E7E7E7E7E7E7E7E8E7E7E7000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000A10000000001000001E7E7E8E8E8E8E8E8E87EE8E8E6E4E5E4E4E3E2E1E5E4E4E3DF47E0E4E1E4E4E2E5E3E1E3E3E2E2C0128BE1E0E4E36DE3D0E07154806FE4E2E2E5CB45C01D94E0E2E2E2E1E5E4BE5903E3E4E4E5E3E3E4E0100EAAE3E3E5E4E5E5E2E5E4E0AAE1E8E7E7E7E4E3660000C9E2E4E4E1E4E3E6E5E6E7E8E6E6E3E3E6E5E4E66F41E3E5E3E5E2E5E5E7E5E6E5E5E4E8E6E6E6E9E7E7E7E5E4E4E4E4E4E5E6E5E6E4E4E4E5E6E5E5E7E7E8E6E6E5E4E6E7E6E6E4E5E5E5E7E9E6E6E5E6E7E7E4E5E4E4E7E6E8E7E6E6E5E4E4E6E5E5E7E6E5E4E2E4E7E8E9E1E6E6E8E7E6E6E6E6E7E5E7E6E6E7E6E6E8E6E6E6E7E6E5E5E6E6E8E6E7E6E6E5E6E7E7E8E7E9E6E3E6E3E7E6E7E6E8E8E7E7E7E7E6E6E6E5E6E8E2E3E4E3E4E5E4E2E4E5E5E5DEE3E1E3E2E159E3E4E3CB0C17788E75E2E2E5E4E38E01B71D90E4E1E0E3E2E0BCCD47E3E4E5E7E5E6E6B112664EE5E4D8E5E4E4E55D0AB3E0E4E2E3E5E4E4E4E35D0010E4E6E4E4E5E4000000E2E2E3D4E4E3E3E4E6E7E7E5E6E3E5E6E4E6E4E4E226E3E6E5E1E3E3E3E2E1E6E5E5E4E5E6E7E4E6E7E7E5E6E6E6E7E2E5E5E5E4E5E4E3E6E6E5E6E9E7E7E5E4E5E4E4E5E4E5E6E5E4E5E5E5E5E5E5E8E7E8E8E5E5E4E5E7E7E7E7E6E5E5E6E5E6E6E6E8E7E8E8E6E6E6E6E8E7E7E6E6E6E6E8E5E5E5E4E7E6E8E7E4E7E4E6E8E7E6E7E7E8E7E8E8E8E8E5E7E8E6E6E7E7E6E6E7E6E6E7000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000A30000000001000001E6E6E6E6D2E6E7E7E9E8E9E9E7E7E7E4E3E3E2DBE3E3E4E5E1E3E3E3E4E0E2E3E4E2A8E5E3E2E5E09D4C3AE3E4E6E7E7E7E4D21928E000E6E3E5E5E587D4E2E3E5E3E4E3E6E62B1D0500C2E3E7E6E6E7E5E0E3E3E6E5E6E5E5E4E4DCE4B754009FE5E7E7E4E500A8E2E5E6E5E4E5E6E5E4E4E4E2E6E5E7E6E4E5E5D2E6E7E5E6E6E7E7E7E4E4E4E3E5E4E3E6E4E7E5E6E8E6E7E7E7E4E6E3E4E6E4E6E7E7E6E6E8E3E7E7E6E7E5E5E6E5E5E4E8E5E5E5E7E7E6E6E9E6E7E3E8E7E8E7E4E3E5E4E7E6E8E8E5E3E4E5E8E7E6E7E8E6E5E7E7E6E7E9E6E5E0E5E5E5E6E6E6E6E5DDE8E7E7E7E6E6E6C9E3E0E6E6E6E5E5E6E4E5E5E5E7E7E7E6E8E7E8E8E7E6E6E6E7E5E7E6E7E8E8E8E8E8E8E8E8E7E6E5E4E0E4E2E3E1A8E4E3E4DBE2E3E2E4E0E6E4E5E4E3E1E5E0E24C45E5E4E3E6E4E5E4E05000C7E1E4E5E4E6C0E1D8E2CDE2E7E5E626E5A6A60005E1E4E5E6E4E5E7E5E5E6E6E5E3E7E4E5E4E5E3B3E3AA59E3E6E3E6E50AB7E5E5E6E8E4E6E8E6E6E6E5E6E6E7E5E5E5E5E4E5E5E6E6E5E8E6BAE5E9E6E6E7E3E2E4E5E7E8E8E6E6E6E8E7E9E7E8E6E6E7E6E6E7E5E5E5E6E7E8E6E6E5E3E4E6E7E5E7E6E6E8E6E8E6E7E7E7E6E5E6E5E4E5E4E6E4E6E7E8E7E8E7E6E5E4E6E7E7E8E7E7E7E6E7E8E7E7E7E5E5E6E7E7E8E5E7E5E6E4E6E8E7E8E8E7E5A6E6E7E7E7E8E3E5E5E7E6E7E7E6E8E7E9E7E8E8E8E8E6E6E6E5000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000A50000000001000001E7E7E7E7E7E7E9E7E9E7E8E8E2E7E7E3E3E4A4E3E5E0E3D4A4E2E3E4E4E3E5E5E7E7E6E6E69FE0E7E420017CE1E1E5E3E4E4E13315A4A4E4E6E7E4E5E4E5E6E2E5E5E4E2E5E6E3CB158375E4E7E6E6E5E5E5E0E5E6E7E6E5E6E6E4E5E6E457332FE6E6E6E2E696E380E3E4E4E3E6E4E5E6E6E6E7E6E6E8E7E7E5E5E5E4E5E5E2E8E7E7E7E5E6E5E6E6E7E5E5E7E7E7E8E6E3E6E7E3E6E6E6E4E7E7E6E4E5E6E5E5E5E6E6E5E5E5E4E6E7E5E5E7E6E6E5E6E7E5E7E5E6E6E5E7E5E6E3E5E6E5E7E7E6E5E6E6E7E6E7E7E7E8E6E7E6E8E7E3E7E8E7E6E5E5E7E8E6E5E7E8E6E5E6E8E7E8E6E6E7E6E6E6E7E6E7E6E6E5E6E7E6E7E5E8E8E8E9E8E7E8E7E6E6E6E6E8E7E8E8E7E7E6E6EAE9E9EAE6E7E8E8E1ACE2E2E3E4E2E3E564E2E4E4CDE5B1E1BCE6E7E5E5E7E5E5E27AE4E5E4E5E6E2E5E473E2DCE4E5E2C9E5E4E2E2E4B7E3E5E4E4E2E5E4E2549675E5E5E5E3E6E4E5E3E5E4E5E4E2E6E3E3E3E5E5A800C2E5E5E5E6E5E4D4E5E6E6E5E5E5E4E5E4E5E4E4E4E4E4E6E6E4E4E6E6E7E5E4E4E5E6E5E7E8E6E6E6E6E5E6E6E4E6E5E7E9E7E5E7E6E5E7E7E7E6E6E5E5E4E4E4E5E6E5E6E5E5E6E6E5E5E4E6E5E6E6E5E8E6E7E4E4E4E5E6E9E8E8E4E5E5E8E8E7E6E5E6E7E7E8E6E6E6E7E7E8E5E6E6E7E8E7E8E9E8E7E6E6E6E6E6E6E7E7ACE7E7E6E5E6E6E7E8E7E5E7E3E7E8E8E7E7E8E6E7E9E8E8E8E7E6E7E6E7E6E7000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000A70000000001000001E7E7E7E7E7E9E9E9E8E8E8E8E7E8E9E8E3E4E5E4E0DFB7E4E7E6E7E6E04131E5E6E5E5E5E4E4E5E39D80E6E5E5E675E6E7E7E7C0C0E2E5E4E6E4E5E4E2E4E3E3E6E7E6E7E6E5E5E6E4E2E5E4E1E2E6E7E4E6E5E5E4E5E5E7E6E6C5E5E6E4E12BE2E7E6D8E5E6E2E2E4E4E5E5E4E4E6E7E8E6E6E7E6E6E6E6E6E5E7E7E5E5E2E6E4E4E5E4E8E7E6E7E1E5E5E6E7E8E8C5E6E6E7E5E5E6E6E3E6E5E7E7E6E6E6E6E7E8E7E7E4E6E5E6E5E6E6E5E5E5E6E5E6E7E5E5E6E5E3E8E8E8E6E8E5E7E5E7E7E7E8E8E6E7E5E8E7E8E6E7E5E6E6E6E7E2E7E7E8E7E5E8E8E7E6E7E6E5E3E5E4E0E6E7E7E8E9E7E9E7E7E7E8E7E8E7E8E8E8E8E6E6E5E5E9E8E9E8E7E6E7E7E8E7E7E7E7E5E7E7E7E7E7E7E7E8E8E9E3E2E3E2E6E6E4E6E4E4E4E5E3E5E5E4E7E580C9E4DDE5E5E3E5E7A8E6E5E6E6E3E5E5E3E5E5E3E5E6E5E4E4E4E5E4E6E5E5E4E4E5E492E3E6E6E6E6E4E4E4E5E6E7E7E7E5E6E6E6E6E4E5E4E5E4E3E3E5E5E5E7E8E7E6E8E8E9E8E9E6E4E5E7E6E7E6E6E480E5E5E6E7E8E7E4E6E4E4E7E5E6E6E8E9E8E6E6E8E8E6E6E5E6E7E8E7E8E7E4E6CDE6E6E7E6E6E5E4E4E5E6E6E7E6E6E4E5E6E5E5E4E4E6E6E7D2E7E8E8E9E8E7E8E8E9E7E5E6E4E6E5E5E8E5E7E6E4E5E7E7E6E8E7E6E9E8E7E8E8E6E8E7E7E7DEE7E6E6E6E7E8E7E7E3E7E8E7E8E6E6E6E7E7E8E7E7E6E6E7E7E6E7E7E7E8E7E7E8E7E8E7E8E7E5E6E6000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000A90000000001000001E8E8E8E9E5E6E6E6E7E6E6E7E2E2E3E1E3E3E2E3E6E5E5E4E4E5E3E4E5E3E2E6283AE4E5E4E119E57CE2E6E7E6E7E7E4E6E5E5E692E1E5E5E3E4E3E4E4E5E5E4E5E6E4E7E6A1E7E6E6E6E6E7E6E6E5E3E5E4E5E3E6E6E5E6E6E6E6E5E4E5E5E6E5E6E6E6E7E5E5E5E4E6E5E3E4E3E3E4E4E5E5E5E5BEE5E5E4E4E6E4E6E7E4E6E8E5E7E6E7E4E6E5E6E4C5E6E7E7E7E7E8E7E8E7E6E6E7E7E5E4E5E4E4E4E4E3E6E3E4E3E6E6E8E7E7E6E4E5E7E6E6E8E5E5E7E7E4E5E6E7E6E5E7E7E3E4E6E5E8E1E7E5E7E3E6E6E5E5E4E6E8E6E7E8E5E5E4E4E85DE7E8E5E6E8E7E8E7E6E7E6E6E6E6E5E3E7E7E8E8E7E7E9E8E8E9E9E9E8EAE2E8E7E7E6E6E6E7E6E7E6E7E8E8E8E8E8E8E6E3E9EAE7EAE1E3E4E3E5E4E4E4E373E2E2E5E4E4E4E5E3E4E6B3E0E5E5E6E5E4E5E5C0E5E7E2E6E5689B9FE5E4E3E0E4E7E4E5E4E3E3E3E4E4E3E4E3E3E4E5E5E5E4E1E3E5E7E6E5E6E5E6E6E6E5E5E6E6E5E6E6E5E5E5E2E4E3E0E4E5E4E5E4E5E5E6E4E4E2E5E0E5E3E5E6E6E4E5E3E5E5E5E6E5E2E3E3E2E6E6E7E7E6E6E5E4E5E5C0E5E5E5E5E6E6E6E7E6E6E7E6E5E6E6E6E7E5E5E3E4E4E5E5E1E5E2E6E6E8E7E6E5E6E6E5E7E5E5E5E6E3E6E5E7E8E6E7E7E7E7E7E8E5E1E5E5E7E5E7E7E6E7E4E5E0E7E7E6E5E6E3E5E7E9E7E8E8E7E7E8E8E7E7E7E6E6E8E6E6E6E7E6E6E7E7E6E8E8E6E8E8E8E7E6E7E7E7E7E7E7E8E7E7E6E6E7000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000AB0000000001000001E6E6E6E6E9E8E8E8E8E8E7E6E4E4E3E5E2E3E4E1E6E6E5E0E5E6E5E4E8D0E7E8E4A1DE96AAE2E5E6E5E2E5E2E6E6E02B2F414CE4DFE1E4E5E5E5E6E4E4E3E4E5E5E5E5E4C7E7E5E5E4E4E2E4E6E7E7E6C7E5E5E596E1CDE5E4E4E5E4E6E5E1E4E6E6E8E8E6E4E4E5E7E7E4E5E4E5E4CBE5E6E7A8E7E5E6E5E6E7E7E7E5E5E7E5E6A1E3E6E7E5E6E3E4E6BEE7E7E5E5E5E6E3E6E5E6E6E6E5E6E6E1E8CDE1E4E5E6E4E3E3E5E7E7E6E5E5E6E4E4E3E4E5E5E8E7E7E6E6E7E6E8E5E7E7E6E6E6E6E7E7E7E5E6E7E7E9E7E6E8E6E4E5E7E8E6DDE5E6E6E8E7E7E8E8E8E8E6E7E5E4E9E8E8E8E7E7E8E5E7E7E7E7E6E7E8E6E7E7E6E9E8E6E6E4E7E7E7E6E6E6E6E5E9E7E7E8E7E8E7E7E8E8E8E9E1E3E3E3E3E5E3E5E5E5E4E4E7E7E7E7E5E5E5E6E5E5E4E4E7E7E6E72F43E4E2E8B533E771262831BEE5E6E3E5E44EE5E2E3DFDDE5E5E6E6E6E6E5E6E6E7E5E7E6E4E5E6E4E1E5E6E6E5E6E5E6E3E4E6E6D6E6E6E7E6E6E7E6E5E4E3E4E7E3E5E5E0E4E46FE6E2E7E7E6E51DE7E5E6E5E6E5E4E4E5E6E6E5E7E7E7E6E6E6E8E6E6E7E7E7E6E8E7E7E4E4E2C2E6E6E2E5E3E5E5E7E6E5E5E6E7E7E8E7E7E7E5E5E5E6E7E6E6E5E5E5E6E7E9E1E7E6E7E7E7E6E5E7E7E7E7E8E6E5E5E7E6E6E5E7E8E9E7E8E7E7E7E6E8E7E6E8E6E6E8E6E7E6E7E6E7E7E6E7E8E8E7E6E8E8E9E9E8E8E6E7E8E7E7E7E8E7E4E7E8E8E9E9E6E5E6E7000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000AD0000000001000001E6E5E6E6E9E7E7E8E8EAE9EAE8E6E5E6E3E2E3E4E2E3E5E3E2E5E6E4E5E300E6E6E6E0E6E7E2E6E3E1E4E0BCE8E5DEE7DDE6D44EE1E0E596A4E649E6E6DDE3A1E6E6E6E738E296B324E4E3A65D7AC2E5E7E7E5E6E5E2E4E3E5E5E4E4E5C0E5E6E5E5E673E4E5E4E5A1E6E6E8E5E4E6E4E6D2C7E2E4E5E5E6E4E8E3CDE1E6E5E1E3E3E2E4E5E5E6E1E5E56FE6E6E6E6E5E7E4E7E8E6E8E6E6E5E5E6E4E6E5E6E7E8E5E5E7E6E8E7E7E7E6E5E7E7E6E6E7E8E4E6E6E5E5E7E5E8E8E8E7E7E5E7E6E6E6E8E7E7E6E7E6E8E5E0E8E9E7E8E7E6E6E5E6E7E7E6E6E6E7E8E6E7E7E7E8E387E8E8E7E8E7E7E6E5E5E5E7E7E76DE6E6E6E7E7E8E7E7E7E4E7E7E6E6E5E5E8E7E8E8E7E7E6E6E8E8E7ACE4E4E2E3E3E4E3E4E7E6E6E5E7E6E5E6E6E4E5E5E7E6E6E8E7E5E6E6E5E6E6E7E5E5E6E6E7E7E7E6E7E1E7E5E6E7E6E7E7E7E468CDE5E3E4E7E2A6E0E3E6E3E6E0CDE7E7E5E5E6E475CDE5E5E7E7E6E7E5E1E5E4E6E5E6E5E8E7E5E2E6DBE4E7E8E7E6E5E5E4E5E4E7E6E7E8E5E5E6E2E6E6E6E7E6E6E8E6AFE7E6E7E7E8E9E5E6E5E5E6E9E8E8E8E6E5E7E7E9E8E7E7E6E8E8E2E6E6E7E7E6E6E7E8E8E9E9E8E6E6E6E6E9E8E8E8E7E9E8E9E7E8E8E8E6E7EBE8E8E8E6E7E7E7E6E7E7E6E6E7E9E5E7E8E7E8E7E7E8E7E6E7E7E8E7E8E7E8E7E7E8E7E8E7E9E9E9E8E6E6E6E6E8E7E7E7E7E8E9E7E8E6E6E7E8E8E6E7E6E5E6E6000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000AF0000000001000001E7E7E6E7E9E8E9E9E0E8E7E8E6E9E9E8E5E4E5E6E4E6E6E6E7E6E6E7E6E4E5E5E6E7E5E5E6E6E5E7E6E6E7E7E8E7E7E7E7E6E6E7E6E6E6E5E5E6E6E6E6E6E6E6E7E8E6E6E8E6E8E8E7E7E7E8E6E6E7E6E6E7E6A6E4E5E5E6E7E7E8E8E6E5E4E4E6E7E6E7E7E7E7E6EAE7E7E7E6E7E6E7E6E8E9E8EAE8E8E8E6E7E9E7E8E6E7E7E6E5E7E7E7E8E4E7E9E8E8E8E7E4E1E8E6E8E7E7E7E7E8E7E8E5E6E6E8E7E8E8E8E8E9E9E9E9E8E9E8E8E7E8E7E6E7E7E8E7E6E8E7E7E6E8E9E9E7E9E8E8E3E6E8E8E7E8E8E8E9E7E8E8E8E8E9E9E9E7E7E6E7E8E8E8E8E8E7E7E8E7E7E7E8E6E8E8E9E8E7E7E6E6E8E8E7E8E8E8E6E8EAEAE9EAE7E7E9E8E6E7E8E8E6E6E6E6E8E8E8E7E7E8E8E7EAE7E9E8E8E6E6E7E5E6E5E5E6E5E6E5E5E6E5E5E6E7E6E7E6E6E6E5E8E5E6E8E4E5E4E5E7E6E7E7E7E7E8E7E6E6E4E6E7E4E6E7E7E5E5E5E6E5E7E6E8E7E8E8E7E6E6E6E7E7E6E8E5E5E6E7E7E585E7E8E7E8E9E6E6E7E6E7E7E6E6E8E6E6A6E7E6E6E6E8E8E8E7E7E8E8E7E7E7E5E6E2E7E8E7E6E5E6E4E7E9E7E8E7E7E7E7E8E8E7E8E785E8E8E8E0E8E9E8E8E7E8E6E7E6E7E8E8E8E7E8E8E9E8E7E7E8E8E8E7E9E6E6E6E7E7E9E8E8E9E8E6E7E7E6E5E6E6E8E6E7E8E7E7E6E7E9E8E8E9E6E6E6E7E6E6E6E6E8E8E8E8E8E8E7E8E7E7E8E8E6E6E8E7E6E6E7E6E8E8E8E6E6E7E7E8E9E7E7E7E9E8E7E8D4E6E8E6EAE8E8E8E6E6E6E6000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000001000000B10000000001000001E6E6E6E6E8E7E8E9E9E8E7E8E5E8E8E8E6E4E5E5E6E5E6E5E7E7E8E8E1E5E4E5E7E6E7E7E5E6E5E6E6E741E5E7E6E8E8E6E5E6E5E8E6E7E8E5E6E5E6E93CE5E7E6E5E4E6E6E7E6E5E7E5E7E5E5E5E6E6E6E6E7E6E5E6E7E7E6E7E6E6E6E6E5E5E6E7E6E7E6E5E6E6E6E8E7E7E7E7E7E8E8E8E7E8E8E6E7E7E6E6E6E6E6E5E6E6E8E6E7E8E8E8E7E8E9E9E9E7E8E6E8E8E6E4E7E7E8E7E7E7E7E5E6E6E7E7E7E7E7E6E8E8E6E7E6B5E7E7E7E7E7E6E7E7E8E7E7E7E9E8E8E8E7E7E7E7E7E7E7E9E6E8E7E7E7E6E6E6E7E8E8E8E8E7E7E7E8E8EAE8E7E8E8E8E8E8E7E8E8E6E6E6E6E6E5E6E8E8E7E7E6E7E5E6E8E6E7E7E7E7E7E7E6E5E6E6E7E7E6E7E6E6E6E6E8E8E7E8E7E7E8E8EAE9E8E6E8E7E9E7E3E3E6E6E6E6E7E6E7E7E6E7E6E6E6E4E6E5E6E6E6E5E5E5E7E7E8E7E8E8E8E8E5E6E6E6E8E7E7E7E6E5E4E5E6E6E8E7E1E8E8E7E9E8E9E8E8E7E8E7E7E7E7E6E6E7E7E7E6E7E8E8E6E7E7E8E7E7E8E6E8E8E7E8E7E7E7E7C9E6E9E7E7E7E7E7E8E9E1EAE8E8E6E8E8E7E8E7E6E6E7E7E7E2E7E7EAE9E8E8E6E9E3E8E7E8E8E7E6E6E6E6E7E7E8E6E6E6E6E7E7E6E8E6E7E6E7E7E8E8E7E7E8E5E8E7E6E8E7E8E7E7E7E6E7E9E8EAE7E8E9E8E7E6E8E8E7E8E9E8E7E7E7E6EAE8E8E7E7E7E8E7E6E7E9E9E8E8E6E7E6E7E7E8E7E7E8E7E8E7E7E7E8E8E8E6E7E6E7E7E8E8E7E9E6E6E7E7E8E2E8E7E6E8E8E8E6E6E6E7000000 + USBDEVFS_REAPURBNDELAY 0 3 131 0 0 540 540 0 802100001C0200000000000000000000B30000000001000001E6E4E5E5E7E7E8E7E9E9E9E8E6E8E8E8E4E6E5B3E4E4E5E6E5E5E5E7E5E5E5E6E6E6E6E5E9E7E8E7E5E5E5E6E8E8E7E7E7E9E9E8E8E6E8E7E6E6E7E8E6E5E5E5E7E7E7E4E6E6E6E7E7E6E6E6E6E6E7E8E6E6E664E8E7E6E6E6E7E8D6E7E5E6E6E9E7E7E6E6E7E6E6E6DCE8E8E8E7E8E8E7E8E6E8E9E7E5E6E6E4E6E6E6E7E7E7E8E8E7E7E8E7E8E7EAE6E7E8E7E7E7E8E9EAE9E9E6E6E6E7E7E7EAE9E8E7E7E7E8E6E6E7E8E6E8E8E7E7E6E6E6E7E7E8E8E7E8E4E8E6E7E7E7E9E6E9E6E7E6E7E8E8E9E7E7E7E6E8E9E8E9E8E9E7E7E7E7E5E7E2E8E7E7E8E7E6E7E6E6E6E7E7E6E7E8E5E8E6E8E7E8E9E9E8E6E5E7E7E9E8E9E9E7E5E7E6E7E7E6E7E6E6E6E5E8E8E8E7E7E7E8E8EAEAEAEAE6E6E8E6E5E5E6E6E4E3E4E4E6E4E5E7E6E6E5E5E6E6E6E7E8E6E8E8E8E7E9E7E7E6E7E7E9E7E7E8E8E4E7E8E7E7E7E6E7E7E7E6E5E4E5E6E7E3E4E5E6E6E6E4E9E8E7E8E7E8E7E9E6E6E6E6E7E7E6E4E5E4E5E4E5E6E6E6E8E7E6E7E7E7E8E6E5E7E7E6E3E7E6E6E8E5E6E6E8E7E8E8E7E6E7E7E8E8E7E7E6E6E7E7E6E8E5E8E5E5E5E6E8E9EAE9E9E8E9E9E9E9E8E7E6E7E7E99BE5E6E6E8E8E0E7E9E9E8E8EAE7E9E9E9E8E8E8E7E7E5E8E9E7E6E8E6E7E7E8EAE9E7E8E9E9E9E8E7E7E6E7E8E8E6E7E7E7E7E7E6E7E7E7EAE6E6E8E6E6E6E5E8E8E8E8E7E8E7E7E5E6E7E6E8E8E6E7E5E6E6E5E8E8E7E9E8E8E8E8E6E6E5E6000000 diff --git a/tests/nb1010/capture.png b/tests/nb1010/capture.png new file mode 100644 index 0000000000000000000000000000000000000000..3acf305190548d33f98856e707728927eadf32a6 GIT binary patch literal 70982 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 OeC%wTtXq!|)BX>-EL?d2 literal 0 HcmV?d00001 diff --git a/tests/nb1010/device b/tests/nb1010/device new file mode 100644 index 0000000..672f8e8 --- /dev/null +++ b/tests/nb1010/device @@ -0,0 +1,301 @@ +P: /devices/pci0000:00/0000:00:01.3/0000:02:00.0/usb1/1-7 +N: bus/usb/001/003=12010002000000408D29101001000102000109022700010100A032090400000300000000070581034000050705020240000007058302400000 +E: DEVNAME=/dev/bus/usb/001/003 +E: DEVTYPE=usb_device +E: DRIVER=usb +E: PRODUCT=298d/1010/1 +E: TYPE=0/0/0 +E: BUSNUM=001 +E: DEVNUM=003 +E: MAJOR=189 +E: MINOR=2 +E: SUBSYSTEM=usb +E: ID_VENDOR=NEXT_Biometrics +E: ID_VENDOR_ENC=NEXT\x20Biometrics +E: ID_VENDOR_ID=298d +E: ID_MODEL=NB-1010-U +E: ID_MODEL_ENC=NB-1010-U +E: ID_MODEL_ID=1010 +E: ID_REVISION=0001 +E: ID_SERIAL=NEXT_Biometrics_NB-1010-U +E: ID_BUS=usb +E: ID_USB_INTERFACES=:000000: +E: ID_PATH=pci-0000:02:00.0-usb-0:7 +E: ID_PATH_TAG=pci-0000_02_00_0-usb-0_7 +A: authorized=1 +A: avoid_reset_quirk=0 +A: bConfigurationValue=1 +A: bDeviceClass=00 +A: bDeviceProtocol=00 +A: bDeviceSubClass=00 +A: bMaxPacketSize0=64 +A: bMaxPower=100mA +A: bNumConfigurations=1 +A: bNumInterfaces= 1 +A: bcdDevice=0001 +A: bmAttributes=a0 +A: busnum=1\n +A: configuration= +H: descriptors=12010002000000408D29101001000102000109022700010100A032090400000300000000070581034000050705020240000007058302400000 +A: dev=189:2 +A: devnum=3\n +A: devpath=7 +L: driver=../../../../../../bus/usb/drivers/usb +A: idProduct=1010 +A: idVendor=298d +A: ltm_capable=no +A: manufacturer=NEXT Biometrics +A: maxchild=0 +L: port=../1-0:1.0/usb1-port7 +A: power/active_duration=5192496 +A: power/async=enabled +A: power/autosuspend=2 +A: power/autosuspend_delay_ms=2000 +A: power/connected_duration=5192496 +A: power/control=on +A: power/level=on +A: power/persist=1 +A: power/runtime_active_kids=0 +A: power/runtime_active_time=5191944 +A: power/runtime_enabled=forbidden +A: power/runtime_status=active +A: power/runtime_suspended_time=0 +A: power/runtime_usage=1 +A: power/wakeup=disabled +A: power/wakeup_abort_count= +A: power/wakeup_active= +A: power/wakeup_active_count= +A: power/wakeup_count= +A: power/wakeup_expire_count= +A: power/wakeup_last_time_ms= +A: power/wakeup_max_time_ms= +A: power/wakeup_total_time_ms= +A: product=NB-1010-U +A: quirks=0x0 +A: removable=unknown +A: rx_lanes=1 +A: speed=12 +A: tx_lanes=1 +A: urbnum=4944 +A: version= 2.00 + +P: /devices/pci0000:00/0000:00:01.3/0000:02:00.0/usb1 +N: bus/usb/001/001=12010002090001406B1D020004050302010109021900010100E0000904000001090000000705810304000C +E: DEVNAME=/dev/bus/usb/001/001 +E: DEVTYPE=usb_device +E: DRIVER=usb +E: PRODUCT=1d6b/2/504 +E: TYPE=9/0/1 +E: BUSNUM=001 +E: DEVNUM=001 +E: MAJOR=189 +E: MINOR=0 +E: SUBSYSTEM=usb +E: ID_VENDOR=Linux_5.4.0-70-generic_xhci-hcd +E: ID_VENDOR_ENC=Linux\x205.4.0-70-generic\x20xhci-hcd +E: ID_VENDOR_ID=1d6b +E: ID_MODEL=xHCI_Host_Controller +E: ID_MODEL_ENC=xHCI\x20Host\x20Controller +E: ID_MODEL_ID=0002 +E: ID_REVISION=0504 +E: ID_SERIAL=Linux_5.4.0-70-generic_xhci-hcd_xHCI_Host_Controller_0000:02:00.0 +E: ID_SERIAL_SHORT=0000:02:00.0 +E: ID_BUS=usb +E: ID_USB_INTERFACES=:090000: +E: ID_VENDOR_FROM_DATABASE=Linux Foundation +E: ID_MODEL_FROM_DATABASE=2.0 root hub +E: ID_PATH=pci-0000:02:00.0 +E: ID_PATH_TAG=pci-0000_02_00_0 +E: ID_FOR_SEAT=usb-pci-0000_02_00_0 +E: TAGS=:seat: +A: authorized=1 +A: authorized_default=1 +A: avoid_reset_quirk=0 +A: bConfigurationValue=1 +A: bDeviceClass=09 +A: bDeviceProtocol=01 +A: bDeviceSubClass=00 +A: bMaxPacketSize0=64 +A: bMaxPower=0mA +A: bNumConfigurations=1 +A: bNumInterfaces= 1 +A: bcdDevice=0504 +A: bmAttributes=e0 +A: busnum=1\n +A: configuration= +H: descriptors=12010002090001406B1D020004050302010109021900010100E0000904000001090000000705810304000C +A: dev=189:0 +A: devnum=1\n +A: devpath=0 +L: driver=../../../../../bus/usb/drivers/usb +A: idProduct=0002 +A: idVendor=1d6b +A: interface_authorized_default=1 +A: ltm_capable=no +A: manufacturer=Linux 5.4.0-70-generic xhci-hcd +A: maxchild=10 +A: power/active_duration=5193368 +A: power/async=enabled +A: power/autosuspend=0 +A: power/autosuspend_delay_ms=0 +A: power/connected_duration=5193368 +A: power/control=auto +A: power/level=auto +A: power/runtime_active_kids=1 +A: power/runtime_active_time=5193313 +A: power/runtime_enabled=enabled +A: power/runtime_status=active +A: power/runtime_suspended_time=0 +A: power/runtime_usage=0 +A: power/wakeup=disabled +A: power/wakeup_abort_count= +A: power/wakeup_active= +A: power/wakeup_active_count= +A: power/wakeup_count= +A: power/wakeup_expire_count= +A: power/wakeup_last_time_ms= +A: power/wakeup_max_time_ms= +A: power/wakeup_total_time_ms= +A: product=xHCI Host Controller +A: quirks=0x0 +A: removable=unknown +A: rx_lanes=1 +A: serial=0000:02:00.0 +A: speed=480 +A: tx_lanes=1 +A: urbnum=60 +A: version= 2.00 + +P: /devices/pci0000:00/0000:00:01.3/0000:02:00.0 +E: DRIVER=xhci_hcd +E: PCI_CLASS=C0330 +E: PCI_ID=1022:43D5 +E: PCI_SUBSYS_ID=1B21:1142 +E: PCI_SLOT_NAME=0000:02:00.0 +E: MODALIAS=pci:v00001022d000043D5sv00001B21sd00001142bc0Csc03i30 +E: SUBSYSTEM=pci +E: ID_PCI_CLASS_FROM_DATABASE=Serial bus controller +E: ID_PCI_SUBCLASS_FROM_DATABASE=USB controller +E: ID_PCI_INTERFACE_FROM_DATABASE=XHCI +E: ID_VENDOR_FROM_DATABASE=Advanced Micro Devices, Inc. [AMD] +E: ID_MODEL_FROM_DATABASE=400 Series Chipset USB 3.1 XHCI Controller +A: aer_dev_correctable=RxErr 0\nBadTLP 0\nBadDLLP 0\nRollover 0\nTimeout 0\nNonFatalErr 0\nCorrIntErr 0\nHeaderOF 0\nTOTAL_ERR_COR 0 +A: aer_dev_fatal=Undefined 0\nDLP 0\nSDES 0\nTLP 0\nFCP 0\nCmpltTO 0\nCmpltAbrt 0\nUnxCmplt 0\nRxOF 0\nMalfTLP 0\nECRC 0\nUnsupReq 0\nACSViol 0\nUncorrIntErr 0\nBlockedTLP 0\nAtomicOpBlocked 0\nTLPBlockedErr 0\nTOTAL_ERR_FATAL 0 +A: aer_dev_nonfatal=Undefined 0\nDLP 0\nSDES 0\nTLP 0\nFCP 0\nCmpltTO 0\nCmpltAbrt 0\nUnxCmplt 0\nRxOF 0\nMalfTLP 0\nECRC 0\nUnsupReq 0\nACSViol 0\nUncorrIntErr 0\nBlockedTLP 0\nAtomicOpBlocked 0\nTLPBlockedErr 0\nTOTAL_ERR_NONFATAL 0 +A: ari_enabled=0 +A: broken_parity_status=0 +A: class=0x0c0330 +H: config=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 +A: consistent_dma_mask_bits=64 +A: current_link_speed=8 GT/s +A: current_link_width=4 +A: d3cold_allowed=1 +A: dbc=disabled +A: device=0x43d5 +A: dma_mask_bits=64 +L: driver=../../../../bus/pci/drivers/xhci_hcd +A: driver_override=(null) +A: enable=1 +A: irq=40 +A: link/l1_1_aspm=0 +A: link/l1_1_pcipm=0 +A: link/l1_aspm=0 +A: local_cpulist=0-11 +A: local_cpus=00000fff +A: max_link_speed=8 GT/s +A: max_link_width=4 +A: modalias=pci:v00001022d000043D5sv00001B21sd00001142bc0Csc03i30 +A: msi_bus=1 +A: msi_irqs/40=msi +A: numa_node=-1 +A: pools=poolinfo - 0.1\nbuffer-2048 0 0 2048 0\nbuffer-512 0 0 512 0\nbuffer-128 0 0 128 0\nbuffer-32 0 0 32 0\nxHCI 1KB stream ctx arrays 0 0 1024 0\nxHCI 256 byte stream ctx arrays 0 0 256 0\nxHCI input/output contexts 5 6 2112 6\nxHCI ring segments 22 26 4096 26\nbuffer-2048 0 0 2048 0\nbuffer-512 0 0 512 0\nbuffer-128 0 0 128 0\nbuffer-32 0 0 32 0 +A: power/async=enabled +A: power/control=on +A: power/runtime_active_kids=1 +A: power/runtime_active_time=5193487 +A: power/runtime_enabled=forbidden +A: power/runtime_status=active +A: power/runtime_suspended_time=0 +A: power/runtime_usage=1 +A: power/wakeup=enabled +A: power/wakeup_abort_count=0 +A: power/wakeup_active=0 +A: power/wakeup_active_count=0 +A: power/wakeup_count=0 +A: power/wakeup_expire_count=0 +A: power/wakeup_last_time_ms=0 +A: power/wakeup_max_time_ms=0 +A: power/wakeup_total_time_ms=0 +A: resource=0x00000000fc7a0000 0x00000000fc7a7fff 0x0000000000140204\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000 +A: revision=0x01 +A: subsystem_device=0x1142 +A: subsystem_vendor=0x1b21 +A: vendor=0x1022 + +P: /devices/pci0000:00/0000:00:01.3 +E: DRIVER=pcieport +E: PCI_CLASS=60400 +E: PCI_ID=1022:1483 +E: PCI_SUBSYS_ID=1022:1234 +E: PCI_SLOT_NAME=0000:00:01.3 +E: MODALIAS=pci:v00001022d00001483sv00001022sd00001234bc06sc04i00 +E: SUBSYSTEM=pci +E: ID_PCI_CLASS_FROM_DATABASE=Bridge +E: ID_PCI_SUBCLASS_FROM_DATABASE=PCI bridge +E: ID_PCI_INTERFACE_FROM_DATABASE=Normal decode +E: ID_VENDOR_FROM_DATABASE=Advanced Micro Devices, Inc. [AMD] +E: ID_MODEL_FROM_DATABASE=Starship/Matisse GPP Bridge +A: aer_dev_correctable=RxErr 0\nBadTLP 0\nBadDLLP 0\nRollover 0\nTimeout 0\nNonFatalErr 0\nCorrIntErr 0\nHeaderOF 0\nTOTAL_ERR_COR 0 +A: aer_dev_fatal=Undefined 0\nDLP 0\nSDES 0\nTLP 0\nFCP 0\nCmpltTO 0\nCmpltAbrt 0\nUnxCmplt 0\nRxOF 0\nMalfTLP 0\nECRC 0\nUnsupReq 0\nACSViol 0\nUncorrIntErr 0\nBlockedTLP 0\nAtomicOpBlocked 0\nTLPBlockedErr 0\nTOTAL_ERR_FATAL 0 +A: aer_dev_nonfatal=Undefined 0\nDLP 0\nSDES 0\nTLP 0\nFCP 0\nCmpltTO 0\nCmpltAbrt 0\nUnxCmplt 0\nRxOF 0\nMalfTLP 0\nECRC 0\nUnsupReq 0\nACSViol 0\nUncorrIntErr 0\nBlockedTLP 0\nAtomicOpBlocked 0\nTLPBlockedErr 0\nTOTAL_ERR_NONFATAL 0 +A: aer_rootport_total_err_cor=0 +A: aer_rootport_total_err_fatal=0 +A: aer_rootport_total_err_nonfatal=0 +A: ari_enabled=0 +A: broken_parity_status=0 +A: class=0x060400 +H: config=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 +A: consistent_dma_mask_bits=32 +A: current_link_speed=8 GT/s +A: current_link_width=4 +A: d3cold_allowed=1 +A: device=0x1483 +A: dma_mask_bits=32 +L: driver=../../../bus/pci/drivers/pcieport +A: driver_override=(null) +A: enable=2 +A: irq=26 +A: local_cpulist=0-11 +A: local_cpus=00000fff +A: max_link_speed=8 GT/s +A: max_link_width=8 +A: modalias=pci:v00001022d00001483sv00001022sd00001234bc06sc04i00 +A: msi_bus=1 +A: msi_irqs/26=msi +A: numa_node=-1 +A: power/async=enabled +A: power/autosuspend_delay_ms=100 +A: power/control=auto +A: power/runtime_active_kids=3 +A: power/runtime_active_time=5193496 +A: power/runtime_enabled=enabled +A: power/runtime_status=active +A: power/runtime_suspended_time=0 +A: power/runtime_usage=0 +A: power/wakeup=enabled +A: power/wakeup_abort_count=0 +A: power/wakeup_active=0 +A: power/wakeup_active_count=0 +A: power/wakeup_count=0 +A: power/wakeup_expire_count=0 +A: power/wakeup_last_time_ms=0 +A: power/wakeup_max_time_ms=0 +A: power/wakeup_total_time_ms=0 +A: resource=0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x000000000000f000 0x000000000000ffff 0x0000000000000101\n0x00000000fc500000 0x00000000fc7fffff 0x0000000000000200\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000 +A: revision=0x00 +A: secondary_bus_number=2 +A: subordinate_bus_number=9 +A: subsystem_device=0x1234 +A: subsystem_vendor=0x1022 +A: vendor=0x1022 +