From dc1bf93805491234cc0998d194aa5428af25b359 Mon Sep 17 00:00:00 2001 From: akiroz Date: Sun, 23 Jan 2022 08:28:12 +0800 Subject: [PATCH] init --- .gitignore | 10 + README.md | 11 + build.zig | 11 + include/libusb.h | 2113 ++++++++++++++++++++++++++++++++++++++++++++++ lib/COPYING | 504 +++++++++++ lib/libusb-1.0.a | Bin 0 -> 187480 bytes src/ini/LICENSE | 21 + src/ini/ini.zig | 324 +++++++ src/main.zig | 7 + 9 files changed, 3001 insertions(+) create mode 100644 .gitignore create mode 100644 README.md create mode 100644 build.zig create mode 100644 include/libusb.h create mode 100644 lib/COPYING create mode 100644 lib/libusb-1.0.a create mode 100644 src/ini/LICENSE create mode 100644 src/ini/ini.zig create mode 100644 src/main.zig diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..fd7f575 --- /dev/null +++ b/.gitignore @@ -0,0 +1,10 @@ +zig-cache/ +zig-out/ +/release/ +/debug/ +/build/ +/build-*/ +/docgen_tmp/ + +.DS_Store + diff --git a/README.md b/README.md new file mode 100644 index 0000000..46b29f8 --- /dev/null +++ b/README.md @@ -0,0 +1,11 @@ +## chuniio-tasoller + +chuniio driver for tasoller custom 2.0 firmware + +### Build + +``` +$ git clone ... +$ zig build +$ ls zig-out/lib/chuniio_tasoller.dll +``` diff --git a/build.zig b/build.zig new file mode 100644 index 0000000..bd5bde8 --- /dev/null +++ b/build.zig @@ -0,0 +1,11 @@ +const std = @import("std"); +const CrossTarget = std.zig.CrossTarget; + +pub fn build(b: *std.build.Builder) void { + const lib = b.addStaticLibrary("chuniio_tasoller", "src/main.zig"); + lib.setTarget(CrossTarget{ .os_tag = .windows, .cpu_arch = .i386, .abi = .msvc }); + lib.addIncludeDir("include"); + lib.addLibPath("lib"); + lib.linkSystemLibrary("usb"); + lib.install(); +} diff --git a/include/libusb.h b/include/libusb.h new file mode 100644 index 0000000..1308571 --- /dev/null +++ b/include/libusb.h @@ -0,0 +1,2113 @@ +/* + * Public libusb header file + * Copyright © 2001 Johannes Erdfelt + * Copyright © 2007-2008 Daniel Drake + * Copyright © 2012 Pete Batard + * Copyright © 2012-2018 Nathan Hjelm + * Copyright © 2014-2020 Chris Dickens + * For more information, please visit: http://libusb.info + * + * 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 + */ + +#ifndef LIBUSB_H +#define LIBUSB_H + +#if defined(_MSC_VER) +/* on MS environments, the inline keyword is available in C++ only */ +#if !defined(__cplusplus) +#define inline __inline +#endif +/* ssize_t is also not available */ +#include +typedef SSIZE_T ssize_t; +#endif /* _MSC_VER */ + +#include +#include +#include +#if !defined(_MSC_VER) +#include +#endif +#include + +#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) +#define ZERO_SIZED_ARRAY /* [] - valid C99 code */ +#else +#define ZERO_SIZED_ARRAY 0 /* [0] - non-standard, but usually working code */ +#endif /* __STDC_VERSION__ */ + +/* 'interface' might be defined as a macro on Windows, so we need to + * undefine it so as not to break the current libusb API, because + * libusb_config_descriptor has an 'interface' member + * As this can be problematic if you include windows.h after libusb.h + * in your sources, we force windows.h to be included first. */ +#if defined(_WIN32) || defined(__CYGWIN__) +#include +#if defined(interface) +#undef interface +#endif +#if !defined(__CYGWIN__) +#include +#endif +#endif /* _WIN32 || __CYGWIN__ */ + +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)) +#define LIBUSB_DEPRECATED_FOR(f) __attribute__ ((deprecated ("Use " #f " instead"))) +#elif defined(__GNUC__) && (__GNUC__ >= 3) +#define LIBUSB_DEPRECATED_FOR(f) __attribute__ ((deprecated)) +#else +#define LIBUSB_DEPRECATED_FOR(f) +#endif /* __GNUC__ */ + +#if defined(__GNUC__) +#define LIBUSB_PACKED __attribute__ ((packed)) +#else +#define LIBUSB_PACKED +#endif /* __GNUC__ */ + +/** \def LIBUSB_CALL + * \ingroup libusb_misc + * libusb's Windows calling convention. + * + * Under Windows, the selection of available compilers and configurations + * means that, unlike other platforms, there is not one true calling + * convention (calling convention: the manner in which parameters are + * passed to functions in the generated assembly code). + * + * Matching the Windows API itself, libusb uses the WINAPI convention (which + * translates to the stdcall convention) and guarantees that the + * library is compiled in this way. The public header file also includes + * appropriate annotations so that your own software will use the right + * convention, even if another convention is being used by default within + * your codebase. + * + * The one consideration that you must apply in your software is to mark + * all functions which you use as libusb callbacks with this LIBUSB_CALL + * annotation, so that they too get compiled for the correct calling + * convention. + * + * On non-Windows operating systems, this macro is defined as nothing. This + * means that you can apply it to your code without worrying about + * cross-platform compatibility. + */ +/* LIBUSB_CALL must be defined on both definition and declaration of libusb + * functions. You'd think that declaration would be enough, but cygwin will + * complain about conflicting types unless both are marked this way. + * The placement of this macro is important too; it must appear after the + * return type, before the function name. See internal documentation for + * API_EXPORTED. + */ +#if defined(_WIN32) || defined(__CYGWIN__) +#define LIBUSB_CALL WINAPI +#else +#define LIBUSB_CALL +#endif /* _WIN32 || __CYGWIN__ */ + +/** \def LIBUSB_API_VERSION + * \ingroup libusb_misc + * libusb's API version. + * + * Since version 1.0.13, to help with feature detection, libusb defines + * a LIBUSB_API_VERSION macro that gets increased every time there is a + * significant change to the API, such as the introduction of a new call, + * the definition of a new macro/enum member, or any other element that + * libusb applications may want to detect at compilation time. + * + * The macro is typically used in an application as follows: + * \code + * #if defined(LIBUSB_API_VERSION) && (LIBUSB_API_VERSION >= 0x01001234) + * // Use one of the newer features from the libusb API + * #endif + * \endcode + * + * Internally, LIBUSB_API_VERSION is defined as follows: + * (libusb major << 24) | (libusb minor << 16) | (16 bit incremental) + */ +#define LIBUSB_API_VERSION 0x01000108 + +/* The following is kept for compatibility, but will be deprecated in the future */ +#define LIBUSBX_API_VERSION LIBUSB_API_VERSION + +#if defined(__cplusplus) +extern "C" { +#endif + +/** + * \ingroup libusb_misc + * Convert a 16-bit value from host-endian to little-endian format. On + * little endian systems, this function does nothing. On big endian systems, + * the bytes are swapped. + * \param x the host-endian value to convert + * \returns the value in little-endian byte order + */ +static inline uint16_t libusb_cpu_to_le16(const uint16_t x) +{ + union { + uint8_t b8[2]; + uint16_t b16; + } _tmp; + _tmp.b8[1] = (uint8_t) (x >> 8); + _tmp.b8[0] = (uint8_t) (x & 0xff); + return _tmp.b16; +} + +/** \def libusb_le16_to_cpu + * \ingroup libusb_misc + * Convert a 16-bit value from little-endian to host-endian format. On + * little endian systems, this function does nothing. On big endian systems, + * the bytes are swapped. + * \param x the little-endian value to convert + * \returns the value in host-endian byte order + */ +#define libusb_le16_to_cpu libusb_cpu_to_le16 + +/* standard USB stuff */ + +/** \ingroup libusb_desc + * Device and/or Interface Class codes */ +enum libusb_class_code { + /** In the context of a \ref libusb_device_descriptor "device descriptor", + * this bDeviceClass value indicates that each interface specifies its + * own class information and all interfaces operate independently. + */ + LIBUSB_CLASS_PER_INTERFACE = 0x00, + + /** Audio class */ + LIBUSB_CLASS_AUDIO = 0x01, + + /** Communications class */ + LIBUSB_CLASS_COMM = 0x02, + + /** Human Interface Device class */ + LIBUSB_CLASS_HID = 0x03, + + /** Physical */ + LIBUSB_CLASS_PHYSICAL = 0x05, + + /** Image class */ + LIBUSB_CLASS_IMAGE = 0x06, + LIBUSB_CLASS_PTP = 0x06, /* legacy name from libusb-0.1 usb.h */ + + /** Printer class */ + LIBUSB_CLASS_PRINTER = 0x07, + + /** Mass storage class */ + LIBUSB_CLASS_MASS_STORAGE = 0x08, + + /** Hub class */ + LIBUSB_CLASS_HUB = 0x09, + + /** Data class */ + LIBUSB_CLASS_DATA = 0x0a, + + /** Smart Card */ + LIBUSB_CLASS_SMART_CARD = 0x0b, + + /** Content Security */ + LIBUSB_CLASS_CONTENT_SECURITY = 0x0d, + + /** Video */ + LIBUSB_CLASS_VIDEO = 0x0e, + + /** Personal Healthcare */ + LIBUSB_CLASS_PERSONAL_HEALTHCARE = 0x0f, + + /** Diagnostic Device */ + LIBUSB_CLASS_DIAGNOSTIC_DEVICE = 0xdc, + + /** Wireless class */ + LIBUSB_CLASS_WIRELESS = 0xe0, + + /** Miscellaneous class */ + LIBUSB_CLASS_MISCELLANEOUS = 0xef, + + /** Application class */ + LIBUSB_CLASS_APPLICATION = 0xfe, + + /** Class is vendor-specific */ + LIBUSB_CLASS_VENDOR_SPEC = 0xff +}; + +/** \ingroup libusb_desc + * Descriptor types as defined by the USB specification. */ +enum libusb_descriptor_type { + /** Device descriptor. See libusb_device_descriptor. */ + LIBUSB_DT_DEVICE = 0x01, + + /** Configuration descriptor. See libusb_config_descriptor. */ + LIBUSB_DT_CONFIG = 0x02, + + /** String descriptor */ + LIBUSB_DT_STRING = 0x03, + + /** Interface descriptor. See libusb_interface_descriptor. */ + LIBUSB_DT_INTERFACE = 0x04, + + /** Endpoint descriptor. See libusb_endpoint_descriptor. */ + LIBUSB_DT_ENDPOINT = 0x05, + + /** BOS descriptor */ + LIBUSB_DT_BOS = 0x0f, + + /** Device Capability descriptor */ + LIBUSB_DT_DEVICE_CAPABILITY = 0x10, + + /** HID descriptor */ + LIBUSB_DT_HID = 0x21, + + /** HID report descriptor */ + LIBUSB_DT_REPORT = 0x22, + + /** Physical descriptor */ + LIBUSB_DT_PHYSICAL = 0x23, + + /** Hub descriptor */ + LIBUSB_DT_HUB = 0x29, + + /** SuperSpeed Hub descriptor */ + LIBUSB_DT_SUPERSPEED_HUB = 0x2a, + + /** SuperSpeed Endpoint Companion descriptor */ + LIBUSB_DT_SS_ENDPOINT_COMPANION = 0x30 +}; + +/* Descriptor sizes per descriptor type */ +#define LIBUSB_DT_DEVICE_SIZE 18 +#define LIBUSB_DT_CONFIG_SIZE 9 +#define LIBUSB_DT_INTERFACE_SIZE 9 +#define LIBUSB_DT_ENDPOINT_SIZE 7 +#define LIBUSB_DT_ENDPOINT_AUDIO_SIZE 9 /* Audio extension */ +#define LIBUSB_DT_HUB_NONVAR_SIZE 7 +#define LIBUSB_DT_SS_ENDPOINT_COMPANION_SIZE 6 +#define LIBUSB_DT_BOS_SIZE 5 +#define LIBUSB_DT_DEVICE_CAPABILITY_SIZE 3 + +/* BOS descriptor sizes */ +#define LIBUSB_BT_USB_2_0_EXTENSION_SIZE 7 +#define LIBUSB_BT_SS_USB_DEVICE_CAPABILITY_SIZE 10 +#define LIBUSB_BT_CONTAINER_ID_SIZE 20 + +/* We unwrap the BOS => define its max size */ +#define LIBUSB_DT_BOS_MAX_SIZE \ + (LIBUSB_DT_BOS_SIZE + \ + LIBUSB_BT_USB_2_0_EXTENSION_SIZE + \ + LIBUSB_BT_SS_USB_DEVICE_CAPABILITY_SIZE + \ + LIBUSB_BT_CONTAINER_ID_SIZE) + +#define LIBUSB_ENDPOINT_ADDRESS_MASK 0x0f /* in bEndpointAddress */ +#define LIBUSB_ENDPOINT_DIR_MASK 0x80 + +/** \ingroup libusb_desc + * Endpoint direction. Values for bit 7 of the + * \ref libusb_endpoint_descriptor::bEndpointAddress "endpoint address" scheme. + */ +enum libusb_endpoint_direction { + /** Out: host-to-device */ + LIBUSB_ENDPOINT_OUT = 0x00, + + /** In: device-to-host */ + LIBUSB_ENDPOINT_IN = 0x80 +}; + +#define LIBUSB_TRANSFER_TYPE_MASK 0x03 /* in bmAttributes */ + +/** \ingroup libusb_desc + * Endpoint transfer type. Values for bits 0:1 of the + * \ref libusb_endpoint_descriptor::bmAttributes "endpoint attributes" field. + */ +enum libusb_endpoint_transfer_type { + /** Control endpoint */ + LIBUSB_ENDPOINT_TRANSFER_TYPE_CONTROL = 0x0, + + /** Isochronous endpoint */ + LIBUSB_ENDPOINT_TRANSFER_TYPE_ISOCHRONOUS = 0x1, + + /** Bulk endpoint */ + LIBUSB_ENDPOINT_TRANSFER_TYPE_BULK = 0x2, + + /** Interrupt endpoint */ + LIBUSB_ENDPOINT_TRANSFER_TYPE_INTERRUPT = 0x3 +}; + +/** \ingroup libusb_misc + * Standard requests, as defined in table 9-5 of the USB 3.0 specifications */ +enum libusb_standard_request { + /** Request status of the specific recipient */ + LIBUSB_REQUEST_GET_STATUS = 0x00, + + /** Clear or disable a specific feature */ + LIBUSB_REQUEST_CLEAR_FEATURE = 0x01, + + /* 0x02 is reserved */ + + /** Set or enable a specific feature */ + LIBUSB_REQUEST_SET_FEATURE = 0x03, + + /* 0x04 is reserved */ + + /** Set device address for all future accesses */ + LIBUSB_REQUEST_SET_ADDRESS = 0x05, + + /** Get the specified descriptor */ + LIBUSB_REQUEST_GET_DESCRIPTOR = 0x06, + + /** Used to update existing descriptors or add new descriptors */ + LIBUSB_REQUEST_SET_DESCRIPTOR = 0x07, + + /** Get the current device configuration value */ + LIBUSB_REQUEST_GET_CONFIGURATION = 0x08, + + /** Set device configuration */ + LIBUSB_REQUEST_SET_CONFIGURATION = 0x09, + + /** Return the selected alternate setting for the specified interface */ + LIBUSB_REQUEST_GET_INTERFACE = 0x0a, + + /** Select an alternate interface for the specified interface */ + LIBUSB_REQUEST_SET_INTERFACE = 0x0b, + + /** Set then report an endpoint's synchronization frame */ + LIBUSB_REQUEST_SYNCH_FRAME = 0x0c, + + /** Sets both the U1 and U2 Exit Latency */ + LIBUSB_REQUEST_SET_SEL = 0x30, + + /** Delay from the time a host transmits a packet to the time it is + * received by the device. */ + LIBUSB_SET_ISOCH_DELAY = 0x31 +}; + +/** \ingroup libusb_misc + * Request type bits of the + * \ref libusb_control_setup::bmRequestType "bmRequestType" field in control + * transfers. */ +enum libusb_request_type { + /** Standard */ + LIBUSB_REQUEST_TYPE_STANDARD = (0x00 << 5), + + /** Class */ + LIBUSB_REQUEST_TYPE_CLASS = (0x01 << 5), + + /** Vendor */ + LIBUSB_REQUEST_TYPE_VENDOR = (0x02 << 5), + + /** Reserved */ + LIBUSB_REQUEST_TYPE_RESERVED = (0x03 << 5) +}; + +/** \ingroup libusb_misc + * Recipient bits of the + * \ref libusb_control_setup::bmRequestType "bmRequestType" field in control + * transfers. Values 4 through 31 are reserved. */ +enum libusb_request_recipient { + /** Device */ + LIBUSB_RECIPIENT_DEVICE = 0x00, + + /** Interface */ + LIBUSB_RECIPIENT_INTERFACE = 0x01, + + /** Endpoint */ + LIBUSB_RECIPIENT_ENDPOINT = 0x02, + + /** Other */ + LIBUSB_RECIPIENT_OTHER = 0x03 +}; + +#define LIBUSB_ISO_SYNC_TYPE_MASK 0x0c + +/** \ingroup libusb_desc + * Synchronization type for isochronous endpoints. Values for bits 2:3 of the + * \ref libusb_endpoint_descriptor::bmAttributes "bmAttributes" field in + * libusb_endpoint_descriptor. + */ +enum libusb_iso_sync_type { + /** No synchronization */ + LIBUSB_ISO_SYNC_TYPE_NONE = 0x0, + + /** Asynchronous */ + LIBUSB_ISO_SYNC_TYPE_ASYNC = 0x1, + + /** Adaptive */ + LIBUSB_ISO_SYNC_TYPE_ADAPTIVE = 0x2, + + /** Synchronous */ + LIBUSB_ISO_SYNC_TYPE_SYNC = 0x3 +}; + +#define LIBUSB_ISO_USAGE_TYPE_MASK 0x30 + +/** \ingroup libusb_desc + * Usage type for isochronous endpoints. Values for bits 4:5 of the + * \ref libusb_endpoint_descriptor::bmAttributes "bmAttributes" field in + * libusb_endpoint_descriptor. + */ +enum libusb_iso_usage_type { + /** Data endpoint */ + LIBUSB_ISO_USAGE_TYPE_DATA = 0x0, + + /** Feedback endpoint */ + LIBUSB_ISO_USAGE_TYPE_FEEDBACK = 0x1, + + /** Implicit feedback Data endpoint */ + LIBUSB_ISO_USAGE_TYPE_IMPLICIT = 0x2 +}; + +/** \ingroup libusb_desc + * Supported speeds (wSpeedSupported) bitfield. Indicates what + * speeds the device supports. + */ +enum libusb_supported_speed { + /** Low speed operation supported (1.5MBit/s). */ + LIBUSB_LOW_SPEED_OPERATION = (1 << 0), + + /** Full speed operation supported (12MBit/s). */ + LIBUSB_FULL_SPEED_OPERATION = (1 << 1), + + /** High speed operation supported (480MBit/s). */ + LIBUSB_HIGH_SPEED_OPERATION = (1 << 2), + + /** Superspeed operation supported (5000MBit/s). */ + LIBUSB_SUPER_SPEED_OPERATION = (1 << 3) +}; + +/** \ingroup libusb_desc + * Masks for the bits of the + * \ref libusb_usb_2_0_extension_descriptor::bmAttributes "bmAttributes" field + * of the USB 2.0 Extension descriptor. + */ +enum libusb_usb_2_0_extension_attributes { + /** Supports Link Power Management (LPM) */ + LIBUSB_BM_LPM_SUPPORT = (1 << 1) +}; + +/** \ingroup libusb_desc + * Masks for the bits of the + * \ref libusb_ss_usb_device_capability_descriptor::bmAttributes "bmAttributes" field + * field of the SuperSpeed USB Device Capability descriptor. + */ +enum libusb_ss_usb_device_capability_attributes { + /** Supports Latency Tolerance Messages (LTM) */ + LIBUSB_BM_LTM_SUPPORT = (1 << 1) +}; + +/** \ingroup libusb_desc + * USB capability types + */ +enum libusb_bos_type { + /** Wireless USB device capability */ + LIBUSB_BT_WIRELESS_USB_DEVICE_CAPABILITY = 0x01, + + /** USB 2.0 extensions */ + LIBUSB_BT_USB_2_0_EXTENSION = 0x02, + + /** SuperSpeed USB device capability */ + LIBUSB_BT_SS_USB_DEVICE_CAPABILITY = 0x03, + + /** Container ID type */ + LIBUSB_BT_CONTAINER_ID = 0x04 +}; + +/** \ingroup libusb_desc + * A structure representing the standard USB device descriptor. This + * descriptor is documented in section 9.6.1 of the USB 3.0 specification. + * All multiple-byte fields are represented in host-endian format. + */ +struct libusb_device_descriptor { + /** Size of this descriptor (in bytes) */ + uint8_t bLength; + + /** Descriptor type. Will have value + * \ref libusb_descriptor_type::LIBUSB_DT_DEVICE LIBUSB_DT_DEVICE in this + * context. */ + uint8_t bDescriptorType; + + /** USB specification release number in binary-coded decimal. A value of + * 0x0200 indicates USB 2.0, 0x0110 indicates USB 1.1, etc. */ + uint16_t bcdUSB; + + /** USB-IF class code for the device. See \ref libusb_class_code. */ + uint8_t bDeviceClass; + + /** USB-IF subclass code for the device, qualified by the bDeviceClass + * value */ + uint8_t bDeviceSubClass; + + /** USB-IF protocol code for the device, qualified by the bDeviceClass and + * bDeviceSubClass values */ + uint8_t bDeviceProtocol; + + /** Maximum packet size for endpoint 0 */ + uint8_t bMaxPacketSize0; + + /** USB-IF vendor ID */ + uint16_t idVendor; + + /** USB-IF product ID */ + uint16_t idProduct; + + /** Device release number in binary-coded decimal */ + uint16_t bcdDevice; + + /** Index of string descriptor describing manufacturer */ + uint8_t iManufacturer; + + /** Index of string descriptor describing product */ + uint8_t iProduct; + + /** Index of string descriptor containing device serial number */ + uint8_t iSerialNumber; + + /** Number of possible configurations */ + uint8_t bNumConfigurations; +}; + +/** \ingroup libusb_desc + * A structure representing the standard USB endpoint descriptor. This + * descriptor is documented in section 9.6.6 of the USB 3.0 specification. + * All multiple-byte fields are represented in host-endian format. + */ +struct libusb_endpoint_descriptor { + /** Size of this descriptor (in bytes) */ + uint8_t bLength; + + /** Descriptor type. Will have value + * \ref libusb_descriptor_type::LIBUSB_DT_ENDPOINT LIBUSB_DT_ENDPOINT in + * this context. */ + uint8_t bDescriptorType; + + /** The address of the endpoint described by this descriptor. Bits 0:3 are + * the endpoint number. Bits 4:6 are reserved. Bit 7 indicates direction, + * see \ref libusb_endpoint_direction. */ + uint8_t bEndpointAddress; + + /** Attributes which apply to the endpoint when it is configured using + * the bConfigurationValue. Bits 0:1 determine the transfer type and + * correspond to \ref libusb_endpoint_transfer_type. Bits 2:3 are only used + * for isochronous endpoints and correspond to \ref libusb_iso_sync_type. + * Bits 4:5 are also only used for isochronous endpoints and correspond to + * \ref libusb_iso_usage_type. Bits 6:7 are reserved. */ + uint8_t bmAttributes; + + /** Maximum packet size this endpoint is capable of sending/receiving. */ + uint16_t wMaxPacketSize; + + /** Interval for polling endpoint for data transfers. */ + uint8_t bInterval; + + /** For audio devices only: the rate at which synchronization feedback + * is provided. */ + uint8_t bRefresh; + + /** For audio devices only: the address if the synch endpoint */ + uint8_t bSynchAddress; + + /** Extra descriptors. If libusb encounters unknown endpoint descriptors, + * it will store them here, should you wish to parse them. */ + const unsigned char *extra; + + /** Length of the extra descriptors, in bytes. Must be non-negative. */ + int extra_length; +}; + +/** \ingroup libusb_desc + * A structure representing the standard USB interface descriptor. This + * descriptor is documented in section 9.6.5 of the USB 3.0 specification. + * All multiple-byte fields are represented in host-endian format. + */ +struct libusb_interface_descriptor { + /** Size of this descriptor (in bytes) */ + uint8_t bLength; + + /** Descriptor type. Will have value + * \ref libusb_descriptor_type::LIBUSB_DT_INTERFACE LIBUSB_DT_INTERFACE + * in this context. */ + uint8_t bDescriptorType; + + /** Number of this interface */ + uint8_t bInterfaceNumber; + + /** Value used to select this alternate setting for this interface */ + uint8_t bAlternateSetting; + + /** Number of endpoints used by this interface (excluding the control + * endpoint). */ + uint8_t bNumEndpoints; + + /** USB-IF class code for this interface. See \ref libusb_class_code. */ + uint8_t bInterfaceClass; + + /** USB-IF subclass code for this interface, qualified by the + * bInterfaceClass value */ + uint8_t bInterfaceSubClass; + + /** USB-IF protocol code for this interface, qualified by the + * bInterfaceClass and bInterfaceSubClass values */ + uint8_t bInterfaceProtocol; + + /** Index of string descriptor describing this interface */ + uint8_t iInterface; + + /** Array of endpoint descriptors. This length of this array is determined + * by the bNumEndpoints field. */ + const struct libusb_endpoint_descriptor *endpoint; + + /** Extra descriptors. If libusb encounters unknown interface descriptors, + * it will store them here, should you wish to parse them. */ + const unsigned char *extra; + + /** Length of the extra descriptors, in bytes. Must be non-negative. */ + int extra_length; +}; + +/** \ingroup libusb_desc + * A collection of alternate settings for a particular USB interface. + */ +struct libusb_interface { + /** Array of interface descriptors. The length of this array is determined + * by the num_altsetting field. */ + const struct libusb_interface_descriptor *altsetting; + + /** The number of alternate settings that belong to this interface. + * Must be non-negative. */ + int num_altsetting; +}; + +/** \ingroup libusb_desc + * A structure representing the standard USB configuration descriptor. This + * descriptor is documented in section 9.6.3 of the USB 3.0 specification. + * All multiple-byte fields are represented in host-endian format. + */ +struct libusb_config_descriptor { + /** Size of this descriptor (in bytes) */ + uint8_t bLength; + + /** Descriptor type. Will have value + * \ref libusb_descriptor_type::LIBUSB_DT_CONFIG LIBUSB_DT_CONFIG + * in this context. */ + uint8_t bDescriptorType; + + /** Total length of data returned for this configuration */ + uint16_t wTotalLength; + + /** Number of interfaces supported by this configuration */ + uint8_t bNumInterfaces; + + /** Identifier value for this configuration */ + uint8_t bConfigurationValue; + + /** Index of string descriptor describing this configuration */ + uint8_t iConfiguration; + + /** Configuration characteristics */ + uint8_t bmAttributes; + + /** Maximum power consumption of the USB device from this bus in this + * configuration when the device is fully operation. Expressed in units + * of 2 mA when the device is operating in high-speed mode and in units + * of 8 mA when the device is operating in super-speed mode. */ + uint8_t MaxPower; + + /** Array of interfaces supported by this configuration. The length of + * this array is determined by the bNumInterfaces field. */ + const struct libusb_interface *interface; + + /** Extra descriptors. If libusb encounters unknown configuration + * descriptors, it will store them here, should you wish to parse them. */ + const unsigned char *extra; + + /** Length of the extra descriptors, in bytes. Must be non-negative. */ + int extra_length; +}; + +/** \ingroup libusb_desc + * A structure representing the superspeed endpoint companion + * descriptor. This descriptor is documented in section 9.6.7 of + * the USB 3.0 specification. All multiple-byte fields are represented in + * host-endian format. + */ +struct libusb_ss_endpoint_companion_descriptor { + /** Size of this descriptor (in bytes) */ + uint8_t bLength; + + /** Descriptor type. Will have value + * \ref libusb_descriptor_type::LIBUSB_DT_SS_ENDPOINT_COMPANION in + * this context. */ + uint8_t bDescriptorType; + + /** The maximum number of packets the endpoint can send or + * receive as part of a burst. */ + uint8_t bMaxBurst; + + /** In bulk EP: bits 4:0 represents the maximum number of + * streams the EP supports. In isochronous EP: bits 1:0 + * represents the Mult - a zero based value that determines + * the maximum number of packets within a service interval */ + uint8_t bmAttributes; + + /** The total number of bytes this EP will transfer every + * service interval. Valid only for periodic EPs. */ + uint16_t wBytesPerInterval; +}; + +/** \ingroup libusb_desc + * A generic representation of a BOS Device Capability descriptor. It is + * advised to check bDevCapabilityType and call the matching + * libusb_get_*_descriptor function to get a structure fully matching the type. + */ +struct libusb_bos_dev_capability_descriptor { + /** Size of this descriptor (in bytes) */ + uint8_t bLength; + + /** Descriptor type. Will have value + * \ref libusb_descriptor_type::LIBUSB_DT_DEVICE_CAPABILITY + * LIBUSB_DT_DEVICE_CAPABILITY in this context. */ + uint8_t bDescriptorType; + + /** Device Capability type */ + uint8_t bDevCapabilityType; + + /** Device Capability data (bLength - 3 bytes) */ + uint8_t dev_capability_data[ZERO_SIZED_ARRAY]; +}; + +/** \ingroup libusb_desc + * A structure representing the Binary Device Object Store (BOS) descriptor. + * This descriptor is documented in section 9.6.2 of the USB 3.0 specification. + * All multiple-byte fields are represented in host-endian format. + */ +struct libusb_bos_descriptor { + /** Size of this descriptor (in bytes) */ + uint8_t bLength; + + /** Descriptor type. Will have value + * \ref libusb_descriptor_type::LIBUSB_DT_BOS LIBUSB_DT_BOS + * in this context. */ + uint8_t bDescriptorType; + + /** Length of this descriptor and all of its sub descriptors */ + uint16_t wTotalLength; + + /** The number of separate device capability descriptors in + * the BOS */ + uint8_t bNumDeviceCaps; + + /** bNumDeviceCap Device Capability Descriptors */ + struct libusb_bos_dev_capability_descriptor *dev_capability[ZERO_SIZED_ARRAY]; +}; + +/** \ingroup libusb_desc + * A structure representing the USB 2.0 Extension descriptor + * This descriptor is documented in section 9.6.2.1 of the USB 3.0 specification. + * All multiple-byte fields are represented in host-endian format. + */ +struct libusb_usb_2_0_extension_descriptor { + /** Size of this descriptor (in bytes) */ + uint8_t bLength; + + /** Descriptor type. Will have value + * \ref libusb_descriptor_type::LIBUSB_DT_DEVICE_CAPABILITY + * LIBUSB_DT_DEVICE_CAPABILITY in this context. */ + uint8_t bDescriptorType; + + /** Capability type. Will have value + * \ref libusb_capability_type::LIBUSB_BT_USB_2_0_EXTENSION + * LIBUSB_BT_USB_2_0_EXTENSION in this context. */ + uint8_t bDevCapabilityType; + + /** Bitmap encoding of supported device level features. + * A value of one in a bit location indicates a feature is + * supported; a value of zero indicates it is not supported. + * See \ref libusb_usb_2_0_extension_attributes. */ + uint32_t bmAttributes; +}; + +/** \ingroup libusb_desc + * A structure representing the SuperSpeed USB Device Capability descriptor + * This descriptor is documented in section 9.6.2.2 of the USB 3.0 specification. + * All multiple-byte fields are represented in host-endian format. + */ +struct libusb_ss_usb_device_capability_descriptor { + /** Size of this descriptor (in bytes) */ + uint8_t bLength; + + /** Descriptor type. Will have value + * \ref libusb_descriptor_type::LIBUSB_DT_DEVICE_CAPABILITY + * LIBUSB_DT_DEVICE_CAPABILITY in this context. */ + uint8_t bDescriptorType; + + /** Capability type. Will have value + * \ref libusb_capability_type::LIBUSB_BT_SS_USB_DEVICE_CAPABILITY + * LIBUSB_BT_SS_USB_DEVICE_CAPABILITY in this context. */ + uint8_t bDevCapabilityType; + + /** Bitmap encoding of supported device level features. + * A value of one in a bit location indicates a feature is + * supported; a value of zero indicates it is not supported. + * See \ref libusb_ss_usb_device_capability_attributes. */ + uint8_t bmAttributes; + + /** Bitmap encoding of the speed supported by this device when + * operating in SuperSpeed mode. See \ref libusb_supported_speed. */ + uint16_t wSpeedSupported; + + /** The lowest speed at which all the functionality supported + * by the device is available to the user. For example if the + * device supports all its functionality when connected at + * full speed and above then it sets this value to 1. */ + uint8_t bFunctionalitySupport; + + /** U1 Device Exit Latency. */ + uint8_t bU1DevExitLat; + + /** U2 Device Exit Latency. */ + uint16_t bU2DevExitLat; +}; + +/** \ingroup libusb_desc + * A structure representing the Container ID descriptor. + * This descriptor is documented in section 9.6.2.3 of the USB 3.0 specification. + * All multiple-byte fields, except UUIDs, are represented in host-endian format. + */ +struct libusb_container_id_descriptor { + /** Size of this descriptor (in bytes) */ + uint8_t bLength; + + /** Descriptor type. Will have value + * \ref libusb_descriptor_type::LIBUSB_DT_DEVICE_CAPABILITY + * LIBUSB_DT_DEVICE_CAPABILITY in this context. */ + uint8_t bDescriptorType; + + /** Capability type. Will have value + * \ref libusb_capability_type::LIBUSB_BT_CONTAINER_ID + * LIBUSB_BT_CONTAINER_ID in this context. */ + uint8_t bDevCapabilityType; + + /** Reserved field */ + uint8_t bReserved; + + /** 128 bit UUID */ + uint8_t ContainerID[16]; +}; + +/** \ingroup libusb_asyncio + * Setup packet for control transfers. */ +#if defined(_MSC_VER) +#pragma pack(push, 1) +#endif +struct libusb_control_setup { + /** Request type. Bits 0:4 determine recipient, see + * \ref libusb_request_recipient. Bits 5:6 determine type, see + * \ref libusb_request_type. Bit 7 determines data transfer direction, see + * \ref libusb_endpoint_direction. + */ + uint8_t bmRequestType; + + /** Request. If the type bits of bmRequestType are equal to + * \ref libusb_request_type::LIBUSB_REQUEST_TYPE_STANDARD + * "LIBUSB_REQUEST_TYPE_STANDARD" then this field refers to + * \ref libusb_standard_request. For other cases, use of this field is + * application-specific. */ + uint8_t bRequest; + + /** Value. Varies according to request */ + uint16_t wValue; + + /** Index. Varies according to request, typically used to pass an index + * or offset */ + uint16_t wIndex; + + /** Number of bytes to transfer */ + uint16_t wLength; +} LIBUSB_PACKED; +#if defined(_MSC_VER) +#pragma pack(pop) +#endif + +#define LIBUSB_CONTROL_SETUP_SIZE (sizeof(struct libusb_control_setup)) + +/* libusb */ + +struct libusb_context; +struct libusb_device; +struct libusb_device_handle; + +/** \ingroup libusb_lib + * Structure providing the version of the libusb runtime + */ +struct libusb_version { + /** Library major version. */ + const uint16_t major; + + /** Library minor version. */ + const uint16_t minor; + + /** Library micro version. */ + const uint16_t micro; + + /** Library nano version. */ + const uint16_t nano; + + /** Library release candidate suffix string, e.g. "-rc4". */ + const char *rc; + + /** For ABI compatibility only. */ + const char *describe; +}; + +/** \ingroup libusb_lib + * Structure representing a libusb session. The concept of individual libusb + * sessions allows for your program to use two libraries (or dynamically + * load two modules) which both independently use libusb. This will prevent + * interference between the individual libusb users - for example + * libusb_set_option() will not affect the other user of the library, and + * libusb_exit() will not destroy resources that the other user is still + * using. + * + * Sessions are created by libusb_init() and destroyed through libusb_exit(). + * If your application is guaranteed to only ever include a single libusb + * user (i.e. you), you do not have to worry about contexts: pass NULL in + * every function call where a context is required. The default context + * will be used. + * + * For more information, see \ref libusb_contexts. + */ +typedef struct libusb_context libusb_context; + +/** \ingroup libusb_dev + * Structure representing a USB device detected on the system. This is an + * opaque type for which you are only ever provided with a pointer, usually + * originating from libusb_get_device_list(). + * + * Certain operations can be performed on a device, but in order to do any + * I/O you will have to first obtain a device handle using libusb_open(). + * + * Devices are reference counted with libusb_ref_device() and + * libusb_unref_device(), and are freed when the reference count reaches 0. + * New devices presented by libusb_get_device_list() have a reference count of + * 1, and libusb_free_device_list() can optionally decrease the reference count + * on all devices in the list. libusb_open() adds another reference which is + * later destroyed by libusb_close(). + */ +typedef struct libusb_device libusb_device; + + +/** \ingroup libusb_dev + * Structure representing a handle on a USB device. This is an opaque type for + * which you are only ever provided with a pointer, usually originating from + * libusb_open(). + * + * A device handle is used to perform I/O and other operations. When finished + * with a device handle, you should call libusb_close(). + */ +typedef struct libusb_device_handle libusb_device_handle; + +/** \ingroup libusb_dev + * Speed codes. Indicates the speed at which the device is operating. + */ +enum libusb_speed { + /** The OS doesn't report or know the device speed. */ + LIBUSB_SPEED_UNKNOWN = 0, + + /** The device is operating at low speed (1.5MBit/s). */ + LIBUSB_SPEED_LOW = 1, + + /** The device is operating at full speed (12MBit/s). */ + LIBUSB_SPEED_FULL = 2, + + /** The device is operating at high speed (480MBit/s). */ + LIBUSB_SPEED_HIGH = 3, + + /** The device is operating at super speed (5000MBit/s). */ + LIBUSB_SPEED_SUPER = 4, + + /** The device is operating at super speed plus (10000MBit/s). */ + LIBUSB_SPEED_SUPER_PLUS = 5 +}; + +/** \ingroup libusb_misc + * Error codes. Most libusb functions return 0 on success or one of these + * codes on failure. + * You can call libusb_error_name() to retrieve a string representation of an + * error code or libusb_strerror() to get an end-user suitable description of + * an error code. + */ +enum libusb_error { + /** Success (no error) */ + LIBUSB_SUCCESS = 0, + + /** Input/output error */ + LIBUSB_ERROR_IO = -1, + + /** Invalid parameter */ + LIBUSB_ERROR_INVALID_PARAM = -2, + + /** Access denied (insufficient permissions) */ + LIBUSB_ERROR_ACCESS = -3, + + /** No such device (it may have been disconnected) */ + LIBUSB_ERROR_NO_DEVICE = -4, + + /** Entity not found */ + LIBUSB_ERROR_NOT_FOUND = -5, + + /** Resource busy */ + LIBUSB_ERROR_BUSY = -6, + + /** Operation timed out */ + LIBUSB_ERROR_TIMEOUT = -7, + + /** Overflow */ + LIBUSB_ERROR_OVERFLOW = -8, + + /** Pipe error */ + LIBUSB_ERROR_PIPE = -9, + + /** System call interrupted (perhaps due to signal) */ + LIBUSB_ERROR_INTERRUPTED = -10, + + /** Insufficient memory */ + LIBUSB_ERROR_NO_MEM = -11, + + /** Operation not supported or unimplemented on this platform */ + LIBUSB_ERROR_NOT_SUPPORTED = -12, + + /* NB: Remember to update LIBUSB_ERROR_COUNT below as well as the + message strings in strerror.c when adding new error codes here. */ + + /** Other error */ + LIBUSB_ERROR_OTHER = -99 +}; + +/* Total number of error codes in enum libusb_error */ +#define LIBUSB_ERROR_COUNT 14 + +/** \ingroup libusb_asyncio + * Transfer type */ +enum libusb_transfer_type { + /** Control transfer */ + LIBUSB_TRANSFER_TYPE_CONTROL = 0U, + + /** Isochronous transfer */ + LIBUSB_TRANSFER_TYPE_ISOCHRONOUS = 1U, + + /** Bulk transfer */ + LIBUSB_TRANSFER_TYPE_BULK = 2U, + + /** Interrupt transfer */ + LIBUSB_TRANSFER_TYPE_INTERRUPT = 3U, + + /** Bulk stream transfer */ + LIBUSB_TRANSFER_TYPE_BULK_STREAM = 4U +}; + +/** \ingroup libusb_asyncio + * Transfer status codes */ +enum libusb_transfer_status { + /** Transfer completed without error. Note that this does not indicate + * that the entire amount of requested data was transferred. */ + LIBUSB_TRANSFER_COMPLETED, + + /** Transfer failed */ + LIBUSB_TRANSFER_ERROR, + + /** Transfer timed out */ + LIBUSB_TRANSFER_TIMED_OUT, + + /** Transfer was cancelled */ + LIBUSB_TRANSFER_CANCELLED, + + /** For bulk/interrupt endpoints: halt condition detected (endpoint + * stalled). For control endpoints: control request not supported. */ + LIBUSB_TRANSFER_STALL, + + /** Device was disconnected */ + LIBUSB_TRANSFER_NO_DEVICE, + + /** Device sent more data than requested */ + LIBUSB_TRANSFER_OVERFLOW + + /* NB! Remember to update libusb_error_name() + when adding new status codes here. */ +}; + +/** \ingroup libusb_asyncio + * libusb_transfer.flags values */ +enum libusb_transfer_flags { + /** Report short frames as errors */ + LIBUSB_TRANSFER_SHORT_NOT_OK = (1U << 0), + + /** Automatically free() transfer buffer during libusb_free_transfer(). + * Note that buffers allocated with libusb_dev_mem_alloc() should not + * be attempted freed in this way, since free() is not an appropriate + * way to release such memory. */ + LIBUSB_TRANSFER_FREE_BUFFER = (1U << 1), + + /** Automatically call libusb_free_transfer() after callback returns. + * If this flag is set, it is illegal to call libusb_free_transfer() + * from your transfer callback, as this will result in a double-free + * when this flag is acted upon. */ + LIBUSB_TRANSFER_FREE_TRANSFER = (1U << 2), + + /** Terminate transfers that are a multiple of the endpoint's + * wMaxPacketSize with an extra zero length packet. This is useful + * when a device protocol mandates that each logical request is + * terminated by an incomplete packet (i.e. the logical requests are + * not separated by other means). + * + * This flag only affects host-to-device transfers to bulk and interrupt + * endpoints. In other situations, it is ignored. + * + * This flag only affects transfers with a length that is a multiple of + * the endpoint's wMaxPacketSize. On transfers of other lengths, this + * flag has no effect. Therefore, if you are working with a device that + * needs a ZLP whenever the end of the logical request falls on a packet + * boundary, then it is sensible to set this flag on every + * transfer (you do not have to worry about only setting it on transfers + * that end on the boundary). + * + * This flag is currently only supported on Linux. + * On other systems, libusb_submit_transfer() will return + * LIBUSB_ERROR_NOT_SUPPORTED for every transfer where this flag is set. + * + * Available since libusb-1.0.9. + */ + LIBUSB_TRANSFER_ADD_ZERO_PACKET = (1U << 3) +}; + +/** \ingroup libusb_asyncio + * Isochronous packet descriptor. */ +struct libusb_iso_packet_descriptor { + /** Length of data to request in this packet */ + unsigned int length; + + /** Amount of data that was actually transferred */ + unsigned int actual_length; + + /** Status code for this packet */ + enum libusb_transfer_status status; +}; + +struct libusb_transfer; + +/** \ingroup libusb_asyncio + * Asynchronous transfer callback function type. When submitting asynchronous + * transfers, you pass a pointer to a callback function of this type via the + * \ref libusb_transfer::callback "callback" member of the libusb_transfer + * structure. libusb will call this function later, when the transfer has + * completed or failed. See \ref libusb_asyncio for more information. + * \param transfer The libusb_transfer struct the callback function is being + * notified about. + */ +typedef void (LIBUSB_CALL *libusb_transfer_cb_fn)(struct libusb_transfer *transfer); + +/** \ingroup libusb_asyncio + * The generic USB transfer structure. The user populates this structure and + * then submits it in order to request a transfer. After the transfer has + * completed, the library populates the transfer with the results and passes + * it back to the user. + */ +struct libusb_transfer { + /** Handle of the device that this transfer will be submitted to */ + libusb_device_handle *dev_handle; + + /** A bitwise OR combination of \ref libusb_transfer_flags. */ + uint8_t flags; + + /** Address of the endpoint where this transfer will be sent. */ + unsigned char endpoint; + + /** Type of the transfer from \ref libusb_transfer_type */ + unsigned char type; + + /** Timeout for this transfer in milliseconds. A value of 0 indicates no + * timeout. */ + unsigned int timeout; + + /** The status of the transfer. Read-only, and only for use within + * transfer callback function. + * + * If this is an isochronous transfer, this field may read COMPLETED even + * if there were errors in the frames. Use the + * \ref libusb_iso_packet_descriptor::status "status" field in each packet + * to determine if errors occurred. */ + enum libusb_transfer_status status; + + /** Length of the data buffer. Must be non-negative. */ + int length; + + /** Actual length of data that was transferred. Read-only, and only for + * use within transfer callback function. Not valid for isochronous + * endpoint transfers. */ + int actual_length; + + /** Callback function. This will be invoked when the transfer completes, + * fails, or is cancelled. */ + libusb_transfer_cb_fn callback; + + /** User context data. Useful for associating specific data to a transfer + * that can be accessed from within the callback function. + * + * This field may be set manually or is taken as the `user_data` parameter + * of the following functions: + * - libusb_fill_bulk_transfer() + * - libusb_fill_bulk_stream_transfer() + * - libusb_fill_control_transfer() + * - libusb_fill_interrupt_transfer() + * - libusb_fill_iso_transfer() */ + void *user_data; + + /** Data buffer */ + unsigned char *buffer; + + /** Number of isochronous packets. Only used for I/O with isochronous + * endpoints. Must be non-negative. */ + int num_iso_packets; + + /** Isochronous packet descriptors, for isochronous transfers only. */ + struct libusb_iso_packet_descriptor iso_packet_desc[ZERO_SIZED_ARRAY]; +}; + +/** \ingroup libusb_misc + * Capabilities supported by an instance of libusb on the current running + * platform. Test if the loaded library supports a given capability by calling + * \ref libusb_has_capability(). + */ +enum libusb_capability { + /** The libusb_has_capability() API is available. */ + LIBUSB_CAP_HAS_CAPABILITY = 0x0000U, + + /** Hotplug support is available on this platform. */ + LIBUSB_CAP_HAS_HOTPLUG = 0x0001U, + + /** The library can access HID devices without requiring user intervention. + * Note that before being able to actually access an HID device, you may + * still have to call additional libusb functions such as + * \ref libusb_detach_kernel_driver(). */ + LIBUSB_CAP_HAS_HID_ACCESS = 0x0100U, + + /** The library supports detaching of the default USB driver, using + * \ref libusb_detach_kernel_driver(), if one is set by the OS kernel */ + LIBUSB_CAP_SUPPORTS_DETACH_KERNEL_DRIVER = 0x0101U +}; + +/** \ingroup libusb_lib + * Log message levels. + */ +enum libusb_log_level { + /** (0) : No messages ever emitted by the library (default) */ + LIBUSB_LOG_LEVEL_NONE = 0, + + /** (1) : Error messages are emitted */ + LIBUSB_LOG_LEVEL_ERROR = 1, + + /** (2) : Warning and error messages are emitted */ + LIBUSB_LOG_LEVEL_WARNING = 2, + + /** (3) : Informational, warning and error messages are emitted */ + LIBUSB_LOG_LEVEL_INFO = 3, + + /** (4) : All messages are emitted */ + LIBUSB_LOG_LEVEL_DEBUG = 4 +}; + +/** \ingroup libusb_lib + * Log callback mode. + * \see libusb_set_log_cb() + */ +enum libusb_log_cb_mode { + /** Callback function handling all log messages. */ + LIBUSB_LOG_CB_GLOBAL = (1 << 0), + + /** Callback function handling context related log messages. */ + LIBUSB_LOG_CB_CONTEXT = (1 << 1) +}; + +/** \ingroup libusb_lib + * Callback function for handling log messages. + * \param ctx the context which is related to the log message, or NULL if it + * is a global log message + * \param level the log level, see \ref libusb_log_level for a description + * \param str the log message + * \see libusb_set_log_cb() + */ +typedef void (LIBUSB_CALL *libusb_log_cb)(libusb_context *ctx, + enum libusb_log_level level, const char *str); + +int LIBUSB_CALL libusb_init(libusb_context **ctx); +void LIBUSB_CALL libusb_exit(libusb_context *ctx); +LIBUSB_DEPRECATED_FOR(libusb_set_option) +void LIBUSB_CALL libusb_set_debug(libusb_context *ctx, int level); +void LIBUSB_CALL libusb_set_log_cb(libusb_context *ctx, libusb_log_cb cb, int mode); +const struct libusb_version * LIBUSB_CALL libusb_get_version(void); +int LIBUSB_CALL libusb_has_capability(uint32_t capability); +const char * LIBUSB_CALL libusb_error_name(int errcode); +int LIBUSB_CALL libusb_setlocale(const char *locale); +const char * LIBUSB_CALL libusb_strerror(int errcode); + +ssize_t LIBUSB_CALL libusb_get_device_list(libusb_context *ctx, + libusb_device ***list); +void LIBUSB_CALL libusb_free_device_list(libusb_device **list, + int unref_devices); +libusb_device * LIBUSB_CALL libusb_ref_device(libusb_device *dev); +void LIBUSB_CALL libusb_unref_device(libusb_device *dev); + +int LIBUSB_CALL libusb_get_configuration(libusb_device_handle *dev, + int *config); +int LIBUSB_CALL libusb_get_device_descriptor(libusb_device *dev, + struct libusb_device_descriptor *desc); +int LIBUSB_CALL libusb_get_active_config_descriptor(libusb_device *dev, + struct libusb_config_descriptor **config); +int LIBUSB_CALL libusb_get_config_descriptor(libusb_device *dev, + uint8_t config_index, struct libusb_config_descriptor **config); +int LIBUSB_CALL libusb_get_config_descriptor_by_value(libusb_device *dev, + uint8_t bConfigurationValue, struct libusb_config_descriptor **config); +void LIBUSB_CALL libusb_free_config_descriptor( + struct libusb_config_descriptor *config); +int LIBUSB_CALL libusb_get_ss_endpoint_companion_descriptor( + libusb_context *ctx, + const struct libusb_endpoint_descriptor *endpoint, + struct libusb_ss_endpoint_companion_descriptor **ep_comp); +void LIBUSB_CALL libusb_free_ss_endpoint_companion_descriptor( + struct libusb_ss_endpoint_companion_descriptor *ep_comp); +int LIBUSB_CALL libusb_get_bos_descriptor(libusb_device_handle *dev_handle, + struct libusb_bos_descriptor **bos); +void LIBUSB_CALL libusb_free_bos_descriptor(struct libusb_bos_descriptor *bos); +int LIBUSB_CALL libusb_get_usb_2_0_extension_descriptor( + libusb_context *ctx, + struct libusb_bos_dev_capability_descriptor *dev_cap, + struct libusb_usb_2_0_extension_descriptor **usb_2_0_extension); +void LIBUSB_CALL libusb_free_usb_2_0_extension_descriptor( + struct libusb_usb_2_0_extension_descriptor *usb_2_0_extension); +int LIBUSB_CALL libusb_get_ss_usb_device_capability_descriptor( + libusb_context *ctx, + struct libusb_bos_dev_capability_descriptor *dev_cap, + struct libusb_ss_usb_device_capability_descriptor **ss_usb_device_cap); +void LIBUSB_CALL libusb_free_ss_usb_device_capability_descriptor( + struct libusb_ss_usb_device_capability_descriptor *ss_usb_device_cap); +int LIBUSB_CALL libusb_get_container_id_descriptor(libusb_context *ctx, + struct libusb_bos_dev_capability_descriptor *dev_cap, + struct libusb_container_id_descriptor **container_id); +void LIBUSB_CALL libusb_free_container_id_descriptor( + struct libusb_container_id_descriptor *container_id); +uint8_t LIBUSB_CALL libusb_get_bus_number(libusb_device *dev); +uint8_t LIBUSB_CALL libusb_get_port_number(libusb_device *dev); +int LIBUSB_CALL libusb_get_port_numbers(libusb_device *dev, uint8_t *port_numbers, int port_numbers_len); +LIBUSB_DEPRECATED_FOR(libusb_get_port_numbers) +int LIBUSB_CALL libusb_get_port_path(libusb_context *ctx, libusb_device *dev, uint8_t *path, uint8_t path_length); +libusb_device * LIBUSB_CALL libusb_get_parent(libusb_device *dev); +uint8_t LIBUSB_CALL libusb_get_device_address(libusb_device *dev); +int LIBUSB_CALL libusb_get_device_speed(libusb_device *dev); +int LIBUSB_CALL libusb_get_max_packet_size(libusb_device *dev, + unsigned char endpoint); +int LIBUSB_CALL libusb_get_max_iso_packet_size(libusb_device *dev, + unsigned char endpoint); + +int LIBUSB_CALL libusb_wrap_sys_device(libusb_context *ctx, intptr_t sys_dev, libusb_device_handle **dev_handle); +int LIBUSB_CALL libusb_open(libusb_device *dev, libusb_device_handle **dev_handle); +void LIBUSB_CALL libusb_close(libusb_device_handle *dev_handle); +libusb_device * LIBUSB_CALL libusb_get_device(libusb_device_handle *dev_handle); + +int LIBUSB_CALL libusb_set_configuration(libusb_device_handle *dev_handle, + int configuration); +int LIBUSB_CALL libusb_claim_interface(libusb_device_handle *dev_handle, + int interface_number); +int LIBUSB_CALL libusb_release_interface(libusb_device_handle *dev_handle, + int interface_number); + +libusb_device_handle * LIBUSB_CALL libusb_open_device_with_vid_pid( + libusb_context *ctx, uint16_t vendor_id, uint16_t product_id); + +int LIBUSB_CALL libusb_set_interface_alt_setting(libusb_device_handle *dev_handle, + int interface_number, int alternate_setting); +int LIBUSB_CALL libusb_clear_halt(libusb_device_handle *dev_handle, + unsigned char endpoint); +int LIBUSB_CALL libusb_reset_device(libusb_device_handle *dev_handle); + +int LIBUSB_CALL libusb_alloc_streams(libusb_device_handle *dev_handle, + uint32_t num_streams, unsigned char *endpoints, int num_endpoints); +int LIBUSB_CALL libusb_free_streams(libusb_device_handle *dev_handle, + unsigned char *endpoints, int num_endpoints); + +unsigned char * LIBUSB_CALL libusb_dev_mem_alloc(libusb_device_handle *dev_handle, + size_t length); +int LIBUSB_CALL libusb_dev_mem_free(libusb_device_handle *dev_handle, + unsigned char *buffer, size_t length); + +int LIBUSB_CALL libusb_kernel_driver_active(libusb_device_handle *dev_handle, + int interface_number); +int LIBUSB_CALL libusb_detach_kernel_driver(libusb_device_handle *dev_handle, + int interface_number); +int LIBUSB_CALL libusb_attach_kernel_driver(libusb_device_handle *dev_handle, + int interface_number); +int LIBUSB_CALL libusb_set_auto_detach_kernel_driver( + libusb_device_handle *dev_handle, int enable); + +/* async I/O */ + +/** \ingroup libusb_asyncio + * Get the data section of a control transfer. This convenience function is here + * to remind you that the data does not start until 8 bytes into the actual + * buffer, as the setup packet comes first. + * + * Calling this function only makes sense from a transfer callback function, + * or situations where you have already allocated a suitably sized buffer at + * transfer->buffer. + * + * \param transfer a transfer + * \returns pointer to the first byte of the data section + */ +static inline unsigned char *libusb_control_transfer_get_data( + struct libusb_transfer *transfer) +{ + return transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE; +} + +/** \ingroup libusb_asyncio + * Get the control setup packet of a control transfer. This convenience + * function is here to remind you that the control setup occupies the first + * 8 bytes of the transfer data buffer. + * + * Calling this function only makes sense from a transfer callback function, + * or situations where you have already allocated a suitably sized buffer at + * transfer->buffer. + * + * \param transfer a transfer + * \returns a casted pointer to the start of the transfer data buffer + */ +static inline struct libusb_control_setup *libusb_control_transfer_get_setup( + struct libusb_transfer *transfer) +{ + return (struct libusb_control_setup *)(void *)transfer->buffer; +} + +/** \ingroup libusb_asyncio + * Helper function to populate the setup packet (first 8 bytes of the data + * buffer) for a control transfer. The wIndex, wValue and wLength values should + * be given in host-endian byte order. + * + * \param buffer buffer to output the setup packet into + * This pointer must be aligned to at least 2 bytes boundary. + * \param bmRequestType see the + * \ref libusb_control_setup::bmRequestType "bmRequestType" field of + * \ref libusb_control_setup + * \param bRequest see the + * \ref libusb_control_setup::bRequest "bRequest" field of + * \ref libusb_control_setup + * \param wValue see the + * \ref libusb_control_setup::wValue "wValue" field of + * \ref libusb_control_setup + * \param wIndex see the + * \ref libusb_control_setup::wIndex "wIndex" field of + * \ref libusb_control_setup + * \param wLength see the + * \ref libusb_control_setup::wLength "wLength" field of + * \ref libusb_control_setup + */ +static inline void libusb_fill_control_setup(unsigned char *buffer, + uint8_t bmRequestType, uint8_t bRequest, uint16_t wValue, uint16_t wIndex, + uint16_t wLength) +{ + struct libusb_control_setup *setup = (struct libusb_control_setup *)(void *)buffer; + setup->bmRequestType = bmRequestType; + setup->bRequest = bRequest; + setup->wValue = libusb_cpu_to_le16(wValue); + setup->wIndex = libusb_cpu_to_le16(wIndex); + setup->wLength = libusb_cpu_to_le16(wLength); +} + +struct libusb_transfer * LIBUSB_CALL libusb_alloc_transfer(int iso_packets); +int LIBUSB_CALL libusb_submit_transfer(struct libusb_transfer *transfer); +int LIBUSB_CALL libusb_cancel_transfer(struct libusb_transfer *transfer); +void LIBUSB_CALL libusb_free_transfer(struct libusb_transfer *transfer); +void LIBUSB_CALL libusb_transfer_set_stream_id( + struct libusb_transfer *transfer, uint32_t stream_id); +uint32_t LIBUSB_CALL libusb_transfer_get_stream_id( + struct libusb_transfer *transfer); + +/** \ingroup libusb_asyncio + * Helper function to populate the required \ref libusb_transfer fields + * for a control transfer. + * + * If you pass a transfer buffer to this function, the first 8 bytes will + * be interpreted as a control setup packet, and the wLength field will be + * used to automatically populate the \ref libusb_transfer::length "length" + * field of the transfer. Therefore the recommended approach is: + * -# Allocate a suitably sized data buffer (including space for control setup) + * -# Call libusb_fill_control_setup() + * -# If this is a host-to-device transfer with a data stage, put the data + * in place after the setup packet + * -# Call this function + * -# Call libusb_submit_transfer() + * + * It is also legal to pass a NULL buffer to this function, in which case this + * function will not attempt to populate the length field. Remember that you + * must then populate the buffer and length fields later. + * + * \param transfer the transfer to populate + * \param dev_handle handle of the device that will handle the transfer + * \param buffer data buffer. If provided, this function will interpret the + * first 8 bytes as a setup packet and infer the transfer length from that. + * This pointer must be aligned to at least 2 bytes boundary. + * \param callback callback function to be invoked on transfer completion + * \param user_data user data to pass to callback function + * \param timeout timeout for the transfer in milliseconds + */ +static inline void libusb_fill_control_transfer( + struct libusb_transfer *transfer, libusb_device_handle *dev_handle, + unsigned char *buffer, libusb_transfer_cb_fn callback, void *user_data, + unsigned int timeout) +{ + struct libusb_control_setup *setup = (struct libusb_control_setup *)(void *)buffer; + transfer->dev_handle = dev_handle; + transfer->endpoint = 0; + transfer->type = LIBUSB_TRANSFER_TYPE_CONTROL; + transfer->timeout = timeout; + transfer->buffer = buffer; + if (setup) + transfer->length = (int) (LIBUSB_CONTROL_SETUP_SIZE + + libusb_le16_to_cpu(setup->wLength)); + transfer->user_data = user_data; + transfer->callback = callback; +} + +/** \ingroup libusb_asyncio + * Helper function to populate the required \ref libusb_transfer fields + * for a bulk transfer. + * + * \param transfer the transfer to populate + * \param dev_handle handle of the device that will handle the transfer + * \param endpoint address of the endpoint where this transfer will be sent + * \param buffer data buffer + * \param length length of data buffer + * \param callback callback function to be invoked on transfer completion + * \param user_data user data to pass to callback function + * \param timeout timeout for the transfer in milliseconds + */ +static inline void libusb_fill_bulk_transfer(struct libusb_transfer *transfer, + libusb_device_handle *dev_handle, unsigned char endpoint, + unsigned char *buffer, int length, libusb_transfer_cb_fn callback, + void *user_data, unsigned int timeout) +{ + transfer->dev_handle = dev_handle; + transfer->endpoint = endpoint; + transfer->type = LIBUSB_TRANSFER_TYPE_BULK; + transfer->timeout = timeout; + transfer->buffer = buffer; + transfer->length = length; + transfer->user_data = user_data; + transfer->callback = callback; +} + +/** \ingroup libusb_asyncio + * Helper function to populate the required \ref libusb_transfer fields + * for a bulk transfer using bulk streams. + * + * Since version 1.0.19, \ref LIBUSB_API_VERSION >= 0x01000103 + * + * \param transfer the transfer to populate + * \param dev_handle handle of the device that will handle the transfer + * \param endpoint address of the endpoint where this transfer will be sent + * \param stream_id bulk stream id for this transfer + * \param buffer data buffer + * \param length length of data buffer + * \param callback callback function to be invoked on transfer completion + * \param user_data user data to pass to callback function + * \param timeout timeout for the transfer in milliseconds + */ +static inline void libusb_fill_bulk_stream_transfer( + struct libusb_transfer *transfer, libusb_device_handle *dev_handle, + unsigned char endpoint, uint32_t stream_id, + unsigned char *buffer, int length, libusb_transfer_cb_fn callback, + void *user_data, unsigned int timeout) +{ + libusb_fill_bulk_transfer(transfer, dev_handle, endpoint, buffer, + length, callback, user_data, timeout); + transfer->type = LIBUSB_TRANSFER_TYPE_BULK_STREAM; + libusb_transfer_set_stream_id(transfer, stream_id); +} + +/** \ingroup libusb_asyncio + * Helper function to populate the required \ref libusb_transfer fields + * for an interrupt transfer. + * + * \param transfer the transfer to populate + * \param dev_handle handle of the device that will handle the transfer + * \param endpoint address of the endpoint where this transfer will be sent + * \param buffer data buffer + * \param length length of data buffer + * \param callback callback function to be invoked on transfer completion + * \param user_data user data to pass to callback function + * \param timeout timeout for the transfer in milliseconds + */ +static inline void libusb_fill_interrupt_transfer( + struct libusb_transfer *transfer, libusb_device_handle *dev_handle, + unsigned char endpoint, unsigned char *buffer, int length, + libusb_transfer_cb_fn callback, void *user_data, unsigned int timeout) +{ + transfer->dev_handle = dev_handle; + transfer->endpoint = endpoint; + transfer->type = LIBUSB_TRANSFER_TYPE_INTERRUPT; + transfer->timeout = timeout; + transfer->buffer = buffer; + transfer->length = length; + transfer->user_data = user_data; + transfer->callback = callback; +} + +/** \ingroup libusb_asyncio + * Helper function to populate the required \ref libusb_transfer fields + * for an isochronous transfer. + * + * \param transfer the transfer to populate + * \param dev_handle handle of the device that will handle the transfer + * \param endpoint address of the endpoint where this transfer will be sent + * \param buffer data buffer + * \param length length of data buffer + * \param num_iso_packets the number of isochronous packets + * \param callback callback function to be invoked on transfer completion + * \param user_data user data to pass to callback function + * \param timeout timeout for the transfer in milliseconds + */ +static inline void libusb_fill_iso_transfer(struct libusb_transfer *transfer, + libusb_device_handle *dev_handle, unsigned char endpoint, + unsigned char *buffer, int length, int num_iso_packets, + libusb_transfer_cb_fn callback, void *user_data, unsigned int timeout) +{ + transfer->dev_handle = dev_handle; + transfer->endpoint = endpoint; + transfer->type = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS; + transfer->timeout = timeout; + transfer->buffer = buffer; + transfer->length = length; + transfer->num_iso_packets = num_iso_packets; + transfer->user_data = user_data; + transfer->callback = callback; +} + +/** \ingroup libusb_asyncio + * Convenience function to set the length of all packets in an isochronous + * transfer, based on the num_iso_packets field in the transfer structure. + * + * \param transfer a transfer + * \param length the length to set in each isochronous packet descriptor + * \see libusb_get_max_packet_size() + */ +static inline void libusb_set_iso_packet_lengths( + struct libusb_transfer *transfer, unsigned int length) +{ + int i; + + for (i = 0; i < transfer->num_iso_packets; i++) + transfer->iso_packet_desc[i].length = length; +} + +/** \ingroup libusb_asyncio + * Convenience function to locate the position of an isochronous packet + * within the buffer of an isochronous transfer. + * + * This is a thorough function which loops through all preceding packets, + * accumulating their lengths to find the position of the specified packet. + * Typically you will assign equal lengths to each packet in the transfer, + * and hence the above method is sub-optimal. You may wish to use + * libusb_get_iso_packet_buffer_simple() instead. + * + * \param transfer a transfer + * \param packet the packet to return the address of + * \returns the base address of the packet buffer inside the transfer buffer, + * or NULL if the packet does not exist. + * \see libusb_get_iso_packet_buffer_simple() + */ +static inline unsigned char *libusb_get_iso_packet_buffer( + struct libusb_transfer *transfer, unsigned int packet) +{ + int i; + size_t offset = 0; + int _packet; + + /* oops..slight bug in the API. packet is an unsigned int, but we use + * signed integers almost everywhere else. range-check and convert to + * signed to avoid compiler warnings. FIXME for libusb-2. */ + if (packet > INT_MAX) + return NULL; + _packet = (int) packet; + + if (_packet >= transfer->num_iso_packets) + return NULL; + + for (i = 0; i < _packet; i++) + offset += transfer->iso_packet_desc[i].length; + + return transfer->buffer + offset; +} + +/** \ingroup libusb_asyncio + * Convenience function to locate the position of an isochronous packet + * within the buffer of an isochronous transfer, for transfers where each + * packet is of identical size. + * + * This function relies on the assumption that every packet within the transfer + * is of identical size to the first packet. Calculating the location of + * the packet buffer is then just a simple calculation: + * buffer + (packet_size * packet) + * + * Do not use this function on transfers other than those that have identical + * packet lengths for each packet. + * + * \param transfer a transfer + * \param packet the packet to return the address of + * \returns the base address of the packet buffer inside the transfer buffer, + * or NULL if the packet does not exist. + * \see libusb_get_iso_packet_buffer() + */ +static inline unsigned char *libusb_get_iso_packet_buffer_simple( + struct libusb_transfer *transfer, unsigned int packet) +{ + int _packet; + + /* oops..slight bug in the API. packet is an unsigned int, but we use + * signed integers almost everywhere else. range-check and convert to + * signed to avoid compiler warnings. FIXME for libusb-2. */ + if (packet > INT_MAX) + return NULL; + _packet = (int) packet; + + if (_packet >= transfer->num_iso_packets) + return NULL; + + return transfer->buffer + ((int) transfer->iso_packet_desc[0].length * _packet); +} + +/* sync I/O */ + +int LIBUSB_CALL libusb_control_transfer(libusb_device_handle *dev_handle, + uint8_t request_type, uint8_t bRequest, uint16_t wValue, uint16_t wIndex, + unsigned char *data, uint16_t wLength, unsigned int timeout); + +int LIBUSB_CALL libusb_bulk_transfer(libusb_device_handle *dev_handle, + unsigned char endpoint, unsigned char *data, int length, + int *actual_length, unsigned int timeout); + +int LIBUSB_CALL libusb_interrupt_transfer(libusb_device_handle *dev_handle, + unsigned char endpoint, unsigned char *data, int length, + int *actual_length, unsigned int timeout); + +/** \ingroup libusb_desc + * Retrieve a descriptor from the default control pipe. + * This is a convenience function which formulates the appropriate control + * message to retrieve the descriptor. + * + * \param dev_handle a device handle + * \param desc_type the descriptor type, see \ref libusb_descriptor_type + * \param desc_index the index of the descriptor to retrieve + * \param data output buffer for descriptor + * \param length size of data buffer + * \returns number of bytes returned in data, or LIBUSB_ERROR code on failure + */ +static inline int libusb_get_descriptor(libusb_device_handle *dev_handle, + uint8_t desc_type, uint8_t desc_index, unsigned char *data, int length) +{ + return libusb_control_transfer(dev_handle, LIBUSB_ENDPOINT_IN, + LIBUSB_REQUEST_GET_DESCRIPTOR, (uint16_t) ((desc_type << 8) | desc_index), + 0, data, (uint16_t) length, 1000); +} + +/** \ingroup libusb_desc + * Retrieve a descriptor from a device. + * This is a convenience function which formulates the appropriate control + * message to retrieve the descriptor. The string returned is Unicode, as + * detailed in the USB specifications. + * + * \param dev_handle a device handle + * \param desc_index the index of the descriptor to retrieve + * \param langid the language ID for the string descriptor + * \param data output buffer for descriptor + * \param length size of data buffer + * \returns number of bytes returned in data, or LIBUSB_ERROR code on failure + * \see libusb_get_string_descriptor_ascii() + */ +static inline int libusb_get_string_descriptor(libusb_device_handle *dev_handle, + uint8_t desc_index, uint16_t langid, unsigned char *data, int length) +{ + return libusb_control_transfer(dev_handle, LIBUSB_ENDPOINT_IN, + LIBUSB_REQUEST_GET_DESCRIPTOR, (uint16_t)((LIBUSB_DT_STRING << 8) | desc_index), + langid, data, (uint16_t) length, 1000); +} + +int LIBUSB_CALL libusb_get_string_descriptor_ascii(libusb_device_handle *dev_handle, + uint8_t desc_index, unsigned char *data, int length); + +/* polling and timeouts */ + +int LIBUSB_CALL libusb_try_lock_events(libusb_context *ctx); +void LIBUSB_CALL libusb_lock_events(libusb_context *ctx); +void LIBUSB_CALL libusb_unlock_events(libusb_context *ctx); +int LIBUSB_CALL libusb_event_handling_ok(libusb_context *ctx); +int LIBUSB_CALL libusb_event_handler_active(libusb_context *ctx); +void LIBUSB_CALL libusb_interrupt_event_handler(libusb_context *ctx); +void LIBUSB_CALL libusb_lock_event_waiters(libusb_context *ctx); +void LIBUSB_CALL libusb_unlock_event_waiters(libusb_context *ctx); +int LIBUSB_CALL libusb_wait_for_event(libusb_context *ctx, struct timeval *tv); + +int LIBUSB_CALL libusb_handle_events_timeout(libusb_context *ctx, + struct timeval *tv); +int LIBUSB_CALL libusb_handle_events_timeout_completed(libusb_context *ctx, + struct timeval *tv, int *completed); +int LIBUSB_CALL libusb_handle_events(libusb_context *ctx); +int LIBUSB_CALL libusb_handle_events_completed(libusb_context *ctx, int *completed); +int LIBUSB_CALL libusb_handle_events_locked(libusb_context *ctx, + struct timeval *tv); +int LIBUSB_CALL libusb_pollfds_handle_timeouts(libusb_context *ctx); +int LIBUSB_CALL libusb_get_next_timeout(libusb_context *ctx, + struct timeval *tv); + +/** \ingroup libusb_poll + * File descriptor for polling + */ +struct libusb_pollfd { + /** Numeric file descriptor */ + int fd; + + /** Event flags to poll for from . POLLIN indicates that you + * should monitor this file descriptor for becoming ready to read from, + * and POLLOUT indicates that you should monitor this file descriptor for + * nonblocking write readiness. */ + short events; +}; + +/** \ingroup libusb_poll + * Callback function, invoked when a new file descriptor should be added + * to the set of file descriptors monitored for events. + * \param fd the new file descriptor + * \param events events to monitor for, see \ref libusb_pollfd for a + * description + * \param user_data User data pointer specified in + * libusb_set_pollfd_notifiers() call + * \see libusb_set_pollfd_notifiers() + */ +typedef void (LIBUSB_CALL *libusb_pollfd_added_cb)(int fd, short events, + void *user_data); + +/** \ingroup libusb_poll + * Callback function, invoked when a file descriptor should be removed from + * the set of file descriptors being monitored for events. After returning + * from this callback, do not use that file descriptor again. + * \param fd the file descriptor to stop monitoring + * \param user_data User data pointer specified in + * libusb_set_pollfd_notifiers() call + * \see libusb_set_pollfd_notifiers() + */ +typedef void (LIBUSB_CALL *libusb_pollfd_removed_cb)(int fd, void *user_data); + +const struct libusb_pollfd ** LIBUSB_CALL libusb_get_pollfds( + libusb_context *ctx); +void LIBUSB_CALL libusb_free_pollfds(const struct libusb_pollfd **pollfds); +void LIBUSB_CALL libusb_set_pollfd_notifiers(libusb_context *ctx, + libusb_pollfd_added_cb added_cb, libusb_pollfd_removed_cb removed_cb, + void *user_data); + +/** \ingroup libusb_hotplug + * Callback handle. + * + * Callbacks handles are generated by libusb_hotplug_register_callback() + * and can be used to deregister callbacks. Callback handles are unique + * per libusb_context and it is safe to call libusb_hotplug_deregister_callback() + * on an already deregistered callback. + * + * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102 + * + * For more information, see \ref libusb_hotplug. + */ +typedef int libusb_hotplug_callback_handle; + +/** \ingroup libusb_hotplug + * + * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102 + * + * Hotplug events */ +typedef enum { + /** A device has been plugged in and is ready to use */ + LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED = (1 << 0), + + /** A device has left and is no longer available. + * It is the user's responsibility to call libusb_close on any handle associated with a disconnected device. + * It is safe to call libusb_get_device_descriptor on a device that has left */ + LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT = (1 << 1) +} libusb_hotplug_event; + +/** \ingroup libusb_hotplug + * + * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102 + * + * Hotplug flags */ +typedef enum { + /** Arm the callback and fire it for all matching currently attached devices. */ + LIBUSB_HOTPLUG_ENUMERATE = (1 << 0) +} libusb_hotplug_flag; + +/** \ingroup libusb_hotplug + * Convenience macro when not using any flags */ +#define LIBUSB_HOTPLUG_NO_FLAGS 0 + +/** \ingroup libusb_hotplug + * Wildcard matching for hotplug events */ +#define LIBUSB_HOTPLUG_MATCH_ANY -1 + +/** \ingroup libusb_hotplug + * Hotplug callback function type. When requesting hotplug event notifications, + * you pass a pointer to a callback function of this type. + * + * This callback may be called by an internal event thread and as such it is + * recommended the callback do minimal processing before returning. + * + * libusb will call this function later, when a matching event had happened on + * a matching device. See \ref libusb_hotplug for more information. + * + * It is safe to call either libusb_hotplug_register_callback() or + * libusb_hotplug_deregister_callback() from within a callback function. + * + * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102 + * + * \param ctx context of this notification + * \param device libusb_device this event occurred on + * \param event event that occurred + * \param user_data user data provided when this callback was registered + * \returns bool whether this callback is finished processing events. + * returning 1 will cause this callback to be deregistered + */ +typedef int (LIBUSB_CALL *libusb_hotplug_callback_fn)(libusb_context *ctx, + libusb_device *device, libusb_hotplug_event event, void *user_data); + +/** \ingroup libusb_hotplug + * Register a hotplug callback function + * + * Register a callback with the libusb_context. The callback will fire + * when a matching event occurs on a matching device. The callback is + * armed until either it is deregistered with libusb_hotplug_deregister_callback() + * or the supplied callback returns 1 to indicate it is finished processing events. + * + * If the \ref LIBUSB_HOTPLUG_ENUMERATE is passed the callback will be + * called with a \ref LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED for all devices + * already plugged into the machine. Note that libusb modifies its internal + * device list from a separate thread, while calling hotplug callbacks from + * libusb_handle_events(), so it is possible for a device to already be present + * on, or removed from, its internal device list, while the hotplug callbacks + * still need to be dispatched. This means that when using \ref + * LIBUSB_HOTPLUG_ENUMERATE, your callback may be called twice for the arrival + * of the same device, once from libusb_hotplug_register_callback() and once + * from libusb_handle_events(); and/or your callback may be called for the + * removal of a device for which an arrived call was never made. + * + * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102 + * + * \param[in] ctx context to register this callback with + * \param[in] events bitwise or of hotplug events that will trigger this callback. + * See \ref libusb_hotplug_event + * \param[in] flags bitwise or of hotplug flags that affect registration. + * See \ref libusb_hotplug_flag + * \param[in] vendor_id the vendor id to match or \ref LIBUSB_HOTPLUG_MATCH_ANY + * \param[in] product_id the product id to match or \ref LIBUSB_HOTPLUG_MATCH_ANY + * \param[in] dev_class the device class to match or \ref LIBUSB_HOTPLUG_MATCH_ANY + * \param[in] cb_fn the function to be invoked on a matching event/device + * \param[in] user_data user data to pass to the callback function + * \param[out] callback_handle pointer to store the handle of the allocated callback (can be NULL) + * \returns LIBUSB_SUCCESS on success LIBUSB_ERROR code on failure + */ +int LIBUSB_CALL libusb_hotplug_register_callback(libusb_context *ctx, + int events, int flags, + int vendor_id, int product_id, int dev_class, + libusb_hotplug_callback_fn cb_fn, void *user_data, + libusb_hotplug_callback_handle *callback_handle); + +/** \ingroup libusb_hotplug + * Deregisters a hotplug callback. + * + * Deregister a callback from a libusb_context. This function is safe to call from within + * a hotplug callback. + * + * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102 + * + * \param[in] ctx context this callback is registered with + * \param[in] callback_handle the handle of the callback to deregister + */ +void LIBUSB_CALL libusb_hotplug_deregister_callback(libusb_context *ctx, + libusb_hotplug_callback_handle callback_handle); + +/** \ingroup libusb_hotplug + * Gets the user_data associated with a hotplug callback. + * + * Since version v1.0.24 \ref LIBUSB_API_VERSION >= 0x01000108 + * + * \param[in] ctx context this callback is registered with + * \param[in] callback_handle the handle of the callback to get the user_data of + */ +void * LIBUSB_CALL libusb_hotplug_get_user_data(libusb_context *ctx, + libusb_hotplug_callback_handle callback_handle); + +/** \ingroup libusb_lib + * Available option values for libusb_set_option(). + */ +enum libusb_option { + /** Set the log message verbosity. + * + * The default level is LIBUSB_LOG_LEVEL_NONE, which means no messages are ever + * printed. If you choose to increase the message verbosity level, ensure + * that your application does not close the stderr file descriptor. + * + * You are advised to use level LIBUSB_LOG_LEVEL_WARNING. libusb is conservative + * with its message logging and most of the time, will only log messages that + * explain error conditions and other oddities. This will help you debug + * your software. + * + * If the LIBUSB_DEBUG environment variable was set when libusb was + * initialized, this function does nothing: the message verbosity is fixed + * to the value in the environment variable. + * + * If libusb was compiled without any message logging, this function does + * nothing: you'll never get any messages. + * + * If libusb was compiled with verbose debug message logging, this function + * does nothing: you'll always get messages from all levels. + */ + LIBUSB_OPTION_LOG_LEVEL = 0, + + /** Use the UsbDk backend for a specific context, if available. + * + * This option should be set immediately after calling libusb_init(), otherwise + * unspecified behavior may occur. + * + * Only valid on Windows. + */ + LIBUSB_OPTION_USE_USBDK = 1, + + /** Set libusb has weak authority. With this option, libusb will skip + * scan devices in libusb_init. + * + * This option should be set before calling libusb_init(), otherwise + * libusb_init will failed. Normally libusb_wrap_sys_device need set + * this option. + * + * Only valid on Linux-based operating system, such as Android. + */ + LIBUSB_OPTION_WEAK_AUTHORITY = 2 +}; + +int LIBUSB_CALL libusb_set_option(libusb_context *ctx, enum libusb_option option, ...); + +#if defined(__cplusplus) +} +#endif + +#endif diff --git a/lib/COPYING b/lib/COPYING new file mode 100644 index 0000000..5ab7695 --- /dev/null +++ b/lib/COPYING @@ -0,0 +1,504 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + 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 + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! + + diff --git a/lib/libusb-1.0.a b/lib/libusb-1.0.a new file mode 100644 index 0000000000000000000000000000000000000000..eb834a04bed702abc7b56f1259307978aec78a79 GIT binary patch literal 187480 zcmeFa4R}=5wKskSMjT;uVhuLhSVtQa6fogC5;ZUk9}*xEf~dq{NG6aPl62+_2}&?@ z65!n9vD~ZP+SXd>$GzUxwzRbYmDWJG1eB{$xrl{oTGN_g(n>1@1g?31YwvybIr9

+HSH-s@af6bx6czJ2&D-sDfgl>DhvrcRtZZJO7c z&ywu_z1~R^CUJy!#c)MYG)1}m-v4{PtG}rz|DEqsuPI8V?{mi$<^S*RM~^59zK)CA zt?$TPisQ3ZQI5JpUTVI)s zs;Y@(%(^OMmJO_27l?!+k(&CtKuwhrsI6Iv8UmC7K%g$VW@RW`JSi!mp+2k*k`fGu z>eQ6%oXJ42sw#|%GABkFLZK>KQaDsCB(Whau5CzA53C8T2{7r4r%6Ule04Y!DlV8H z@exQCjH>k@uLdhu2ObE8>q51Gs&LI(2x^t5d{v>9(N!t9+WJ+2%9W`U>l;*PP*$=! z7ztDc8-goqYHQSW#4T$!loe1USXZOgJQ$MAWz)M&y%BpoBtA=P2&$`#3#Q20C}B;o zDbNtCd;nksbZtzVsWp-ML2^XvGOC+2C-{R|L{y^53<`=0RZ&VL5Nv1&)g_yaXl}EF z5UepAYzRcwMFc^+T=gJf1BSyRJ0 zAoJI&>(z$Z=qfl@wQ{vEYZF&juhvx8R5EWP?bS@If`?oMLk6Rj=-eyem~GwD%$1&J zqSf`yOuW%Rs4A!iiAWM>Rz;Er?o8Bhur5-abn9l8lK~%zu3S^21~Q~n2J0$uZ_JQl zqR8_FxPwBI*kqI$h<_^s8i4a3tgEUGNy@C3)Q0#yG;;>VO07^g%Mz(sRTs3lOQIp} zI%;?wb2EX^T8vBVV-IpZ>DXvpW;`nnXAY*xV(K5T`$rsb7rKY#ljc*1<^GgibC;P7=)z(w4VM&Ou5_N+!eOLI!wOB)!qCli3Ca zn?m1_`e;}Vk;9=i^=pM-fuxk0dfd`$R8bsPbla1CigYD3YLkI=C>z>txYo#95&_4M zB3Ns`aZ=Bq8>)>e`L1xiW!J?Mt^5AUXzc^C(-cq0WMyW@W2uazN(?JhA+(SWJ|A_g z<0=w3(Vdtf2~;JD$k!uswk_|dyR$E_J z#RyhWx)NxtsjI4Q#7&b8Mj#86Tpz5W0j7$%0D6Bo7+$9YR;$64=mHV$ypgU3Rm^HI z`j-xZyGfB^QAVGt41r!J)_!rNf;qwQ|%Vq}Vmd{iInUg55&p%k|+(l(e0=`8Hmn>dXQsQ6C zD#y^g=0X*g%$tci^8>Tzm4F8(0GN~|Zb@CtNM71VyP7)5M6DRk8Z}}z()jvYhO4V# zH}FQH-3VniA-XuZ%?O*j)RCfLoC7mPr{BQczwcf5rH4a>X4ZP!H{pR3*NqWBGa_tXyFD;ApXM5TkoNcGHXph>Y7rV8$y8QiA zQ1kcd(O$i|U!V1fv#mq(_iZTAou731Pf)7S;PkX#)^8Ma{e98hF@L{9_xDft_e8&5&=K34 zec%0oicVv#BFY1!o#D84suBE_6&wY>UCunZ?xTNg9cqr|%wzD2)MBwSPS2t}Z5^I@ zM~J|Y`#|z}v^Xmt>(9|Iby2Ycs#jZ*=h9~7IR&|aH)8$n1Gf6NQ6VimFV;~^*;p0! zbnpXuhCjOtsS4^wF1PN_!jDV$yG*W7MAi>|YlpSYjr}Fa4jx;#!1nZ^g(o~;Z2%Pe z#Oc}m4FCgqzf|z^@)h8K1ZsPO@{J_<+TQfEer^c#-_~<(U_dht(SM-;y{#8lH(!*6 zeEJiVe)C8-!7LY=kfm!Z#j`~L6<&T|Br=Iy;6D4sw-&6-($?qY7{BTR5yRjak^i?y@biM~s~LEBOF^SaLkLm`n|nu?lo^9H)n+D7Q4&A#+& zP*iC<>S_BjG0t?>xB0)o9|Pk{fqj`QDP9Apdh5%V5?le;VD|a)7wCF{b?v3=+vN4e zkN=Al@o3q=z(9Ns{(&7g*RWQSmql9s6G})e7v=SR1GP&HZu&JyX&*DuyO^-ZtrWZ& zZ>K8ODlg{alC#})5t#}UuJjE9i5FEsI|qC1C>tB=cj|LAUk>H#@{PuSMMI5#x8|F)jrc*eE?7ceHZ{c&z2f|V z&Vr+fze)dP`p2=P0Nz6$%GJty$a>ynw3!FiCo|GO9yaFWk~WaVnFsGV@TOjtug_;1 z^7m@P0cv-FrLk0?%SX+n5Wk1@Wc_fX%%GnlrXO@$?)#+q+Wkwcf2CJAmRBT^1 z*gzHASXKU>fo^@N6D$@URejm}It;fUCrR5IyJ*Zm`1BUYxhbsZ?*Zu1DFg^;uqUO^}(S4#< z#hTqtcB6ZNke-F*Zrl;(zM*9i9qxz(zf?_m7RkH7eQJ+G9j38cU+nioRJWw6&2?1} z%e=jqepvyTq3wXSM;#OUc*st8nSsWuw$aT6T9{^3WRbccHTtd#{uDRxicWn&R_tSE z;}!b7&Vr7%qtUoFoF`OoWdssOn3#z-xIL7+VrL!d!?_#JlFw3e3OY8PbpVPE z-$qVr6tt#Pph?+P1uh*5u6VD30-=D%JAg=By4C*S&1Cp~Pe=>BZ9GE~x6e`a6+ zcV_0eEq%rMMJ9&rt1<#IUbe~|Hu-?vZ64ZxY!tH+`@q1F^Q$p=dAs$mZyL0vZ5jVG;-=>`Z zo^CJDx8d)J^%v>Qk|ErNp>N#1s4H&yE;V4ZhcopedN@W^dpxbJl;h#iLm$4?vtuSS zwekG{Ohiu29O{VXq_E4pJMmk+yKh9SXK1X$;rZ#2#5-FJxLHzj`5~siIm}9U)o6LG zQ!hWHj%d0IwI`mV{tCCuv>^t6PG?GmVl?Rrlq9w$U)4MRFt(n6^_YMo@G!N8f|L^tAhK0Oy!a_~<_6-Y*)V zTQFenDYGy^n~abVL(o<47}tAeKL1{ckKc27T)EMrZgTlI*ua zveoH6pl=fmXy-W5*^E+`;cOcXsh|}!YcFFM+*Ioedg;DAmkmTS-pJ6lU{G7W-4#hAr}sOjUmHFSMj2lP z9f_}t8&8V-MKB0>I17pN~_dzjfv39pktKxLPY8V18`n#NA>33rjULu886w6;bXi5!u?0{AM&))aJlVhm-9)& zZJ1DSN?*Uj1%briU=ACa$ZOqyh?G>cJ+{vQ(uE&IyI~{xf+7AWi#6n2eJ zgFXvd-N)+u9ZZ$J3Z7U51oO@>zaShUK{3|&yo%hKNKdmH^~8?9hq-ZSeq(j&ZF>tXzEdj$XFID0JF zuxNg*leZUG7Mg}yRooe@@X_#Co9{IiP15G)0;4&!In%5x z{wzwz?cY?bo4QUmXw&S-orSv;eqEWQfsMHbaS_nFMURg@zQe{_q`So9_WP00UxkZ& z874h;ca|?|e=dVA$(qRn#0tMC>I!LclI<&F7JV%6M<=# zYF(sS+^y%|K(45S-1dCtwx?e}PE1q#esGF;;=cd*nDq(Sy@B{q$t8go5pCpytU zd_Dg0@dCHqT6t}bcS<}v{O&G)Hz}c7^Y6oD7Jl~{{)1$M7@$#KxgUO3+>=Suy8oa) zt!+TP``64>R2)uRN~ogz*ghxF#lkk31@p1RO`yB4y3qe_^e~{kfO?__4SzR;plbU5 zgwDuwehHLNCHWyVo6`3fB-j0D5tn6Gf?woJ9D*zTBl@S52ltP*0Z%KfGm;sbuJWmL zL+YCgo7Csz(GU@thS&Vj$Vp|5~qByfCb%Z7~UMIvCg@a3Iq4;(#txK0g2iW zTxsy@rI>8*qN=)l9qb3|FW?Wx4s&2GWj!$DQnqGji(Ma~EfyS#zX!)F##_{UOGN)L zi;zi>cm}eAyCGn}(;5R3ilhAdQ}W}I<*#7myW0`pLr>uP?Z1+c-SHnoNUZi6 zPbYDq{gpJ@PPOS@C5DW-#L7Pq7#*RVi0$`kUuC?UQg7P^BniOWm0$-o5EfM8OVFR- zv-FLWpQP$}Ph&9G0NC$fQw7SO_yv`>uH!jS5*wcy(bKX1;(h+puzPlkGkcSop#{(W z1vj@zpohD1&|3IAb5bn>#$%27*fbC`m($c>eL`CqD8eyh^?e^yJ?-VEX=;-N8U-CR z1a`5$y?^kseYGeD`niHWTbKer_R;40faDOyN&L2jkM~*JTQ$IrlG>v-n{!rXM9cIFKqq8^p}`?nd28) zCMVH~GgPu3m0X2NVguJUs!Rafd)0fPt%6g$5536j{9_p3Tfc8B%Td25dlxL1t!2?l zmK?ufgw6(H)CG&cBMg0C^dLs9mz3os_G0~l?q7)m*8L0$8c4h#uao$XGUGJ)&l`mQ zdp_j+-;FU4o4RFSd}$7wLh=+br{BD8X-;B4SMTd`elF%S z7#}t>)450JSINj98+f6c_5J+MVDpn}8!IqRLoJQvQjyR*d5B_CeSodvXn%RDr_Dzb zMfG;hGcwp0-bc;?3De7CtuT{&VRbYwI_NP=Ew`!P=jQ@aa$>8>Lx6fp{Seb0wbXkzO*-%HAn|rUa~i7+Y-*+bnwO> z;S@35alZKaC9gjr>*u^4wXSJBHu0*w27h9`!;SSPQm5Hnn=-T4_rnBC@!YkIqx9Lr zW^UfLf-^ROxi|DfG^j8f&d&*1ALpmXx@P=z%j?1USw09qS7+d->i+|NiU;B6AC9N% zXZ7EcANa4A$f?Krm-8nMi7#6I11-qL=VCRM#-J|k$mWZ(slXYB`ksCp-Ct=az8LpF zw0YYpPwU4Rk8NuOUQBf_q6bTC0stJ{12Ea0gzSCIzhjg0p`NxFa_~7@+W}AOZTx=f zJ-}@{w|E@$H952z0G6nB`lSb5^y_{_^npp~O6;2#r<-Q3c$(tp18~DvL@tyM?++Wk z73_+QigA^Vt1jPiqW)|8r?W{sO%ULOec6U@lIEL+M_z_+iRN3T`IaQUAjbb-CP`m! zlfF)DW)B;2)M7>xQ9ZOHc^5uTRtlG|wL0*~Tm-VOT0 zYDNSw8^W;5rlpjZ^ny_V4PsA%9t{w3a0j5l6z<9754#vA$fj7(i*y-}pd%yQ$Jmd5 zMU2n4vDP(L52v%GB~R-{5Vt8NagFS6pDurlB-I~dQfGY3E#!C5K~-wJWi9d z6@5Ofn-(rOrZ*omW*pK>^NsK!wMf>l&mD_rg7}ALg2iKrMi=%`<3r=}dUPdY;aGiX zKDG9V!q-tY`X738kDPB~iiRX%Dl}1}jPQz>u(5S66D3q{>0GXc;1LR6e>;k9fWZw} z=Ql23oj>{`y7xt7*Vwn=;!S8RC^)GHQ4_G1j(?j7`g_?LOU!D(*f>_6Jwh+&h<^nw zN!9*r@M<;2qo}v=Waiy?bb2QPQ$%PN)s9w@0Jut+t%aoo?IbjFKdub}rJ>55r=c^hd-yY;MyKHi=f-kaJoXygN zTS_rHEQer`eYiQ=b3$d7DR2X_(l9b*B@ zwy?-isT(g)>bLKcfgYsRj?aJ#L4M{>Ou?btLU>Mpx4H)EWqP(&B6#2Cy_)q+b<)-g z_UG@wZteZ~W8R;W7dPU!k}HD?!6X{ou#N<$%+}0EoF36j%yzXa;WCJ``5Lm*xIt9d z`V+dTQChi^d{gXfP2tk?cf(aE2hk|y{DLF`hTSw2T$8!eT_ zV7LzZpOu=r>UxD8j#8p^57gB+)*=6Wv;h3<-RpUqHPpPc}W25q?HC1@| z?$2AjqawgWD!fV>0?(OoGcU&XyHG|cepldIQ-=c~HC0}I%mF{<5e!AGulKGA)~)mM zvmxRb5^WBAFchv&!Hz}Nbt^;OV4XKwhr?*A>%%y+Ws*f1I_Bl&XYV53U^pCH=dFo& zsgB4Rs7;i`4&e|3H0$LX&qYOc&ct3{ljl*;MU_&A<949ut*N8k!I2PJ z1E1aaDO6 zSJ%{ryym`TZ(}gxji@!XwceE>7@M~tTwe(r2~~~tu8gW)b#=%T1uEegp>sM836W5? zIvA#(#*mjRQ&DC>Haf;o%gzpXv9Xu*UQ;)&y0&K3Y7i7BCBRjr?nV_F6noKGb;Kia zVXKyNpGsGhroFFV9RDJft3y@MS}+A;r{c0AVgW)|uC`N!FrqH#X))WUjutX`8`a>g z4%e??1uWL-j2$Yg3`Ws{!X|}oQGlygsfNLj1hn~>nq2HJ_ll0EBpc4CD5~c+yK2$Yqxvff*~0EHZ{qtL zzHj6ECwwo)sOdUXY{jhUV9q?!N!_v02lq1%XFQS`tpRkpo z12$=CRrLXON3-Qiy=D$m@SQSTk@eaSyPNu82YPUTKIMqKEMunI4%jE9*-z}-X>v!- z4$tEu83k@gJ@*e`202o{T2&ivz2z1z&3HEA=G(Y)l;Ux;!1ORi>=*iY$KfWns*cXr z+FBs33C+LZ4 z0N-KCZv3ayDcQ<@;D4AwXYjuQ-(kvi7(=gSP(C0U6=y4zfXM!`m8Su5D&LdP&jInW zuK}V#Nw)GEiTk63+?deTFv{ZqaVp;d#3_FcWA+eBoeYSl&XCYu5(-M_F$ujPq2B`H zyd)&&<6Z?0!%>n0&>EKSyeu&uUWn712Z+;q z1Q0L#D?prHzs&a~_#&Qfp@d!r#HqY4aTk$~Vzm`WC@i5L0Sd9yj{tEg9WE1hy@aL$ z;#7VhpM>&Dhbs}h?f0%zS9zNV!Fn069LhjBU||fpmhxT6`%(h zbX4YhUqUybH}HJ5fOx(i0D6d(coook2E7M}*YSabXsPPUNFAmW0(yW!D**9)t0lA* zP%TTPl@JcK1ESe4dH|qiK-tPA*u=x3TLEz@GbI!Tw1MT@0*Kf9Bp_aIyTt92xZ#(X z^dtukBWkN%<~7ylgcfp6_1)@qF(C z;v%yz?*OV}WqSc} zo!)Y}nQy9u0)RL#VL-gzHbA^y9T2bWTYz|NF96~tKL0tB-n9~%4~W;h6cDfXZ-82u z?wfEHi*wo{q2~bAGfsaFh}ZEpAYSieEXHss1c=wW9uTi%Gaz2aPh>tP7TkFqZV645 z&>a$5C82r=eFG4$?YPAKRYKQZX{O!1(13()$C@9nceaF@0P%WhMUbcdNJ75_#3ers zh|89Hm06+^5HIn7g#H;2FR>jEFY!7cUdPa@%@QLdR1Aohr~<@GGy&ozzAJIRl+gQt zc)bY;U5yiByu?C4Jawsr*2&aPiF;K-m*tveBY=3>ha~i4nfkeF%+#wTG#ilMRN{Up zp~EtD!WYf5w@RoQ5HH&Sr~z#`Oz8tu!Jv;MG~!w_pBGRgYx6q*aUZb=P=J+al+eQx zdI}KlwMPK)I&!>b9bW=;A1gZ!&?*M`By^{Q76am3-3^HITn}iILjHM!O#Ln(PVYHD zoZfZ`{Zc}20OC}70C73~0!Z+8ompF{gq8#1R`L=cZY5oSc#l60s97Oi{tAe5deQYJ z<&l5_NFAnJBcZ8)c)l4DS|Xu)07V(SHGnvOjWYESK%Cy=68blp@24`~F`3#cp^Lv{ zN_iO|PI)XK&dXGZ^Gn>_fVf_oByPKe+5vG*{ss`|>h}^Fl4s(EOXzw)o0)7k0^(&0 z0dY+R0C7z=0pk396%gm|8xs1SgnkT&*ZWHey&+TIm$-z4zA#ErwlEH+0phKy1LCdv zT|gR3{W%~``9%pG0>pVaE^((MG~@=e#C!118yOYaC3O#=VG2Ei;1C^zDlp;;1|E1?nzl}c!dgqBHYxrA0os7gYsB~&Y+ z1_`MWYLd`;3AIS5RYF@N^oWGEO6YM3Jt?85B=n4gzAvF?CG?zxwoB-F3GI~7E(vu= zXs?9!OX#44x+Qc-LPsQYOhP>p>XlHRg!(0PLP94cbVfqwC8St0APKo75##dwA9-f9ipA6vs=V0+RDmljbj~hGtI25lk6kaFOXB?2* z@nv}^8p|q*`gB5KsLV`!A+$17d=+I8pkh$8m0F9thr}S6`E;i!K_wOC5q#bFT6CVq zl^2yhcj%O%m4{Y&x|8zM0^_~ZUaA!sI>Bd^ zdYtlHX3z5zVCYDjmFL&MbYnhj)&34JbR@~j69*;>b4@GH8DQw(kd?;;JKc)erIlwa zFe@;7v@k`$&?ynCR0)+z!Yl`7JLY9psU~1(FSu1|3o!YZ8(De24-Dj=%+{nl zuK`0FudO`q0#kaGoz7WcXmhibXE?wUNqKIe#H2iT0Mm_Gk;TsvU=G2eC@WNj5A97U z#_Y$+^AIo{NqKZ&wkPHJJ}}QF<#`^M6__1abPfVTD^d6nbsZz{8hf5|z|byGE6)h@ z(XB~&ZUTmOW?Fe}1;z`s71NsD}W75t7;Jc znms`Rss9(9oX1he6Ttr)qLT*#v~4dCK*JYIgMEl+tn^&e{_K+l2DRm#FmYmf-p?4l z+)iey6&2Kc6r1v>mg0umOB5E!itP`4Da@uV+r)eXs}{1bXX>^GwnTA|N3(Vk1yhnm zOrc<_Y(l=pQ_92XRJ~2iFO+=IGwl@VCKg!wpk%SN2+9(VLWSNoC)*k;>ep0?QOLZT(157G519>(8`{BrUsTP?omWM1@Ohda@$bXFFm@GU%X1m_sZx}DD43^~go0~B8B!USGGHvv zJ5O#+%us-5nT7WjsF~>Tuvi)4B%bSm{3V)L_3!MzP^#oSL#`mwd}|71XY;!}8STm6=+ut(swN9Lx8)FMPS zamy6)X)%NEqrQZD)x2&WCd;0lU$jmOwm;?x)4iEtohlf1;N@6hD_{ zP}s|Jv!YCAPb=C6Uh@blm=1j9v zrjo^opPMNzZm*ERtQq_j^K+{#jtD#F>S@0kVb-Q0h;7TcDmA!aV#~RxdS}bI#^@ik zS3T|1VjV+b?>ijtc-of@#C8wa{l4pxbJf~CpRjV#{dAtKv*p~%=nhYNPHeXW@xHd) zGm!W3}Ya8itcMBS%9FL`^G>opEiLS9n6}qIizE6l1`Q6+m+0B#CP-bVLVUXr6}% zetm?G?Hw!P?Gn^=pLRyXdBovG#Oiz*T+ksIT85^wv>2O23nsyit`R=*bL(7Yxu^Y2 z7RpZBN5Lr(zR}{Djv5b)9E%d*dp7ZXSK$%H_tIRXrSVN`9E0=CkAvH}C$*96`s~5^ zH)$sE|3e%9+8z;!Z!8660jFw6U+ipqbHn`wrzl(YTBE32pOZ!B_DFbrksI-aN3}fc zRMcw=j(XZV5q8UPw&=4q$_N+J0#0OWd>=t?5o3xMLwu+P=LV;)B%af$B1sQ{M2If6 z5VNMVI9&)U4BciSdNY_C)v|$CEV3b19jm{)Zvt9y+Wk&_w!87TBtBd69ow5lky*L@ zBTn(FvHn`kzn}C?D^22nEaR09av}iNSr?c(=kh!{41nHzNIUT&btvuQz8yHC=V_ng zC>r8v+YV#HQ87=uQsnY%`VF#r+Rqf8^E~ofDn$vU&X%)Y&*oB=w1+ALq-;Sz2BA`_ z?>SHFZkD0E7hze(oO67lRUFi2xLa`=t`dtj`}|#sc3NL>F!r&-^C+ivagoEb=|`~g z!rh)nZWu~6&v9s<7^MR(XOZ#}YC*&s2LF^8e>E{0aTSMADO&a}JmUGNLuMW0zNSDOx@O|=TJ%{FlBmni;(2KM^okDM=QL&&58d4}lvO*_Qm>~~LD$mDoZ3($d$Hl{ zevuwEBc3jTL+#ei^nHK;ZU~CyC~|t*iYX_85AycB4p#_Z{k5QpEp`^6Eo<3jN37WC zh&At|2qay_StLMLF)eoDhdB^WD?NVU)ExfqG5d_%i({Xl{b)zFr+p~3L;{=??(;kn zVW={P_MUO)Knogq)7MZob{xh7I0jg&=s_@>#EqVI*6_5Slvq2CUr+np4&&bQE$19- zuRz316j?iB%sxk#V>haM_%*$v2N9zebdUKB`t@`QYFggY2a4$Jp4LC0O)07`#W$nK zzCG}`F0K3+%RpUqL62U3Oq-jfm1Z+hik+<;p0-|88~eny;fj`r9nR>bFuftu{X0Fa z5uDG{qtC`SAszk$0dj|E{+;pDbZpP`SN{Dk34iORCv0{DLn)hUIMjC@5i&Hgqbzby ztiQU~!)U3@Bw>^(Wz2R5v$4Ik+^5Jm9Au<$^ROpSa34yk9fY|@_3t;Sa5Fr#Wd>q% zu`u{Z+)i6_IFb|=TbZSyTMqCzsoVkf6yozM#9}X z!|D0z_n>CI{29~qmtR8aAzF!NX4)63z7UO`F`RJO~r>Bl_Ni}ZZ2 zZxKbE^B>crM?CFWV-7pIwYRB4^xN&8NB4p$qJ`ekg+kPa-or2TV`DDwLEDhUn0p?* zsd0S#aa>fx|FK^81eHMNq3T!(<}=scF8tsWvzbi)N9*dOSBRP7|AwNUbvnAJpMCG< zitQBH!#rdQRqgY%wxJ5$zn!@{7H^gxebu3<2Di2>i$XTM$FdK}Hi9L?Qh znvYQ1#0nXYesuolW6ekCUTZivLeZYDeTVv5^AXIg?_wnxvW}1)1 z7lTtCU-Dn+=st)rK15|CvFJeNjn1ws9x|#4B&Z;b5Yd>ddVose-%VqoPzv!ILEolS zW-vCTQhz5#1$}g8rh@q0RO~M(i0C)ZVhqX17ZJhh1woW@R}kXg!HD)=oT83G$t>g7 zKZ^i6sDP084@BrG=!f}}_)kF6a&+;(;*tk2d z(rhev7eg>6)?c+FeGhU`?(ys>?)S;m0p z2;u+QH-pQxk7S}b5X_Is^bSJzX#1p0Ct`a`SlAL4&Wc5>O7u&4xO~UtwI$!kd^9h` zphYN}H@EoTR;L&X;QTuf4GdQ3WWkr-L>r9M@6ScVE^RlBG7yyMNZ&FrV1_zy!##J9 zS^P$5=^1EASTWO70Yc>FktH!PTQi-#b|Mso^-$nnEf_hV|TE?HNZ!xSHQN3CGS<62$`Q!KF#wg>Ci8xsZEA0XE^PyGK zgklsm9^qb+=eImA6DcN3FU``Ixw{||22*Dp4|@`K6*<=4H)fBc6PFuiwLIj=#~mwr zyyzm&rftZC;O7rO2r6JU>o6YWQrrEaAGcI+Kyl;fl`||-lN<9YFJqblezB0V%wxO{ zbz+zT&AL_yyMs%Rw+H6(5-%}-gy1#8&E%ni3zyJL2SbnU6Hjw*Kygsa@c`_Dzo)<) zPte;8()ELwS`_Cxzu+jF?|Ef=^7*DdYmSan@c*8o zDm9b5GDIQW??^!4_}Cp*reO06Nk|IDud{{nh~ACp;TT74`4%)sudR9X-)IE0qr4Yk zKTxts=w_18ro9*2`s4|i+aKBe4>dEEaY1kCA?=$@>c?>HO-_$-i!3?++nge{)0W%8 zYvDe1JP63uh99ReiYyewR0QtF1zp9?Ia!$2op_@Q@?#{5fxM&0<7xYl84fNL%$7FM z#-qYc&m(j!O^*UQ+mr>-!CjyQw)uF6#*Mo)Ldwi83+&LFaUo_*x4tD1b@%e%4lc6d_>r^8Fe*;a4f&IcM0=ORhezbzzC2 zBgPDk1n}#+qv)IFR$IhHqX&k|N`FzwvbWNiKi;8|XCV7YS#kuhITnPUm)7!dW z&?Q%YQVrHWiN6I0xb=dRlB_2F0J=FzN%B#LGK+f(_Ua_CCPzrL^CoeCJ46~KiycJ3*NiI7$U#QM%2`#Tah2XE+x}_1u_gIUbgP1w(=P7u|Bc) zLgmSBc$jV5_==gHydQs-`wQL!;b!s=&`GJ> z{Fn-C?5C*}hTz&6tYx)+p54=2#xMJLZGu^~Qv1m{>Vkowc7zEAO*&&`s-vAZ7ipXdhz{ow$k} zANs~|W2WOpNUGp9Y^XhPwHTijK0%jTmR~-gj>AK!!ZXbedv-XNYP;Dq=5+*Y-O{Ob zSI5phy!H^!yKmOz19wE<(pf=_q4znjlo5Bc2x5+#%~-M&n}2eDx)^a4yl8t8|7Q6o z-eJE}@FwEk{}V!qMG)DFA}ZBY*HGjf^XV>v3I(eW@8=eT{8_oOaV32aNi5XVz@s?X za#HXq?`WAqmtzo4h=<`4gjbe?>Q#w zMCYkXqMx2a$`n;157aa?@L)kwWEMq>Ny?os=PerReh4m>6NT3I+NlBQ&piR zgrrg+ax_GMDZNcD*b14WEin=q7it(sk;TSQK9WM@Fm;@o!zKw+3Bq_$kSz+}#gb+& zDuX>%jS)>mm$FEeQe7XdtMU@kV(V6K1Tn2BoE8&uEJ2ls`nHn7^VNhRnJCejQm*Hf z^${B_dtIgiC`WS3e_Gin>-^N#ybkQb7zd6%r5-a^=DN&OOKywTsNKh`oE2K@GsR!G zWL-mu1-eV~HJ`>?lsmDNU*TPvTBUh>jg_ zDz^ce%xVitNR^Nwq2m(zn}oa=;Z0#>ZwJKd-70anV5G)zQzb;t^LV}M08M3OzX@m> zgFckFi!r+6Wrt(pR>)E*dKk|~rvZ8DlM;Fs5U0FX;topam`tT}Ib7b$FvsImu9VO? zK%5GlPvNO|N+>8(w@4hFKjHbFm8o>Tn&aM+(1$YhHq30f*67qN&vy$}&^a_!Lh}J} zURDF*I%osLbsc-b3pYLV;t9zfhm9s|VbeM>?+0r3(i0r3*!aGH^qcmNRZmoEU~ zWp_*HC?H<8#$%Rv6%eO#3=l8j!aR>d6#s`qUjoF--X?K=36;y#)e=YXe>hjKN$9AA zD8kRJtZ&@|h}RL6(4&BOZBGN@7W+Fuyu=WksN^MvOUMg|mxu!5B{Z3O=M|=uUjxL; zJ}sf20ODoe0K|FzvrIiDAy2lMZyF#@h4#5{XsJw%NZeKlJt?7QWxm%W&Nb4ck|m)V z08L^Vnk8|IBvd6+*Gb&d68aYjwaa|3OWfNM`aq^$f2FCRiGa97l@fYDLJtArTzyaC zek7rnWa^&)O=jF*|9MFnkf1D~2PE_mAVFE;ek7rnWa^&)3Ch^8#%*^ZAVFC|4@l@C zK!UQwQDh-r;w72-CqSI?y;qsGc3eV}aF&&qD3Z`(K%DY9i5rTYvpnBbfOu;9d3u2y~d05&){HML1xN*_K2R`@XTZ-~lo+vQ;asRRM zv;jjeTeR~0GceneFh2r@NLqQ=KH#LfUPl(%fn-sB4;XsBZ(%+pI!PE>)S;+rL>X1$ zb1nF#XWdq*TYx!{lxHb0E%19*sYYOWlH}S9%nEoqE6>k>c_t~(ZeU71_B_7_rX>mU zIk2@Nsnqqrw7`Q|lotc@OcJI6m=j4D8pqIc2TQJR12Z}a^J8EX^caisJA_Hf69=Xz zDbGl1Z1e`J)LdXXP?1&FGGKa=^5|3wmTr~$IWR3rrS?#%q&#sdg}z{w%EE}LSe8mZ zFMJ!UpRC3Dq@NeI(oD#{Z=9;k)C>55|gz(Wg?Dc*;$!j9i^kf7g_;G z)zg$o))_D+#sv#oB2Yb_VWlFiy2&ZkeHI$YwZifH3P*HCn&?kp)P)4$m{jWGec9o-h5n} z{|oZ-r%ajR^-jv4GKryWXNJCv+0K`kU(0Z22ws?;^6kQ`kUlr#>-|6I%+Lz(HVgA! z`=@x2Geh4OGMIU-GectU9Bqvs*0x_=^Q=qjj9zuBGfTb2v*W>;1s&Ce8=UHw#8!e% z;EEY;hsUd%_?>y%h-17NYyj^)r}xF{#mkIk{dkp)@s)mkfy-F8 zq_8V`WkRJr7_)PXrP(7Iz`e0d2OLvXRx*>_KFLS@*iW# zOI_MR7hcDuJx2M|tFf(#3v1&@oH6R8_nR>>67N7?xL^-HQ3*W;oQ2}}WzV%)rorUF zYpdM$olQ(-(aS}4YmcP4oAx?UK@b16Z-nGJ#kP8E3+wRAqS=aK%ua54yhmJLy3AO( z1oafYVa)8u`_YiCU?4GEFU?^X_4Cu0xubu zFFozY_?1xY43*1JxxfJRJ)*L}OE30&5@1@}U?(A=(YAELP$c6$f?VIM4Ink%8TfUg z4T|l4x2JUiUF>&NYYz?CGL$hf0^4eHT1Mc-=00bv87vG(&fJy}-Yq`ZuGiSGg0}7Y z^RQi4TA{vlIjL|ay@Gl6a;?nm+0qLps6~C*S{Zum60Iy7m)a0*_A;xOkG=a{?8h!5 zwqc@PAqEXI;Y_k23Lw6>fxRm&2d<-WO1zqG#`u}*z#Q1+#P)%t#5V~+RQ|3 zfKsAm%g}f?83Oi1brY#$EkUPhu+h+dFgErTV$)Vd{N%=I9S*@eF^K zE|>Qoenu0n0ll_2)jt-YbD-15_AQ}PO43&^r7Dek`wI`l8LMHVsb7osYM)?tN8)1E zKH9#vf#^kW@~WRyCv2rjNcjx^wM$7R!#&RYY|zwP`uuFX3Ep&y_WMV9Z}b`54J0>Q z40h; zI2AWW%)Avw1L9@V*9wI}*%u1I>t|UjoQ!;1@pV8Zs1~1j_^xo+F;&3OPzFLOP%u6! zzWK;*mHH+yJ@{IAeu%3T$Zq9%9T;yCo%ew0KoKj?05IfDEjk{QXn{VgJoM!88JQ=2 zU5O&R(agg7{Lif`-49;UKhp#jY!AAw^Sqjdp`%Z>JYezyYfnjTXH8J8Tpg%Hh?I163NFb**_RL|*+TYQz+t8? z`xID{XR}nAn=GD)g%aCp#bjG}CbLkI4^ORxg3u&MW_j{t!dMouhiK!0SpFM9VNxRM z2re>&9N35gKJAp__`*KinQcb;F7Vy$Xt_@5xR|WVAfw?wNFfD(= z1eVi^C-TK9Ja#*+0@(X4Sy|Tgd~Kjabls7#zWZ%P%?Q8$C4od)-$W+sDSSBo2*ZpM>Y6F*t63O03hI3}BEaj@8l0cX@t@PEB=U z&?@4Qpq!iTvnCx*+CErh5~Y+c=;%xuds8%%T)lX%j$N}2xyG+sK+&4Ql+kO>A%~C2 z5iLTX0^R4LH3cWu6!0c+tKMu0`<#ppu$re8)j^E@f`_q%ZPrzw?zo435ZFq{RT>obqtO5oFB8t z2=AO8Ij`mthjWuTTyAn`+JO{D_j#cZ#(m-$n3cKK!)9Vbxjm#ZxqlEQjZH16N4%n% z&p8f*Ww3~KFH$?bCH<7|7&ettfNH~cP>;B}e6)Z8^Et+Udgw>nJgw)Es3G#r ztBEVNt{<<@bQKH~?n5%pwNtS>v)c|ths7SuQPj%|Uyc42t8x0g?!r5BHXN$nN)dB> z9r{eCF@Kll+XX(uU~^_R9hD(&wv9@=SpEjLL^D_0F*g68ABp4M-$d|U(C8D!|& zMAKpfSm`#GWN^mt`5Ty2W!(sJ&~_V5qnmpT-!3iEq2Jx4mF=ScsC`Zog5AKVH|Z>A z>qC^&M+aQoG(M!pe?Gl^q%+a|Jm?8xPjuMgo=_lw0!FDrFWW_(au+Ita9zG##8#KD zgMMslP&ijlqKf4x$f2EJd)l1}^aV{B;CRk@Elaz5J*L}wF?ja0zJ^Y%&p!wc+BTPJ z<08-=_V_ehlUws0H0=@bY~EV1G7I@n|95Mk@ycq&TfiNC3c3!<{xvw z(#&ct!N^=87+=`MnN6r8vjTQvF@+rg8wY}-A(P@o@z6`uMy97}NpB+~(n~$f^w(m+ z!bfV3^$f-Nh^PuvW5z`-4dd!+x=u&>{vn$07<#sSxl}Avz^;lfGUIT3AEn4XsBVy3 zI}sObl~iXP9X-ul02(+Cy3v1$?RO@&y?hSB!8dUGq$1?+?cOo*x^+L|{=;Z!!eUNg z!+KBa)5xrK8q6Iq(RAN>^gi4vuZVvYX|egE>2AVMs+x4etk!*_pB)6|D!NiE zm)Q4csrM64>*ctxD%go7=Y>wzjZjg|6xM$*oapi&VNC2leO%kW`^>ew&kh^2M~^)Z zq~oyYX5x{>m^Tp72@#HB?+y^RSYwQ`J4}c(>ZHYb7{hh=;rBo|7!^-Su+Rwh8H(KC z-e?GGtVifT(Nie-EFx3=BiaS7fkfB`kfbH1I2&l%f$|PkpI))|Q>ujX;iHV|t+6v7 zM}G+=&4O8U`N-Ds~0O6j+;oceao7LqfEi0bZi%^9g%fWv`&&Gdk z!E=TCJ*{g{%0T=aKjQP~F`lrU?l}mJ<9|+L1vHMQMgN_8`61L>Siaquc@l$D<0~f- z84NXP&Cl!2+Y=-8g<0AOW39XJv~d@bj#1KKz0|E;PXF$7icnA@J`|~aWDEF1f0A)S zvQWmZ3@}U2T=eGW5o(9KD`I6A7KFjdbOgU?rR5|9$I>4o`5*|6#Fje6)ez+4a&WcL zjp5%Z8<(f~Ae2iYbw#gFlpYEQspbmJn!R0U zmgzK}z#swffc!_|uK}|BubYAbneAcxf^|StlIkh+SQhee$8eg)NQ-c3EZ9#*3(KNn z%&hinzo3j7Bg9)IUQRk`2hUWG`yY{P)`#B=HIeg)=P)(cy4uau2T{J{vz6aZ@>2eW z&y+vb^IsbCobj(yL38}n{JiL4@m1glU1mD#GF&iE+t+}M^?WEwZp0Nyc87~eXb$LU zdpv6c-aiWw{jO~_wE@f+k&SyC&)KDBLz9>`%ZZy_}N5v+=y zrQrTR5nJ#WxAaH_o-5F`-&LU(AECGt_VIYsrJc|>%r)+x+c$@W2EjuH&z4W1d1Lli z7`Y~&abRqRAwzZEC#*M9DP$`PT#>~`o3K*)QnzHnK~hJ}hTQibZDZ23J3j#q16pj~(l5{$O+QQ_Qvgor@?)Y(fYQ^uzG~304 zOrB#|ZY+9!Qnvg({UnREhljsIFOvI+8Wsmho=Pr+~>^ zST%zmz2ZCz@FM-cWgmDFNz3$#B{idCyhPJWPK1&-c6Q@G$w<=$yK1EgY0b3ZgQR3r zq=BAfeyO>$E~MUXWm50aouoYV2D`#~2N|stbjbO>T|P^)&(@w-=&aF%)pP%3ub%cX z<2vpBfC7wJ(Zs2H3rzWm)HUc^_;u0IolK+#WtrUxr~%LshL{~8I>Kho8XnHFMVx_A z)NaDwxxdAbfRFAkqQ=$yt^+(%HI3ilk1v=W>mQ9Q@S`$U+neefeR$h}rh<(RI`6mpAvprO+IXfs8jQwd~M~Ugm#F>{4r;1y~lyf>`E; zCt{F|55#y0Bfrij+5NGuho&g}ji>bi7-`{K#!RfWyaLuv6^|aOUa6P5j62U4zNKNf zOM~H4Gq5gtTwj*0H|3y#Tba`^T?uB6)U09F!hU-X{Ad}Ykkk)-x zP$QW9fjKDL{p_dED(HyshS%R3OE@;}rX`B_Qc$VhTG-qRapIG3!RDJptM*f9L7c8) zHdpF`w0Lqyo*=#w?K1Z-T#4xO*HvaFV)LW zz!0vQe&za6>I{9Dz7$bwwK7;B?_Hhx0^ZvZh51j@uWUZ5`%mcQCs`ikVC$o{^=k~! z3;idXcO;H*douk~5sgb|Ge{P7B+nMwU?e(|XY(;!Se{@(56$L*94cCXEBecy$E*iY_U>S!JfckfoZabP@kllMllb;vLrN^Yy z=TZmYMDkZ>BuSMxJf#lPuf$UNLTcxCKZSrb6E>@D>%jIIT5O75Y9J);k-l$#h(^bF z6jjaq7{lEt&A{ZH2JzIWo_uhIU)Nxa(&CJmu8+g8l-l_y5j~=obAL#aLeeUq;6cs% zn!Z(VidLi^2M_Q38S6v3@K;#W_HOJXKUZ)HL`^4^#M3sSmH0m2`*NhjVm~08oG!ZM&kG8{KwQ6TM%9*8lE;vKp$+a z&-A1R_8=IEHNT+H@aSw<$;pDA*bM{yp!LV3@h&(V&&!9&b%KifIYG5YP$j!(6I%Nw zHov=CYjhfXU~#eZONLI(AO^2@)38WegaIlcwMBgQCxdYpr;T=OXQ=uGSsbCAY;y@} zHrovzE@Z7TSiDEt>&fHm$@oQkZTySnOu91|JBS0O0b}zaV$9zQrHLN!^)tYLiNeF` zsOk5fG44DQy*zQRp&1!`Ij zez956*nA$*?QH#wNNIQzLN|06{&QA=s8OAZRp02vbAGCej(p!k&1%1yFc_GXvVD z=aJ}X-3O0r%x*I7$3EfpScx|_k3^q2gC5ugLv4X+ICN{Cz zl*95c7=92WXsKnlXUld#rW?RI60C^&Z{H>8xje&0WH49=emrmz1wCya^J4Ci+&*0N z8dvH)Waq+8SYC^CmPz_2tV=h!3usHZSWcvS64pe`0gS~*5PTroHM!meymo!T5rE<}VR=;O7GRGB%119cQ>aMbK6(MIM?=0>J#CHfpu}Yjm&hCy-UY#!1U4p5*`6oo z+XP4W(hQ=SDU$%gcjliTv+-XsQ_b zPs|PYI42Gs_;{JebAuw>roY`TJPY#E%#bOg0K?j zkGC@1K>ij{E!p1oO3@@w3d%NHB-hJZb8`#oGahcD-KS=I(pse1HTjb*y?A|L7d?Nu zEHM+$H}U9&uGA^hBXgsFp@-x)cL(j9^5r?Ag)l^mjF0>_r}2uNKCrMT_PF0xzpdZ` zX2NdaOYr~)B}i`#HtE=%B!kJ>IY2QswrGO9DR{D0P-Ek{j(&_H&cOz4I|vZ+O7+rP z6zij^m%l?1yExY&G|!rdQde&#MaFvZD!O2J4ed{*>|q5vaViz-C3q32a;1fDEU>V$qnD*VM5}y`$M1yu7%qMX;DL;Jq?fR~f4H znq*^{INr>eVQHp3oZD=jthUJaaN5hq&h<8nW6k$R}HF650ifE-0iS{?Ex@c>!OJPpxsLwzJv9VKP6LyX~Q0}9CuH4$%RZGD9F z9Yj1L3aO%qU18=vWC&6js#%Ld*dIz;rvjlh4eGklH&m)k<8C*%kgbWVij2vSPDk-- z@usdSdH4$16me9`E8gd1>YN?iLvEbhGu59Q!YZX46FZVQt1XZe-kfK%1iLLlBm}m? zuHuF;YK0PbfF_e4Z!p5cXW0!7Ohaj66EYbf-b=^BxtTV`ZKM`0UtednMW{9s@@CSv zS5erT$$a&7RftekU$-mOBHHGWk7l-jBY>4FpFo5@WI2;>A|MN?7aFz=$W z=}9$K)syPb0lf8%b;1@|%K~lo58l#YZzGh)59xYW!WT4B-w8GbVex2z@H$okeHS|= zS7X;Y?G^kXnljsCn6+ZAt&aC@i3q~1ZqK;63zMiGfN z&}%)>iC}Pd^UkOQtE#+nXDpmm;-`J_!o)^ZDd7;k)7MHOeO1;+Ypd#RRK4^*S}Tc1 zFJrF&z6rgV`tg#IvcRJ9C4oh=1M?Qn@-Oq3VS_z!Oll6>T@*D0M-rRCwTOpC#*mx^ z{$e&Z$da!Rw!k|tjt7hfufhTu{cx}@QjIDgOm(<^4S85t6}`CD+~XgttExpLB^zGs zjHG>`q}gh+4z>rBD}ld&Ex>&q>4Bv|aj6M{4!ydP(+Th`u%U3oJV!uvkWsRi?Be#I zm_C8uEf58Pv&R|&PK3EZs?&~V#!JXSK7x;=B4&lA(;){Z@<~rAMq_yOtL|3ky1d zAWm-=AkGV&2jLw284xc^r$Bg#YzY+r;$`VsBZnRZ#5p)A^PQK_NSB$9-VA>i_#4LF z?au4{3UIu(#{qHNc0hAkzMT>}2#D8q6wpd0<=+7DvbSBLD2rK%AfUMnq6lFeS_6o; zRtum?R`!rgJu0Cdna_>rT~#dKHGp^>Qvq>$cSxuV5a(*r2vdKv0P%b!5?Tp}=X(f~_$sPvZF~-d7&Llf8!FaV zk1e*)A|@C<#Wp}fKtUo9p;ZhaIUy+_iOD&9Skd4~G}H0e*lM-6+TyLfS6kcC79j=1 zKrq4TZG+O57TcyRy-gb0QngAE$^Uuwn%OgR&Iz`+@BP2OcVKeXtiATyYk$n1{jv61 z>viZ~04+p*(~S|ZY_mu~QvpeSKdzxAfJElafTV<;)}h-qbWqd%x5oWhL+4;YPq0S;S4vVRp&sValF0Ewh$G?b2|AZdv?fFzCC8oCXTr1mTzk>y1| zs}$#)_c{E=X=pki$@xk^5~Es&HfX3t({0zdJsRrOp|1lHE@yOTI;W!LxFyp8Y8aX4S1p&5WA?)88quBk&G(9qX4-FE>A=l9@PiEy3-Xt64nb%2&D=w3i8 z6!aRPPb>L8_5s6KtDtKDNq*;QXgMH}lE}1pb|jo#-9LvQbFfm=5Wc@ z(8YkHW#?<$EDbFIBx%%YT$6@20xFZ#0Eq-Y1|$+31tb#Wgd7R31|<2Isi98*5-#gB zE~=qcKq5hp#{F1Bf6$>Bmpk<_Q$vdZN!eFxs7*r;Yv}8MM5=FT=y^br?jb-@)4v3C zgTXQ#03@701qtN)n|z*Ct#E0*0qlTt4pr!*dZX z=6s~wobHYF5n_Ba(|~CJ#+8{$l+-JC`IG@ukm03iARixw&PJ)@>BjmZFjOvfG5-O~ zR*VeXT+nUgHXnwHiJd;oXcP)ZqAs6{fyu&m+vPJ0n2?WVAu!u~H0yvVxX>HxUSJGg ztcQU);iI8_yj*-+-L#$uW~&eL8(^rI|Fx=L4)A}PYp-a4c z0toE$(OgJ!^zd$49|MM4k_?c1T>~(LKHa5R01P+5T$)b;Y)60T(yReyRmh9k3=B6y z@ZaVf2iWeTc>ymjU>!yy#3B4 z@=Qv?6!@wWL8D7jTvZ3?Apt zS$Q}o?maNFr!`H>#d9K!&ZXU2rEw;2CL|feoaPo#%BUX6ec>K?eRy}@Vz`+0i{=SV zwGoqOTXPy;Mb$c!HgtT2b2VN)MV4w$$WMu!D@td@-y51wL!nM+cwQf6kSSJnL3y^cyh%=*lK+3!Qi;7SjmA^6uA!`KK^?Yn%WL6d_776s--GU%NjSG-NwrD^0ndFwY5pR%dRlP?LJEr zmQ-q+if#P_H=ZY-iCfn$5rjtS^%Vu|sU2S2yCjLqtuo)DApME7Lqr)wzM3|QjbdFr zb`k6AYARHSZZD1DDj1HX3WH`X-%07dl=6k7=ATc|mqu$X~h-ph-_uuux?wV3`GZ(wF{lTF7- zLV=On>9t%ARLZNFbd3pi<1#VB0u$P-=fzc%0$QHQSC41?6EbpFU4`Dudtq_WIC;Jo zqvR`qMwrq7n+Od|*s^SS8YIvs>?b9iBHqJA5gdIR0Z)(*?VD8=d}x2mp~!i${wrq% zg7@C30@Fq79mZFn>-Do;jB4&1%vKtD@Gu^GJ3TVr%6_a5TQ0%9BW4_o{t*lVCN$?^ zgo06EjKW&f7u>rf00)czwf5-ryv{9M&Dh;BF%yIww%d4~5CLra>n>A{toclRZToaj zd+9D_QjRgcbtHE3g5cc!mYOD6X?H{Qjam_0XoMsJ3;8 zKpY9JE8hgI5vWY84#TOS+ZTu7%?({vO=OcUumj3r^wCV*B*(|X=@S1X{f2;{_2-iTd3*}pnn6;Jl@S;VD zRd5q@ud3lkY=SYnf%Q@zL18vU_=`G;gvO&xRzvlKiXN!5P`N`zd}ICEaNQ>+7&nk| zO?W-JBeVd`2&yvG(b@)()lnyAb@=w0HO3r>)3}!Gz@fIj0TGs$mp4KpkVL|vHI4Q4 z5u-RP%tH+|pKd_zU=hqlG_g9u>&naP8tcOisGr52Osxr5hofuI7LbRE>YBBy!I^Ex zO>{$jW2K!nO4|r#aPVi$CQJ<&lqFkm*ON^K8f_RFN0lEzaW-~66~3wonmjdOqlC@3 z>q&HvXb-AIhnWW2GGal=s4Cjj^^|HJPWuI&Y7nXJ8+ODTqwO(?!RfG1^U0Xx-6&2A22M5 z!mg)QBm1hY>D+};#0|^V7O}v_D7HIpDDp$N z;0-`!7`)-^0JXz1w@YUDf-&LzeTvdg*x5R4+t^+5Ln)ghnV^c6qqyOcqQCUq`tRz z2RQGY2ul8jdcO<#cI%kHK7$-}Fm;9_rQUBL{22<4yg&xZg+JSRe*i+@jNYwCgK0J& z+9DZw_R!}J-L1;u5hd9(C@+=9_n5=pJ%>KWP|ud2sq zP;`3{TLkLpeI}t2P!md;-M!l&>*L_XvY@ZEjV+cN{CW#X9*!a=9Fo&>bHX@2t7ho4nnK0l#;zyW`&OYJqibE@)^_cvLr)VzX92xD^cd{*5Y~ib>@OqZ zV0>Hc#xx3R!XbPl?XM)XvCxawhSzXujzP<@I1;`+jL&XW*B*3>K)D}LQkSpBH>f;X zg&uuTxVkY^h*ucOn(G>>@EHPBUQ1oq4P>KuGPrBc>Tn}V2;V^r2++q@R5KI0_is>| z)1?xK(qYkT=z0R`%}|GA{^vlcvnIT{NqraAA^FB=RTJy%20M311F1uIvK)%ZO%1Fc z6hA-p2v{xO2j@}LIJT3TEU^}n$_h-m)W?!>#4d;5fpkIDwrRc zr#MKOUw`}UU5{6xC+&I)>ffl5@-^j^>&ubH*|&$nO}C@EZx7XBj1noY?Rvbnx;)bL zeYAtxNY~@|-gkW~QXc`hmLFGDx=`f#~qDbJ0d6tjI1k~$|LpAkj0m%uCnQNjETCwwVuo%Xw&WGYmq!e zy`iSA0<{l@97e3``ablJDSv3)^WR<1nX1U&_4vB_HQ)!{XliIO_?!w?G^(yGwJL*k zaF44>jJ52)xYL2Lu(H*gi{D#tTeu&^{SDlEarfXpjGL!Ec*2PO&}nxzjC&LA`*82U zP5aBEM!@?9?y0yJ;9icKHYpy#P4hq875gvTzsF7M2IC>XO5BaO>G$a?xW9>e5AIXA z>BDImZtfP<;(ic!2kw)&S79e%3+_j8AHn@s+_ZnZ3O9G3j^I9xI|CD?%WzM}U5Wea zxSz#+1a}73k0;_@ftzc|)H4f?hOK4XAH_WjcPZ`$+*@&P!`*}XXSn|x_i5Z0V;rB0 zdnN9=TBEAbXpBMw-KdVD&~WvlfM3B)-;6)U{VHzf8cxfSb0lo~VJ=vVzt~2^F3VE< z1hXqJWwG(@dK zp_{KE>K_WOL_^Cov_eDlJSudnG*qdfY7NzDs6j&!4bf|Y0o{pPK5L3?yYiH)x=n#I*o7-*OkTifCNuW^EddB6@MlZuKOb zU?GMVlNlK}fxqY!Jy-IcGWq+3@~$gUmQ=bi-Zdp9Vc;aB=Sq_Qy4QY0w>|8h^5;EK zupf#-#P{FEasTmgz$$N(u+f6iL+vKt(z3lHf^~N+ftJ_0E0gkArWYIRg+GPH!ZCIa zxhUf-O{xbbj*%;H4p(~(5X+s(hPNa2SS!K!{X|TQem&J?a&)3e<^wCdz}j%sdZ3vZ*;I+MUy(Jbjvc78fgzv|v3E2Bs{7hNd>= zSREWKDV~C7X zxxLohaj+F^HE-vmbK(^|Xw4%AocH9mLYqComYGP}919zJhs_P4o?;F^jJD!Y@ML5b z!+2kYS)4^LJH1``cccc`)ZAY2b$^PwF{)CAHluCwGoDI_tuqR%e89SN2VbRdI zR`xYw+e8_4@D!7>m2H=-GLRwmC-vFc-7p?9G5%>1kAa-_ zlI;`6gOBgV!RevFe{B)`B?l*}-RLCHoc>2Ao7$(U7hl9D#?orOiL8GNawflI2(!&a8q(JX%gtR-RMU z+%B3r3ATQi&DvvJLaGmLp6EOwxDyOJW1Y$(2&KT$_x-^Z8VF;(=DpB1LRH?JfO)cN zUw=m1^Kkxj@Ux2`%5@|1UJ%r07rkVjAP8hy-V4o}4;yXIe|Awf9@95oW^L|_&&e=L zdr`8mr3(jGIrvGFf+?jxx9+*4jPAMVhPgBp+_@yZXRc~V=1BOE>W1ZR^AP+=!P(rt zfsD47+IoXKmArFR+nSrh!|xQ_Zd5-5h$H7^s5{CLZ2LM8@C)R$r*=F_eeGraIkC;x z5FZs}TT%;QrG77hhX#M8>)UF|9_-z#8r2ItyU+Fn;rFuLpdDp8?TWJ<-LAw0x6`B^ z*sGe9W6cf0elM#6#;(8|c3N~}9GD3*9_UYMQ0D$y&0cIJgp6Iv zG1PP+R7IjN$k)J!fYi2N@HWCY&?05)mu(+O;bk2wDQ2URkg5J3!;;Ml`^P5Pb{Pwy zJn{MEP8t7mc6`s-ai|+a%WKQ<*75ZwzdWIM_g zA*`6XhfKMNS5d#FuBHj=`dCqqL~*DWO9fm;oTJ5=e$J%G5qm2J=$opAXnAdW<{jSQ5s;AsC=ppOBPG&TSd zI{HSEG-w!7()b`Cs7HcJJD`w)o(3f89t9-nQioJHUkph2t8Y;D}a2Z8bdRT<9-ekkWmALhieY*65J{l5$Y^iAAVgLwGe?=E)Da@uck}G+-yY+ zk_JDxI&iZGbZOYy3=DK!n%@9XpfSlaiYUS^XDods&nR?|2L5L=id@Lb5vTtevLDYj zqc|5aolEk5nZ`J!F(C66W?K%oma{v|=n5(@NHrEKBm${XAlvWrma3H7U)H zGAwsjl$A}I3QyP2*z?n9?F&yA=T*3p43O?QBX_l1nJ<{M?1}RNA2sI3p|>P zuG*T@(=s%9W(AEFuP%(M!;0aIwB3dk3C^t$9txcO* zqTc7ZSBW}E$hq_^5LzLr^hNTgO}1mW`XVbb4dW`+c#>y<4QTT0D~{Wl>A^6R(f7Lw79w*z@%1U9W2S%365wsBcLYH?C?J&UL zhXbh$9tpv(mq|YvcW`w0g2!T`I}1&iXGKOSvcyFAZFCZuZYRRt#!L6F@So)2Kkk2l z{~Qm0+Y-K-ah+ZMcdr-B7l*5t6`mwdqbajq5{t~P7iF>4UKRM~>x1WsQZY}c4>+(W z>W>{SfNNG~a%o*)txq#w{MgF=k429M+bl>-`-slO8%95W(EPG^GW;_i-++QCuek0qo4Maa8aU~<+%XeRPba54AWv%vFW`{5z!v~_*vj3326c{2KEBx>GE zL14bocBKZEtcjNp55E~tBanP4meazd27ZJ`QgS5frR3}2_D_TVDRv*XN`2Y-bjU7@ zK5nDfRtI@w5rVvkAg>4IS8@|UHz;ciXd2myHJ5>u#dp=ia>|dOOvj{Ymf3ALqRjaz z7<#L5%NefLMZ&Q&Ly_BH19l>^-~6F7%Jy=kICdrw{Ydk9BYNhl_kxYsb}Fw{RY-eY zz$&5n{?t@%W{#u%^!Maa1ZhidgY`p`kfB04-9_SD+wjG%f2B&Xgs=Q z&qh8#i?!|TbCsTGk+Ll&#>P0YHRi%tS9rcM6yuri8cV~GBvL2~q`(T_j-tfFD7 zN|=^AOMIA{iZ<3^@((6wqw^HL8tLiLtJ1?|61MdtDmmNsf^3ymMeoyLc4(cWK=!kv z+AAu+!mmOUg>96L!wI8CTX)z=*Qa=#z)y*2<7|F5YFLXq9|7OXai<$|@%Ll6vyJQV zmow*dbqZaewRoPWLOE~!pbC8weexkN*&07<&ZYZdZNX}gFOV28`QRx#WjWgh5Q zN64PNRxuk;Gwy)l%&JTA#JY89!oc+TXg1=B<5`!c4VVJ77ncw9AUGyRv*o? zz;F=h()^bl%jNSMVETPDe+8xioL!m#!Z})U`CN#n2DAm2W*jgFd^GuZ3L%P1!}SAx z?_EAOlLoct(%c3Nzs^FFyuMP0n&Z6Az5e&sS8hcqBwt$~9WMwn?2aupgq%y5d@Tvn zk%akS66RM)7+M8$F5&zEkCXz=NW$EdgyAZta|!sM#yD-27Q^InFm&GOVv^75{t)43 zS*MXBF22(zo}+G4^(idpTO=O}?;^_7X*kQN*!aFVeiG-Xm+vr*Hz6Ka^vYr%d-0Jt z9;Y2yQqef4#yn?+ygX*$=w9;o*DLF^Tqirpr-VG5rsX;3+!DY1K4z0sIluM{;%3V+ zJ9PlcGl)~GWeVvG;arS6fOByvhHv1^#V*AJ>r!$cVi^W@vzz8&Tt~=_pE$l#>t7Og zu3CTcjsDztsfS^nJlOeV(i*Q(H^;cCOXD(kb!YgNq%e-(GcexLbb{co&Q{VQuww|M#*h-auZDDkiI zd*y1WD9c)rR+GVzf_VfEC68!_lJM2#IBn&GxF}=7E3vl&n9;?4K4dP0H=8kJnD;WA zI6&86tUT`Gg44CzQFv$`ySd{odfEN%h|3O`al7>y@UDG`JtB zQ3G>=_olI_(H?@SthFI*7N7$hAmCyQw98Jy?iDby@G#aenq3^BfTGV$fgcTi^FhG{ zxQRAz#+aCvkH0rT7qtw3i;N|J7QiOf4R~IFzw?xREa=y!{pE~E6EF&{M9N5szn>rz zTxs~{Z!v~JFGKyVn1sEo~n#`#H&&?xkkQ`i=9#auEt-CA<^0c zm><={hE;=64*E@yrW{XUCI>Dxpo|(#_&Z5)7k-Z*WQwx> zM#$#T2(FFb4!r_|HsW`Kq9-+F4k0G-5zwtx(uZK5ZYlQZLa??-&g+p%Bhm?}7$GH< zU?_Qol6WTe9bLI@vSYaNs^rU1dHXw(Tb&XLCF0@}5#y^p`Qstorxrr+J5b{zFxKYW@a*2hsd@RWe`Tm)TkUL%2tSU0(iq&-cIh_w~#Y`b_!B6ELo{T zw|$OI+opOA_948^!KR(ta|M7IsW@D9^)%0@!lMa^;X}&)aaz6|!`%bB18 zneT8$=rn}N=8D_CRr%yt*UmyyXdQ|a#LLp+JC8%@h?;%Sp6${KkuzS07b;u5wr3RS zd0|(8$vL|j+H;HSA?0=cfGdIGy#BFmP;fPWz2*2Fh#-D{R-O^2jo)l{FJP8Qk!TeZNf$?ucK9?2X8h>^n$n3(f9%9hz-?Um8*we}&mH%f-072)G zKI+syEm~(rT!njf`mhfl&53mfVrR~c{-;wQ!Qj0wgV{ho{>*rWh18T~s^1<}N{M+< zd6I1^Coe+}F)z%CDpn^akNuBwvdohcrZsF%&UbP$kjE&`Fzta40~F2B-y`mB7QDTu z+4?lXnHgzs@rU?~!a=Fo-oY$IvWxmgYD23d7f`The{knR^T4)>o0wsuc0NR3kLsC* z03l(v$;~^|I6qVP&ESzX77y#%xBGQupz0lZ-Q3%Uklmm*2FfXO^WOs<)P34}3aH?` z6T7*rH^6j7euiJp@Yn3{Q4D8x-S7`F{7-f`Qyxgy;d}X_??%Hm2L6hStMsU2w)Y(T zVR{hQ82BlITz;1@oMp!Fa~QruhsRDW4&L)6sN(KrE8k5mk%33Z*!~QnP{z`Ilv6N^ zK=m#Kvk2Vu`-b>A!JVxvXs{XUu%S8BVc4)5RBvV;85jXpN#A37MT~9E3}6#II=A`S z0Va}#5%N{k`(rM|}t=|vOcm8L@bP(z1&(huVl3HYet z2VN%X5y1Pr+t8GjR%8=K0-#a@3R2%Esb_@jR^#c;z+f!=r!i-$RuPlR^~l`N@`XL~ z6brg=#ix1sd>-C7IWpK%i-u%VsYs5Vfm2@Qei1+=%Z)T6fiHiO?=#MSMC>vrj*Oegm zCX5&cgwc)x)sD&FHL+78#Cvq?)MdfeYe2=wH0A4!>?typWvWkO-<=H0T!&+R}+(X(C{ zhdZ_SO;w4iI0nY^6@-h>yzES39i-UXq-Jj2PFw}W7} zfXnF;u%sJo=>o#+f(U6yh#!10R7D5O87$ZDBb`!thi*;Wu_=At(aTi|mh3bUl=OhQ_ca`=7uR zfbWc2mu4Km^cC&Yp!0pTv)bQ+14@YP6gR&IkT2svhRBI@WOm`@>G0C2c8^jY!+|L4 zV*7^?M-N)Yfj^7qX(@Kqi+P!Yht%VLqw*Y~{sOfhM(TaHNWE`GAM$qI z4}dC)_`riLW2Ip_#Pn0dLaAoQV;lg-x~f^kszOno>KFRM_K{RX&q6J! zE`sM=!7X0&Dt_$gXzX})D_pD}i?p;JjkZ}ueKU$OA|Hb6O#g6#)NDKWyr?7?{^8-} z6EVVXT@^ZNtI>~x+!OFDyUqTpK(ia*9t%$DQq%OFM?-(ua8aLl_u zfG_2>)LYtcCywaGXIq(aaS{>c0NVdE&xz(l_#fDZ+D#Y+Ogy$0-Fwwwa1AB@6h*&d(2 z7~3D%_q$PnBY}Ovy>o_II-|#1Ur@7Xs@vhs{WN~i$lVUY8pBr_uTtO@Yb2IpZZY59 zaxLF_j*)`*aH0*VbO+K0>6Gv5j3+&rab6n``?-TJGH84Ju4P8k#~=%8wEwnK z&X|!L6lAt}hK10HWbmsJG2aH{U9(_IkitK?>#YZ72j2Rvd2&MUq5eRxWM*Ig=$g*A zA^wE!4t9K4lEIX%=oq{@V>a@?zaLndLnnB0FHXH ze=j?_c>XV$FKbaoJZ-X>IS!np%12IN(ZNKhIVa7U$92BD%#X)Zml+uN8=73Zd2rXd z_D%x=9#jJE-}lGSH7`@935S9$5s;Wa9{jl5UaZ+^W@#VaHkO9{=HPuR?F+URK$L;6 zB8uB$p36r1@f=PYu397MiOe&CaoP0gqCI>mMZo7ct>FLZ4=Wvntf zBcHl+0iXt>Qw_Ewf53wg=XwX0^?~5d2x?39Ue-(Sx1r$p5?;KvAl=S1MAZ(TuD;59T6h^WLhc$%Qt9g!=o5T2yN*=gvM!MK_23l!dc zVGojaRFfR+`c0=s>(R$vK8v2YlZ@kQ7gkA`)(xc#7eXs? zc>VMg@fasmUIiO&T6pE1SPs=uZ+&uZZmzMSguhqw&vf;tY{_K&Lg$Kq?1!mFo>E+= zUCc%U8e`KZj02 zyR@(w!1JVZSr4DdupLZ;s=jzAHrv2}V?EVtHW>E$;JBLha_x5lzNjnVk{&JNW*jzH z8A5bj-RdYP(xc@8oMsr0vkvRZBa2|@v3w0oL{ha!hfaWrO8cep;mJ>#LhzY8fb8x8 zTR9#9c1}tYLt;=t9e>as%wf(?UPiRqS||@Vp3R$J(zl_y9&a{PF=>WZjzzF^D(V|H z(I6sC-iOo)5S+d!hbdcSG1)QXjMF8RE@S$J%zH;^G%vwb(8Wl#@EE zVjp#_fwlcBa;Mj>@W@mymaCQDbVch4Yp92fNOE&aM@T$0RP|IRO#F0kGv0`f3g#`# z<+zOU|E+o;IbI>2+7&w%P?QB$4}a&hx$Ox4+X)z%HfepdFE>+3_X z5Pi0O4!-HDVQ7;6!jsS8h{JI|cF5U=+}t>4cS21KcK7TFck^wRSc($1tHV=9!_(TeVI;7z9mk^?vl$|9(3QI}8jgl5=W4ImOU3Gk zNaUn>mTw50`ZU(U!ZywfAz$*zF`RdtU4`AC!j-<4E45_wbb;6PY<1~Y2XthW>1Wsn zt%Mcl3YhfVggl)^R=gXH<&AtVBh@geUPTA+lwTQ8zvYUiNtJlLRh3r2zk3Z^Txk49 zu4wv5Xnj+NzZ1aUt#W3#Dq33`8t-X6B=NMF%4kC^d|kk>t=K73?~ls@w53bu6qYSr zHhWp=(opV3zOx&pkK|{wl5fhw1#>`Dwrt7l8Qt50ermi(WnTEp#-;Iau^Ns3;p&==v32o4L!Bn{h>}qLJ(J#6Keu+ZGAc7 zD5Lp|z((S9HA$%)#LyVyK%*pR7^|SxyNzQG&lLh(fO{40X53qGcjE5DorP%u_mWF+ zbM0y??z3H;2=BvPz@evo(LN~0s*hr3(1I|^@4bf8M;?ty0C(8ZjSDq&IiS_RWg9%9 zA)&K1bb}79)425-x<`k8TjO?U=mi~0|LoVObSD6+P^nGP&^0=Ao`x0znyX@L22`jZ zZsLf1mts~^q;TH`G*3ZXG8E`>Ktf0FeZ?yD$AIQ5=odQln1(LG_(x(~rlG3=twxM& zW46XE)6ge16wwep-wBroHS{G7eOE&VH1vXo=#f(54ru6Hv?{^nYG}HK76KCaHfY>k z8lvAh3EdA!%KnfJrGGi${3lKK7N7;HgtF1nBs51uw9YI1Dga%l=P(*T84=5zwHk^8l2UtB<7nel=xD7|LNCVaFSyG!#ObSqZqm3d8hS{Fegn`N zCCdRF`jUqFG~F8-cUnVP=C3)E zLB|2zsGtvC0PEHY`Zyq|k75li1+-L!mIGR*poam8EML{o(||;lX8;Mm7XU3#F@6k4 zIG+F{aZhU~6aBixy#kPg=4oiQ4lM_CgW^}CL!*Esm-ho&tU{j#B)QxJNYZ^#Lq`Eg zj(9+zRK>Uo&@=@V0=h{-*8!4zR05Kmw*eAc z(BA<`+%fQhB+%s=$^#_)rUDXvvjGXe8#Uc0HB@kfc_tp=LnB?_Nz82Xu?#vK`P`CFu)*B<>*%4FZz5 zBQA0zDAv%Y0j*SA8Z@p|Lx%tf=QJ#w3g=7>eGrgvUZ-(U4VgOhzclVA8v2tC4PER= zl?!N23ZLx0rJNk9@~ z6d-AT4H(}}Q)%#2qCgupbccpGmX=VChy~(VM}h9sP`ieBqFX{A(a@tB;<#KwpU}{g z8hTno+cdOYLtOrrxO+6jalGITXy~AZUeZvnh7N1!h=yL(5a$HK@0f=AHFR7XoP>zN|8XBje@fw<_plY4|6-7nthlr;c2T6vky<5KFq6l>hodV!c!LBH8(9j z<@zum!&8Y5Lp|wcAEq2nTYZ=fcRY4*{)0?ala&1=ALJJ{tj0_!eW_(r>YE&&FSRNDbL zt|_GPVW?w@Y}qu)C)m$@KfLUqY~1UAc7lDrj|aJVPyDG|1R`h?oRRylFeK!KMVMhv zxi{D}%%#-D7GT)>lCxl_Wb9mm;YyWr3Fi4E%63X<66WJc7_PQCm*hQ~gt3w^-%i53oP_yH5@r;7 zEa#H6K9q!+orEdT80W3LISEsxF;3eslQ7@V81gBjjao+-{l0Ja(=;`}MU$eh$& zFC7l%_x@P$v;t#nHgAW9-nU#nv_<0gPK?y77>^;Isne#wzL47Ruw&a#YERUL)wZxvmTJq$%WCRm7&CI}lJeR6 zL9{DWxwg#R)bvG~3gbmiq{NLOFX6N)FptwzC+&L@YM?2C{k(=rFiM1NdNxLE4^Emo zb;@L59EM6CfMG7`ESpQdRS9 zvnubZnp#+qbQAIHx)tR6;!M37#+y=YMEMw#$lbZ}1x*thQvbl_moM6M*hzAVAoYHm zpWHDq#fFmTbG{n;uuW2W;YL-IsHnb)WG}?rqBQ+Ik)n;8olM3+L z7k7knHZaA4m94CTB2+e>3h9tBJhu`1$LQylVmBBYiK>Jh6Hqsa3PI7v*)AHmrQyh2 zSe-$<`npBsO=~^Yn-E%4waJdRpsuRkYp$vo@uG0>TNf#T15ju(6tD@X#1=Fyuir2= z-@%K`Exa2EBF|N(r54l|Z7cwZHdW;{USnf@>MyekCVR>009^LpVHpedKt1v&iMXKB z6>_dJdbTJEjUKP9tYIuxiF74U5=pHu;7K*Xju&bVJwsyNmq=f!l6R{^WLi+~Y9o|D zwZy}_Y;|}I`cb8765i+(+5)_eP_u!9u(Q?wFoI9k)rR5{Ghu~}Ho|)xe%^--Wrqdr0A!*pT3NHcvIcJnz;*SN0;;A2p&K`q&|x|hpz12Z z^PCsREwn_Ex$L{bjU+(9*Pu&*QL(bJbxmdKosQKGIa?>Gq9zfj77M)uZqf^P+vuI% zUiWO%pXdOG*OWN|%)x%g8$%9H^h?i?wB<*rpHCL9GJl^s+AlZtw^)!t3Ph&2^ z>v7y6qhytL-k<_f{Go*=uk|aE6r`YQ{ueBZ6kw$J1m<@0Lc$mz(nxJt%4O+69Z@j^WF{=v+4t0XPfnKu1X zqatHw9E|?;W_9Qn$6cM1Vmz&z72G*z1kb?A$vUV!<8)|nNBbRQTa?+BmDhXG7JJ5wD&MB1kMXrFhw6*9}YtH<@>>O)Oi3uy+VqJTH8M66N z>v#Ti^M~h^%!>TTDyXzdU)}ecw0M3-Z2v|xdTj9hqkj~cZab3$E;H7dWnOpUnxbQo zt=9Yut0B|;vHAL2uWWfM6finR|2l%_EpLrH2k_g`13hZwKG;naYxg9A7==^PMzUfD zvT<13qxrp}(3-mnD&#>&?Yn30D#~lktpt`Xw)*+lGq;jIc61+ql!w_9JD$_>a^$12 zKL+xS26wz1&wq$hIcUB=9Ac?vzdzQMh9jm!V>m^I1&lvf%CLlHubw1@9A)#vDSudo zLG9noDu+B-@i`^I9ZMFh9K1(P9_Wg4^D8IGqZ!t%DVP%)H6l2G?R>HcAw83FmWTs+~>_bpao}*E(7#E*gVl~m{ z*O1a1$Ei$HWhXL6;qs9yQ{~iKD$J|(#qlT<5HSbNK@*(si_FwE{TbyFkg_1hdI}O} zp`^v=f)mT}2YrV%5P3RN7ybH_3=%3YRh1~t18Z?Y!Fj*sWRv+~{Mk;NdHTUYrtzyS z$GLoDwr&H;d}urVzW#OAJDX^5M{I$#5hb-1XE09IZDG3&w)_Aj&AUl~hp*yq-kavn z&DYHz4TjW7hFDi%`d1hnyk`qStyV_2npNZ-Z^s|ngGc*_Q#`H1+}wu(RleBbtrSpI z1GWL#G`CwyK$hzhz_46-dVzwnfr3;dR7sep`nMqdmIKV0Dh9EXlh-LI_2e?--1Nu)gXyzKo%Boo zsr0iXefBG=X!#3H_)Ou%R+2mu5&Dmm$2-DBoh;7%$K+Apqggm69NaPQhFO7N%Qw(m zf_Hxqe`nz!>@UEv`OZbg#&h4Cw=g5v`hGMRYuBdm>zM-gHAVPxe>g)6#ruWb}fbxw-tx^vq@FVOTd6T5aqq&Fiw` zOUE)D)k&e((3KHv;}Z1Hm=Ne&JAQ7{gnB<_6j~k3qMc=P zQ+D%A1DQ>cQJP!O8Et9C6OL2|Th{=984C1_Y#8b-h7|VkJ4$e8A?6*1Q#F z>8ob(cvx*Ui%}i(7WEXX>gXxXg%n0lu_}49c&s(A7XDd^r{iE4q}|sy(p)?XZwwr` zs3g#db(zJh%;EwJGJ-7=DFn`;VZhPH!}ktNaiv+jLQ&A1jCsUb*%!Z|AU+i7S|qOA;k-sN8gP&JW(BY@DFGPxVYRz=-P{K`OKj&`Ccr*OY% z6SKMp4<&z()%eJSMXrgDLrmJvNbnV6c16y0Pb+#Q#wjftm&ukBpqbnxr#Q`?&w{E( zH@1BLcyd$qj%j~F6z8-pUcQzByozQw^AaSKU;qLwDcC~i1tj*)K<@ejLyq*bwIP5FIN0(5h_~ys z1gw^T3>7en0b|&Y9qC^n0URX;TaM%Jt_c#5D*^2BgDtNxV3q`2Bmw-6!_zGTR!P7a zGz}!qF>kQtaR#(X!0#o1?Karb#()PU;3WwN0TpT5^@JdI3UVBgx9-|5$bT2)cp?|< zIv~inAo;b4j0cEP|LB@OE0y>Lrh~y#pO-as%gk3v(7=v0LsK+bM*lePMo!%FMyjB70 zyuzuHAN)4svWX71B*s19iTj}EEpnQW%H+UbP@f{wwc|h($xUQK&4sgx;ARP4YloO6 z+JsBAB$bhAOYi^+6YOA0O3x7dCsobv__NE&;qG>lzPRN$y8=pp-b9(y@Uen%!3UY{ z$)U()j-^3!B!`BKCIdx#e#HX4P{hdSv&BK?_;#zFMT}tiEOntj!_oZM@jH-y8cy)D zwJ38f>|Z(&8CC&s0J!Kd>lEYK4-DS!&NpL4hXY%>O3(&jUT8+qtLty&v>8Xs7aa@y zqMv7?5#ty9PO*P*%L5;?qTa}j*5+Owh==PZ2pY04|HGsdZ27Tb(ib>lc3bUg4qMb4zkfPkp6E+$_*#FF8`(VtA?C8J zqy+p*92h5(fk`G%u6lueB>$bGu&XSpC!z}Bz46~uYx-HXeC=Bjg0RP+bVG63l zJS2Xo&7uyg=*hOyj^NJa1;L$BJD|$kFthC?v*=0lWLxQz!JV6Nm&~a$Hx`&ZR?#DF z>_@Dkwzkqo5F6a13@|s$A!`frfrNo8qTZeY&Ipac4=~0^tWuQ5UQ1*6!#W(zhm=T9&AZ|o zOX4LZuYbL}nF}j8$4=+s{WmL1EwJl?<_uy~jZ<|4edv-TCDIRW7nrSa@JVO>02XYr zw;-+Ew6=nW48!wvcK8j968;by@r{8>(Asfx?dF~`+AWYlW|c1k!u&jO{YRd)?fWHR z=iF7OsX7{|)X4O~J@N|?cHS)Am!pSfmE=)R!s88bg z_UJJ3_g6O!a})pG1pgcCU$v$;PjXJ_lHLJLqd)s6La_0gu1@`|Ka_lGT>wq1H31-o#A)h|87|ccq5z0W?){`3fN6_a7RfM>^q09l4Jyen)la zA2jrqrc1}iR??^i^a&N?n8wljoTNeTa{^s}l9M!w0SRughRSs4ZGePx3m|H@rW>Et zI2w?V&?A6E(mp`K@3@9Wpspmf>3}503P2KL6(EUGtD(CANsNPlBt}0ViE%>Hoz~EM z&;}&Ni-07?uK`JnKLC<6Ue{122CEWdJRk|B*&Bft=uqlf3O{O-7O2wYDZ<$bx>-X9 z014e6014eW(Ek(Mhcz@GkVr+nWJ&E74Xx31cWT@{8u}6-k@=e%_ai`(#!*0A@J}~R z0g^O$I#ALWqoEH15-tTAHy_X(m7`B-Tm>NE_Zf}*qK1B{q4#1MFKr_PNKzXQNcdd^ zNaUNTL+5MUQjIIuxLS?7UE^9c?h6|C6^(mZ<92G?^BUKyalg{I0gZc0ts2?}Nb2Z0jqB0Sk2Umb zP1g@dYT+FndLB+2N;`NjAd&ep4P6CD(wL!fJOe2)7Hizi8d?iTVtfYB4As`|2P84R zsOkP)L*D}=F?ItI`F^QG-vBgMwYu>^N4_FJg$h@xakUz{1Ca2063|sjf;6la6{#4P z0h*_v34n?f#1oA|R|jam!X3NN3B3s46e*W+8p;PGX)M(^p5YU^wL0{9@S3UkvDf<; zpmgJyhWa(co=`$hXo&i&f;*|9(;5OJJ2Xv085+ve5Wj-LC0j#dHI$>FkcP%^v(eYpC?cn&P#Q%=2qbj7$E~6C|oOXH{*6O>+#g?!|;h;Z!3IeKb51(dWY~28JUMmk<4Qj`i_bOB#Gp zT^b7*?k2iveHj>zY+RcE1ZJxbvm2O7ALkc=Va>X+ehEy8kA`c`?LM0Gk%L?x&85I_ zY~=FE2d3ReQwYofA7&XaT(!r4yTmGi+33SWfa%0H#^ubl>1JQvzXS|Nb}r4=f#G7J z%b6?7Tq1Na&jZtoUcrrZ6d1T_@?f~Q+~5)DOSH zPqR+V+&r8K7W!z2`D7BNCJ7Ts!h9hK^UWm8ejny1csh$Nx=e^TLBq_)uT1Vy2T!EZ z%HR@^Lakc@XyQvxrOK4IMSD6bZeF!c9JHC&D|I={Ivs9F0yQ}lGHrF961BbUq(y7q zr*SO$en=u^ejR=c9A3d*xT~3~Pw6*blzz`PYxdITPZNi?pjQ@z>|*iFV!iZJrn~%= zGk4L0_hxUp&fc)|XCKFDE`49koo4zWY>%0~1TV`ruNQ8VRY{O3bP)adzBXJ#V%$XEOBed zD66b#s-RJ^a3u+v%47)(s{J*q5wk2>*BGv{qiP*p)vMY_6~M}PHoxu!u-Ga_Vlg|1GdU+*~%`D zt}LGH4MSJ&5$a)7&71?h$z@QTgm%;U)NR0CDfU|6%nMtXK0Q%Lqx5V`mbgl`+QWzF zk-_IkhP5)&D$U~FWr4YG-*3|6X1&pkCYhGL(EHw*+?_UHeLoRhU(Y@+*y}{mQQ6$Tg^ARyGv7R9-)CCzd-| z^2%YCR};Xzbt2UpL(~fHfM<}Q!Po5OAg%3~zx^vcy@gN{&Y~YlsOJpP_dV}VtP=N!_;}6<5 z_gxnqjzcM{AQIe>KixdSBHP!Oj!L3#fT}chUbGG!fllv(k5uDHnbj9JL9rpYZ23EJ zZ$pRh1OUbGckmzHm)>3UJ95ZmldiVyjmQ~4WxRvn?umyq z15R8gO-{yA#=XTK*NMk8*+zy<^9=;jo56kfMH$9=VBx-?VaCZj8(1E#U*|4z>EU?v zm?{Rc^%W-cvw$Ot4wSsbV0K5p14&gwdJ@5uq%${lLmFsCGOiAeYBoi`V`40C#=M*f zu&kl-0mTW`bGY@_ItLBINsKBUXH9Gjh}#|NN8XM4*AR_*mUdQFy&L@oKmE9Oqd(72 z-~Vn!^)+<3Z0{>p4g3UJ!Rmz@*iR;jdiin=0KNMh)nm>n4DKixyS6hYaL{U~w${&Y zeKT^gRZy$WX=Irv@D>mC>2n?|e2Ah-ve~XSWX0Qm#tvk45XIM@{XgFCyrasYMy9oK zK9t(54dcwen$f=Cj)q0%!B}U6%56uWJl<^;zLih+4=3N*a0N6_EObqgoZ#O1r(0jR zGkfOyBRA%C4vw0cGa@n{pJkk5d4t{^i;m^Q&V-`)Eca15+H_$(pTq(pex)b&c&}5M zN4B@ss`jk!#yjS{w*ISK4lvxlX6 zT&yEQI_9r9{q_I7{2%#e^FRHp`F}Ja{|@_qCjVLRDPVT91r$>o*RJ^!=C8~yPtA{a zYW_02<}X6cFGtO1pnbFQuTQT0PP_8=*tOI74`g0_Up@7oi~L`V&k!4ciH}io8~AQQ z891q=E`x_{y*7E@aP9^g%(hmKHSZP&Y`${=PL*&R8kvCBegzb>(*6ySTo~)mbZ8_T zD$fgWtYSvj9lu1M8o#x2OZPEEQ?1TQ*R*h{tA`!d+&3IN22#iHW~!4qJJ?Y5_(^?# z;qE5O!iZQ63s5(xk$K}69a3+o za*N|sQl&k9Q2mGdhWd0WacZE?aX=A5Zuw?A@jS)O{$C0L@*&GZW9;!GO46gn=^dqj zlk#`Ts9vs08sDKOIc2e1#xUEH`coOd#5QL@kqUmc#|2xs(Tov$JhPPrjbVcIXrKTP zKd98dL_x=Ik6?gpE;<4yf3fcTE&DkhMxO{ZbTnlvH$D$)ithyPEeE>!uG2>F{^fwI zq9Ygxm&+29(DJiJ6aNg8y)H%z6gA9Z}Dk1o+H8g zxtK1ISOoL!LS2EK5Qc-q{DaF~#+qcLxRA~4(KdrJaeBue4%mCp2^T+s5H z^r+&MKhu`~NkkQ@flEO$e45k%MkZOCPIiV(mIZ>+_}pvwM8=BxGGaYAx(M${uLfI{ zBL3zKobG62${6}D%3vk7v~9#QT2urBRlKJ+=EEg)?CGaWHa;mDN0RWb`#24Lvm!`6IC1g=7B4@9OXK-fX^O%HNFWh01;M z$mn17fF6^8G%CT4M7k)7Ul0Dlo{sJL2nxscpryX{>`(Yspbt^K33`=a%W1nrH%p0j z6yTX{bfRkAeR)IjQSfv#6P(XM$o?FR#phrJx|z}JU-kFE-_<;q@I5HBTQ{47=QyLU zt5M|_+_Cc2#Qw&K?0q#b6_Wl2s<zo1!y%S~{bz+v6*op}@q+_2{~Bl{JqG5ANaBc{z~C zX#UI%f#~Si5Sn%u9<6!f{Y2wQM6a+n&xdpzWsABuK0RaE7_(#6-8_ZT+Ii<#jMGf@ zz(DK4n8Lpt`G7B?v|!1-`s(ogc9hDcfYv!*D9|D_o9tK|vrybDiX--n+FSZgZ$J2X zYu-dQpUHe>l)g2j10!T>UeCOV%+A3381|;UKI3q|{2$=1T!tss(i@&y>bFHhm(Fuc z{(f!XE2v{#KeurCh8}mTt&LbjNRRbh#v^Im5}bwF;QTUPT%Gr_xiZsy1>XcKdN^;$ zy6H5%jHzBI-6|+RuI_3*3UAbR$owe}(>@jvEH@|VqPLB`JtEk;2rzQUdMiv23OP(J z9N&uvr^D1$N6S!BORwMhClnuE{osxp(y-`~*79;&DbCZ}Np1z`+YTG%=7T6LoNC9U zpZf3TP#6BCJLg*)PV=nwO^6c7weHNEz8D4kCgR}`cD(p~TqMi>e0QG z*m4*>uQd-77PJRA$HtTDfo`f*-wbm<9f1d1zYYArdyoXh7s>6nYXrrw_K1(?l%IXb zI>J0be`=UnXNx{MCfRts2ChLSo$n3CKjzQO7vX{z#gBKu+>Z)jox*c+LY=NgV=zw! zcf5l2M6>i@JbMWa>Os7sV{3noc~~!M)=E1VpVe#4jre+|xe=5f3a>bgUiLVkae9rl z(Ze|-qrIs6d68fX4Hc3q?`Ye+hGuvHjx4j5XU5aM98bGDxMThZYhI)+b1YX1I9Ndp z44qgU2hnKlkwgAj`Wv#IapbP2Il^*=@>m>!pD`}=h9L4KSQSC-qj>0%KEo<~2|sB= zkT1Gw?dHQ6WAs|32hC;EH{um=PC7=FL+K~%7blefSY?nm8YOkc9p3X$!9n($k?9-V z?+lxxD%F>mHEIFiH^X78IxC#hSd!zZQ>RPtWXy5tIrwD4dMoEMA>H8}V(}Q^q z#}&aHhX9UcMd3Hw{>|bq%0QjQfs&o-s1(jFKrln$j51$qTZ(biNi{*ii{h@QBRRGH zjTH-+5pb65r{X=fvLC>dY2w)|3YbS?%CdtqAD0!#LH#|D`8ljKAU9Z#SYrMarZn<& zDj(4s1DB$F`Tce_2WDb(;C*^?02VD|<@;9b2srXwQ(H-QxwSY1##DV6xCyU7RXeyj>$$EZEJ(M0*?-{V7Ds?siH>G;x6(`W=0D`X|K6A3MFdYcn zPdA-u26wiSw2Ec^9G>%DsJeD^S~NKDJv>yk^C5D9c_@BkAh z?efTbdEaj{;)PjR@e-VmDo8_uk+2e?EN^IVv?I@tW7qGq>Ff<0*o8(A5`x1;dT>z9XO+2Sg zu*I9;_dv!3N8p!b5r}o2Z#}CjMUw2a&Y5ungN$h$W~9X*qZmzN(QYfZ9AGWlYqQ+B zMEkJf3^&iU?i)oO=E4!DDZ~X#^>>iy~F&GWCmP zuMd7#egF4npjLK6Va*u$EaJBZcbxa+h_-VhUkL78IPy#t_?;QNSG_2Deu&roN9HT> zIA6Q?Lo9+V$Fm?JEz6@q@O+ ze0&fTEM_Y`c5?Lk^Lo17Db%Anl43Ad~(YHa@Wh$?)zswL?ZLO)`O$|NMPB> z)A6Ng$o_;^Cj1j<7s>Tcp>ut-pE&iJC_BJ|79c3 z41V69f3;pT3!Ri&GAbzKdMFk}HqMt-(O`?(@4>1=ROZOr3Lrnbr%8BsL7Dd^Mly>q z!F8s}dd++ix^J~+enoKaiqow}@4R&8xsjEaDqo=A_nDdY`soqh;`uInzU(ZXH~gdX zWei}mF~d;XInMf=6PcZ&cO)E7d&?@xwN~UayU2G5KI@s>4z+N|vhBB^Rsk#6ZC`+I z2!1nC@Z#`B4Td;R$BHt@)F6WkHOp6U3Xai+wY(ZX_@pmiL`SSSVzB4Ij#{LG4P(5e zYN`K3Tk%+T;DlyiA8-CWJ|~f1d4*@H5RbCa7nD~vv?R<)5~hF3sKemb?fL$dXiKVn zxH){s{;K|;&fzVR!-0#@Imj;1rGT9AkBm3sE019v9tI3%nTt5~iHNu>!KVy0zi}G{EGquR5Zr|IPYrB1;9X|>FtgOWL zJsM(wQd)Osydi=!rO^YvU7?9q(E-)MKV-M?OVGk^Mhnlhmt~XM_W`vzw8tvyWYw{K z?^ZK3WV(IWMs5$!kRLO;$6C23v4uM^*}^dd%l0;uc-pU#@qpEk&&G~XU$jFvb^=A) zg7?rr8i+7){w-R;<6IQ$DLTSR=qY+te){A`4bu4XUkk#urF(L)DzLI+WN9bdi8q)( zZRxx#XW)6XN2h*+d*?M^jy~gL@czfaAzpMu4SbMwtbA^8y|tA^-5G#^mKi^l?fV&BcfDwBK7f_J z&cM$sn3v)bQsn<*@7?30s;=p#@D4TY_j4k|9JB36KC*GzrOs zq=Y17X1I83aAqLmag=KEleXBRQnjtNXc18ag4hHU6&35fqEcmywW$1*QZ>(at$p@7 zXC?#sd*1hX|9M_NlKGx}S$plZ*Is+=%h`v|$_%9el9!KMA$sErtXQi^u8ng_qdaX? zE7)@&N6di0X+6!p@r0}RHt`Y^jbPUKfvrU2stsmAHU^zjIC)j1fb3sSUX>ejTEt*U zq3zmI!`1#Mv8h%~#1SEvY7!h>yr$doad?LW~o z1#1#``F_f<*llRHl)zKDJ6yNE14wm7)nnu#DKC%u;Z1w6q-wXJSmL#%5v@%P z7)||evaqB&s?G6+{f2N~WNDTw)T$Ea?8=VSywH7Gg^wZ)$Yt41EG& zGn#_m(Epab#4#wjLUfi(_d>uv-3#^Tv?ie@)PVg)r`R%_5n%t1djIwNC_&4};0;*= z77vL|>)S?|Uitv;1m+|A27d8H&WqUn+fGW6H|L8_Xi;(p2(U#(eelc1RM(4o5f+za zog(%fBt~XxI&FQ^$2&5Tswe031sH2x+dGrg_7K!x7k_jrCQ*U#yC56Y4vJqo7Dc&W zBa+Cd!cjKesgNk?!{4d~E>(6$c^Y%d2M9J>1HgE(wE)`~JB-B=DDVSXPWMx;mlVXT2+xa@nWy$Htf)Xm9s`-{}^meiT<=c`Zz7b^=4w=w$>AH7$Df4mir(7x#qyO38{g9nS-NKY14Aa zKh!w^#40_*u$TLvz-!{wZ8(S6(B+L`XO8;+NLPqn^uiI>$ls#ros?+%`-9DnoID_S zh5_E!-XHzxr0CFGVm$se8nJPYSP6<7a4yTR-Pcck@o zOejMZV(YWO+iZHQbFHowwvemKC#c7&tX?En(VP;tsPV>YrMXy;E#Steg56#Jr zZlVpV-XSOn8yXPM7ISdhgn0-PjLSY~na#Uq_0?W-nHDRe0L= zcM*Ogg`+TVV&++lx>n8v7rZv6#$U)+t*6p{?IG;d9%aw=RLj3@JCYhm#f~nf;k1W) zhKb8jPo@h9-?z4LKTzAahiDu3UEan$WCTvr+qiAle_;f^XPwO?{bJ_@+qs$ORK2fZ zyv8PuCyfk@N)$6O6?e{G>7Ex}5u$eydqRV#-=d!Iu~LJF-L3zGGQ08E6Q+p!puDWo z@aDox(TQE5v18%zmXls=p@48#&v9#UrW>Badj3i4;vYU_hW#;Y;YIJ!|g{*kZK93O>l+2 zgN3tbI1|m$!+(b(E!>_|wdaQ3zZBW5o9Ob1!Xv~)mCirrzT z1yQu--ozHKw1(R#FT}4(qzOlOy$Zs#qlHV#M5Bj05J+6R!t^0nGn}QUrFY=$JWWsF9z<5o92DSMEml>(b{qRI4hG))NTWqT#?0fCI=Tc}D@o-6c&({;o^ zSD0QsV5m5WAgR zJ2h_8u_=GP)i}&H>NN~E;UX90pGh(+L2dDywjR~QFFQe2?R90)OnpOZK})x5Y7ei0 zV!JBm^Na4J_Ho_lMX9j@W`uf`870-Ro4Y6c6x;`Dc#{sQ8|EW^N|lR`7iX^CpE z-f2AkpqY^q=7U=pS=AIW!>R^YR}ul!XkWi>UspJYw0*B!OhRylccE8U=}7T-7V1)VZB!x2|s|uIGc0$8dvx* zcDu|@E&-dJtd!i)Fn2vlN3qy_E}E9#mPHBZ79>vxCuCQ6e~cuElAWc77K}h8ic$}p z^9A^ugzMZQtmmo>+~_s}w2#sespILs=xieCg09d?aH8x^@Gu7GBIu%PWd}?dRhTZ9 zQ2C-;4xz?i8I@%%&173hJ)T%sXA#oK>`E2tS#Z3M)piomAuYwRHSS%Q3J;6@2Fggo z3bfeL;n0on%|I>HO#O}4eI)(6j;=v;PxxjK0&!z2+5iepeTlfhX)HFN!NUWW98a|g z(|U;tgZbb#qjX%+y@+z%xB_jDfl8IjA8lA3Xt~ z6Oe_VT3bDcZ-^W!wf7$%+(L9y{TC;gflQMd2L<3-eHLmOSvoxPT!e|+m;AN;ybNka z7SdE@cfLvGD*F@uWGz4oG+kxF;_v{B9mCQ;!z1C;4kdJD|}h)4Y7nFVvvOxkxGPD5(9D>P*^ zmBE~CCNmfbXELj#_0jM?#;fr6F2o^{IItkKZ0}g2PVEbM;dH3A9E%en*m<9Ut^e>Z zp-$L3a)nm0UJ)r|p++LcGSOd{Ve2<_YULvHUndpKd(W=Wd*IXz zzlUgAEZBD{4oYp=iKmlY;YO%g+m>B;fG{iZV0KcB8O=iW$m|Jb=WaZ@9xa*}nLWwu z+=GY6>^!q`F9X~-*!e0@U1avu$dh&3KTK12?--1{UBi;5>B=gswDImN$3YjCL>9q86AcvJ0U%_hv_d8(hm|AqP<=RlcBEm zq8aeh(UYade}mbBxNs<|s2K8151q{NO}oxgR_-k_eNoHuloqtY*HJ0qYN&UR2c1E# zl~1D4&>Tu>z`9od0fh{37$ zKJ&`7;n+n|VLRbJ86!`QT2nxK#MXRH1(Ly0!yRg!aOo(HV!exfH6>aS#spmDK*G>w zEU7T`h?EK`>jtI4W)?_Ai@+E+RJ0L{$*o3i+n#C#M? z`AEe^^T%f4Rz?pI(! z9X^|cFAt0-5x@n4z)45yVOfu&BivbKP)xlQDRnKV$Ix|O*cTcYc{&)&4*vUi*UD2k zBri3xJ$N7+yS=WJsT8vHN!Qk0(NG(mp^jdczbDvtrt8*o;5sbm86M3XXimnww1Pi7*5jJ+puzBGMpZOVrqQsnXA+cK3lCj{ml1N$l z@*R{f`0td+oK)A%kDW$%fa{h=zDpq06}}H4q*=pY)u5oH5zG;8+mEd5K;UV8!4LjB zsOC+vmvQB+7+utf^J)*7d^~P6>o*NbOj1xjs<=3qqQiZ%9HHT47Bf#X22e)YV2>j} z&qSbaXcZuq#mQwreiLk0C?b>#N;fl&{s6}kbiwMCrPDAVi;D+3{#=>J%Z3jG*%rx4yV!C z=#cx2ilpzx1Qowx+Q?RuVxv!M9aXlNxQqoT7q>D$&V}5nXXB z`y9UH36?JjfzhN<4Z7UA$m8%QQ*jf|H*gybr;=%Z-Mq6MMQ$ZNAKQgL(Jka6efGQP zBlL?Ef3Akfe?c;nXZW-SH5c;7fM~8D8>Y^A#?1pA>hV0J72HbcQeB~uP(j|m!{I5l zzSvzjxbGqu^tS5;_ZflD+a?V*0=+alHdmw}4~aiyRcLMh?ncs53f_~lyqnIe2m1#4 zPq4i4j95NdTAtlezfrA1t!K@`!sI?u?IYn3kl9IpyV*;_zt|fJ zormCPl-*$5?~jw&%)J_)P11j=5qp#9B-Te|I2ECCK^Q+_V-?y)MkmFXHjY z6{0NB)JO0a^`UNJralUVhm6qWC=|1)Jti}v)mGWSfmjrQid&}1Y^#N=kc$^6?uGCh zSWYBe(yJuRV1@?K{rq-o@Iu!B*UBbxZg_~G@^jvZ&4S5M(*R3>i91^cVHbNkBr9Q& z3r|_j!X+L|4&a&FWmxbCvUa8fS#TvvSA&NKxx&K`Y0VPJmJ$Q88q$Y;J%^-Bik43O z3N<{&VoYqs$7C}}y0ipvg8!0!rhfc$EF!b8Rus$JE$aL}|PtbgGFm|Li_L?GiB1h5Fetw<)3j*(c7 z0^NIj-;ZQuC1E=0(Hw4$I@vLv<3Xy8t;axe%c3nQ^s&P( zs+g+b!S(`t=4~?aq~;3GwA&?I*|+Yc-|Ksj;c%xqMa`dHLg8@ZE4 zBn-TtnU8b;;UFn0#q%8=3I@VS&*Zgx>0qwV0hCX#!nppgzhNgy4Lpkbh4I+_n1}e_&f)-gxCdd_suP-+?a)wbOOa6~m7 z1>$EGa^`da%mLt2s=z-5R-+gRNe%Zvyl7<`LY|;lt5+tq{}%G-h6YZ;g45MNb-^QP zu9a7yvNY44tLCBOF--ttX;oI+S`vmOAiqc3>}WyC1m&#+zfY9a+KtIla;><8$G=RZ zZ;KM!ScM=tpz9E6k%9G`PQR+|YS>1a)Va7))0cClhy zOGx^$$uW4J0o@?dNx34NBG$(er`{WlzKOpFa{q=>cDTalVjmFx-BvQ!tluNKVyTfn=CMV9%m9}qUd&>W#V{NI~UGG(1(dd(82=o%~WdYxY)BXW);q+ zE~vNjn9Cr4{W~%wEQ54GcCkaKjaX{vCJA*I&CF!pL*l*8IiOi0ie2~-$&-wko`{b> zrm@OYW{^3K4TsM3bJbMwwJ5${p~8-CAz8L0H{%Z&h+U699qCLZQQ_NfxI8GD2F!)Q z&UBmnXmSEq=&$GpY&52%wslV#G`KD@Ye-};mNLl_M54+bOc_kZU)YQBTz8wul(K#q7m#u*-^r&Ki453yIta*em0D)6_ zlfG|g2!(+$bkZ0Ad8^Sn!Bd9{>C*$XJ>Gd=#Swx3U@nSwoKR1;ZO_y8Fo zYe}EXoa~-Gh1w}6SexW{4N~9YuO#dtoiK zkx5VRRUPzMrY3K}gE{3Fn_N*;C)CMD2|}$X2qspEp4Cc;V&Z#f0Ba>~Cb1_b2TY}( z3-5s%H>o8&lQdX;@X0`L)(gsMw7N_+aw>1^ZdTa!kUr7f2W@fEjZ6B{``^CWYHj&A z*9v+C%VMS~K~zo;I>KVIr4XA)s-U{z6A4Voa2@CR#m0j@laB)A^05Hd9bK_QBsun9 zP^*4xm}Fq6)>c#Vm1lUSCd@O7`t4t$W9G9Huun-#+?kRDIz%tR>kw!)YiE(@rjcvI zOD-9AsWjw}(?uR`8iLOOao5I2p2obKm$+2zZ?>Ac%xXP{f{{+JlIb0^74L&Aear3d z_>Ho+n)Bjg+=x7C^j>&BHbXu{0DPx(*iraS;WzMz;7|n|hTxHbn@B3I$$Ns^Q*xhk z-IxVwE9WfINy~u|9yB6R(wMd=(SVPah99;wJOYs=MRi3y6hmURQn0T|;$Tk?ORmn* ziO8B<5ZrLZX9n?^2H8VYkCWAlRg+H5=JTQtKsvO-$nzJL1RPT54;+z6bw ziOTLSx@2H?(NFNo88zLR-K>J?`0gym5o#HW1*`R~`9wP;>)LoH<%kx@d%o1EV$FJZ9JAyrin+Ral*FQ-a#rosJv< zZQo6%LI=JZL0YYL*di}V6uH{;z(V5*EOaI2qP$HcckoH#<{jtI5fm3ZG6)wsfGm{K z6{<(bX4*7RBJbNo4An&{C!#g-RBN0T^CPuw{P$zviC+OhcI8UiBTMZ0*D$*x26XAM zAw)%WzAr5gAog!s`QepROMWal>wJ{j-#d8VZTm6Nn2RPB`ox+ZHXeY~F>FlEbcHTN)uWS#Eq`(~G&3?xErWf5Lrs%m z0q@5~#io6T?U_?#?{zxD553O4GCVJv`O4FGxovTurD{90K1fe6v(TmsT05}=x4?nFtZ~; zo`m%leOCeXsjEpUw3CBMAY-BqLiCuYF;##c*skzI7d;8(!VF8z%#|F1PZnq zJ8hP<4^7qj-qI>qVbR8L@C+=UScC4I1d)gdi9uSknQ*6_xD2D>A$H0T@716zTc5)=%RVj3LDXjnFA zIQlP1OV>WRqQovkOSf&Ak7D69U4n<$I_ipITavgG0oUW?PT-mdob!SU5pP&x6Z@;b zb(A@M-!WP+el@7Se$d#V^h0R_eKi8^3)J(%G^>MY z{Zg^uACDIxC876QTp@Q{lApvUDd8j+$0b=3pJXa0`Dt8| zC*qS7a*`!+Nshw{4h~-OI7vrbl8X2wlQ;?8Zfn=*H}Od(aFXZZl6(}OWIQMNHCo7~ zaxTu&Ie5wDB)j6MTp6Ea3@79YQxb}-OBQ)AB4dld)GA7HOMDX6tS}{^$loQ4j8Og@o&S~iB&>E}N<#Vnl`OK6 z@_&L^6qo<~cs*d93{w)ypPMXl8s&dT=WmHm!U`LvB$R(;vdD3if053=AwCIfbC{A) z{yoVehf@9=o&VqQNm$jxl!WqU#Os5KJPiAt(-r%~O0zgV4QqM$bSv`KWRYKiKy1C0 zVpDty?g8Pik%G$Kn=JAj%DxEMS^fjySvfixcaJb7q5R)X7RkrEx?(vN1LT@H2yo{K zTQ7L0{y0fwXIJd^pbs|?_LT3lDN#dF>TF6atI)WG&J`MsWfkJ&Y84f4On0Mq;u1q7 z!3)8Z>TZ=vThcuoztN806(7HsP&DisIwfw*R=@qER}_wAvVjqyq;JgW&v>nuLrp~Fpj z`@rik6So=DJOdZ2fOGcpaHk`c6-556g^K6Cm*|rR*wUf%PxOuf5k^ne@7wmhf-9;% zN~hI~pQ4=T6yhKa%fl)Gn&1_43NG2^6iYb;zYYnRIa8!rDM%R6DYREeB6p;?9B&_| z)7imtPLV+=Fm-UGn1wfL>DX~-GN+)`tTecjjucZety1XAnNhx+mwaDm3S17%oSwlc z=qyGWY^pQGa4Q9UCL}t=O(`&caHeouDUML%Orcd6^-dYxuA<~I(n@iFQ)E#J3{FlO zSyqa_af&gN0^Pxp;_@++VweBy=#*@Vg~mBzXJu0?WIx0z9(w8^y~0U*r5LDzdlBK7%u2pcn*epi~4YPJU8epLLF7Ht|evuiTSDo;%Gv>6vg@< z`wxu;;typsqq4DqrX+efGz|>*&hV z#8_tHIZUhzTv_EENU%=M@*XFvl+*PX=4M9ZmCybNkqem~TvcpQE5YIdX~!h0@VjWm zIvT$-e#7<0qa~l&^i2LAoqV zpkF(WA>Y`qQE8o?=u`Xkb}Rpvo~iwMH`>pn?7jEe&(xm1|7AZ@b$eIX&s;yBtsh*Q z8vB{$G1GqL`W4vET)zwK=TA_X*a-W11X?NB=ksXhYJEj|U_@Lh zj2{?iBEupF(Z$$M@cXZLmx*st?|qT`Td=!6=Z)S>;fKx6@Zf*k{swa}Ub4yU!FgER zK1}=l(r0<33GCHN$Lrjxdq0J952!L9i*v3ffYIpq)#eKFQ?Xb+i_RDFL(bsXH-VXC1QaVVKXTdr zBwa9UeUAhmB{K60aXIV_Bk9v5*T0FkIna|MJw17#4u<$Ed-i4bMNmj`*l=x_x=ij( zeN|%8kC*UOiJ7=at^zl{45Az4N+6P4x*;*{<0X856Wt(30`XhI<@zLE{zu~hNsgNt z3r78}NYuF#O(}i%fWDBkpX!dw;#%NnFu;dD=%%K!($I^p_Aj`0Z<=lUF)p+%Jq{kG z3c{UTbD~$Lps|Uq_6kx7b-dmz-3MnRAMXg$ZZW=cvp2G6B+;VTo_W=q=Iu=D8ln{? z^0==4vU<8<3-2l5B1LQ*T7>9pNq8kvF7GNoD_$UuDv_gPc}TC4E`Tm&qZ^BH9nf(6 z;0Oraq^%7uEi&bs_zKElTwZ41%ZS#9Er2-L9!j+b8?Ny2tZ0zX985KE2slP}vMOqP zZ<7CEr{Z(D>Kd+P30y-8{cnIWuiwYlIGVGElUJ}1q-iVKv!5$vUzw~sG`CfKB;QTP zOsK-y38gq>qvc{&>=V(b%bYXJ$;m_$+lQ+0MnP;pA=vl6*y}*bu*Th|%-@5+wQ`rI z_~Bev`(=%g_spgE(AIMhw;CvePp0D*nS;Gg zK=2lQ@S5=pRV({bSUJh<47)_VD@|XcSx|^8GjLtpEluD$IukcLTJ{3h#P(#OKok|Z z^ib}>z{k8OFZRzYXpH(=;J@559yxP%(f1L)h&~1u<1+l z>XDJ2@Eg=2e?H!vk{-EX*bQ{&@`UKD?A{>|3-}K23XDb#%ptHC2jOdXc7?hEr{e12 z3nBr!mq@)T*|*Q~2lwM^ill8Sk}O0FPli<=OO>8Xg=Ge%-VOclw+eog#orfI7mniI z`9ky>x|&KpAc+rMQai0nXs536M`j z2{jw`zfqq3{a3nbHd*7mlu*hcYzv^#`VH3nJvnL|OMcNyzY2C`)2&f7!^|*S@D03r zyb-$Oa;0Bs!B`4i@0DpzO|{_h=83M2$LBunKbyRXF1qgu4n<%u+qR(kCYYv=N4lEx zDpH{IR~3(Gdye8rFoE7JmI2yEYK-=s8T@D@eaUlrp_z|c(`F2Vx6pRv%q1i7sm_!= zW?8*C17o?rAc8d3X9h=Jc~#%LGT->fDz?^I2S@>3hr7WeYmmRC3MTt$xz3enYt@JO zdiwV#;ujZV($_~9>=-@}pB*I@Nl7vy2z9bZAScvG`4-_`@Zn` zVY8bdxK_rk7smRnN(|1(+-l3x1XLC_vc-xLzv|AO8 zcKo*W#mC-~*Ectz&^bpf^eFYU{ApAc_jk@L#9P1Swa|;!VgA<0lej4jpXP|J%A+=J zqrZ`g{pd3D^$=RDici~jltBg;nv~KfO30VM*CWZ9n4!K-=D)!9Anfs^2xhIScZJq> z^&O>GCEn>SK;-F_D4yH~U}1svG4XRhn=p&$>%CQvA7iMp)V@%wOscYPq+He6KQg^<1`#{S`XuKLX)greTcWS4F*erpOEt+$>?l>oGU2^{i0_}4 zzM?){8T0aTe2N%_*GWyv=!>Q3FGIDH0WTKG5^9oAi@xbZ#HDLs*>mFG;y!0r>`$u| z|A~FhI41uO^y7c|M>j*H#J_KAJJ-Kgxh%de)mI z-Q(d7My6tBvyP?_Pqus32H&l6g>pcs?TFhyiPU+`2sU+Tn$iH2+wT)wY~-}_t@IHW z6Pp$5%*DFGfz@<=-Ls0m$%3&6rw=_Hk&1PZCtVwHjeZ46J`#ljFhf(bRQE>o;7ej zFYd#H&9$;74HUn|p_xli<>1!?{mZnqGe)Xv6D>tPm1}NyMO2sP*gUnYTg5`mOCcE^ z7(5AA>}$rp9%^8?(JppusztCY&GCivzmBS-NZg3WX&GxLvP5r35 zwKggJAN=19{`tBb_U8-gdpsMcBK%%dcU~HmOqW)0b#OfEggJ;s>G0Gy=Hc|=hbWES zP5hKf4Q#+Ip7kn(rT9WXiNVsuN-Sz`%b-}|U>YzZbm1iTp>roQ)QzISgYgoB< zl#dzv4A5&YON#|yGpW7SKpRl^PJ3hdjuaFE zLo+Vo0UvSNwl+cA${e3_T1yI7v4-cYXzSe9T`Rr#4StR4dO#5>=L&@faij1&RjVBl zjfKDou|?;z@SC>YDhU~N`$D~~`RfK0g$9J}UrR4RaZ}O;CM~4nF7pkp@b%ELO?RU5 zu^DRBE&V?jbB;oosn(&l8Lsfj;KN)&%MxbA+Gy#911+%b(2w>ZphNd{gx^Ps*i_KB z$3tTLpWlxD!ypq!zv|Z*!GA*(-aI;mNa-3?_0lyev+Gfq6O7Z~5E6jKAIQ1`Y|;89 zk$UFnq@0x-U=Q$%< z{Jn0^^XTpC>LR6G(b7!^=KTtW*YZ63x;?KQ*X?h`=n1S#=(ofrM5BU!g`Tz6i|pzgc@1G@7DB1u_lci!M3d@KFB+=ISB7(OE1 zQO{QNME+V8DU06xxY|;R$G<^NTG&$uxE{@RZCsTJQGs=ICH@o?uFRlMK-EP8-L6Li z>maa`A+40U9#5A+GJ^zm;2+Bj$Mym{x69g&g=OB`l;MXTF#vQnH zirLsoe}Z49f_GQ2Y5@8o4n{tJl|9!+eA;cz7u^Ul+Aqbs3wKc9qlMXDLjmd{g*jix z!U*B@{q!?O#Opg{a@>y2qgd=hjHpm!$J!MZ^=P?2{y;aDbJz^r0-Hm9NE=_Wc#aWA z+dJjBy>=M1)%;QUZ#yYqBeD>U^eT(LLaU=Qt@w|Q(h5QBHsoSIGS&_R%i9Ud>w1)z z_GmyLe#nB5nFn@GWh12>FkzO>fO+b`A__(tSVLF%Ca@8mlcHHhL^p)!3QY$el%{k| zG%uw)uaB0y(b4cVUVK$RuSS-xja;<`BMr*a!wd~EY04O3lvx9tL??YQ`yfM=Fw&st z$P)d@wAg>44YXnk8&4w*k-;s3D2z?rDk8*{!IwP2E8fNpEro;-OzngE^GgBQ4w;ZV zxZUlM92sMi$x3+E{ep(DhhfOf(yh>|$fc;{TC@DZ$0OxAUq+|%_lI5>y))$#e3*$Y zdb%+SoC4EoSn0Z)UFL9n;)dQKxu|qq>!}s$@p)b2k?KOi1a3z-?KlD@9WV6<0{4 z=bjFZzQKy#tP0UbG*)rsOeRkWiNfx9@;7smgI4}86Un!8^qE%l@N>8hntX^O$Adf( z{sBcw{lQurN56-^6g@pYFI^~Y`C}JTLP}CcN$i?0bY?RHFA>1xFqZ1lhkvPCWts%ff#ayX^(^=CnSr!oD9_X zk;K7L#5;>eW`oP6$pyJ;Jh{;8ajCzJS4P(La3*{&D(k^ykzZg?SD!tjBunFyaCZtn zq{jW!mB}JI5E+{WMpjY&0r9%Rogw_0mEV;t@^6&irSrcUUj+BJ@G2|+hsh#ovpDuV zY$BI`L3|P1p~8Q*@=s0{NjERWZq@n!5wAR~U*WZu{Qi?Hk~Z&S({%p!_#~{t;ft;O z_a=*UQ+}7uKPEm2_Y%JGm4sWCEOHCiA4ItRJL7v9cf{}#tNtG)i~K3qU*~U#Pr`jY zoN47>ku35H_)al80m|i{7@vgAN%$coA^v}uEV6_0(~OGqKNa6ZY_YL^C)ZOI~^LuBk$%8&65-#hHy3|*w#hQTqrDfrDqr^~}{2Fw-p zM&2F8ZyG(5gM-B--TCQuW&fDS4s%5o`l>TA($c$d&JoP;-dK6}kYT!5Ti2M+!d~PZ_^<2cC}XhhcA3h z!rcD@ZjH2&qi zND@UEg+IjUnGC&NO(AIrf$XUTsbKu3A}2}OF#`booHtMcy^Y*AbSjgkF~s`t8qrw` z?&*CsKG%@ts0vY}At`}k!Ep0bTq`^p{YnWO?buy3EG4!AO#p%Y-Sw#F)yGH$qJdSB zJ6q7OxXS98NJR%C_hS(*Qn8v;Py5Gy)WcZ`I0$-yfhDJ!MKwuxAy%!-!L)q!ERxZ| zjP6vr>@m%pyJd|zxc6SANhs+7lZ!T&lb)dsF;}hl6Mpf1){6D`JrTe65CcAikGJZ+n3a*6TuLP#y=^Ex_(!D@HIySUu62bfq6m5NeWkWYW4YK88Ptc%h~+Kw7kQ5|@)6dk76ah-%g^MIHiGD`CAy zHB^i~jvMUabEI+93X`P$9i_bl%6<`j~FeIM_8HvZME;AP2xo;0Cm*xtH9Ki%-yk(e%y)K{&Jv)>ZjgZ5J7VZ9%4<(!0fE zN+uU2A3`7C%eISG2xSo9Vx=?4-DNG54AZngra#M-F2l||-riQL}k6L^D>lA@`x z?Z@wV`4jphq{nufjBZ>qxS;}fkeP%-+`-Gl3xX0Bq3yuQEff-C_A<|?e+)NzSe#bR0|v4OX)-Iv|m(& zPe=^t@ob(u_q@41o^6c{^8!7d9lm+lV|zS3+4!&9^Niu@*iN4YbA^1=zp?3AL0^-M zrmk}C>5_iXm&oyn&(IO*3BE=V{*?6v$~+#Q+lqMZ$Dsw+ii?pb>bW0Hg_B{3%cjw5 z29B3w0~FtU7)(XnkB@vtig1V74yt7PdFU6OwcNP8-jVjD)#lV6wUwh>IBszLT3o-O zzS4!wJa9|0iM^kakZ?)sYU_SDO_yc0m!2QG;wk_0m#O5$dEP;Ol za$QzO^2hT>-p!(_h$k&}Bh-QRKU^FC6S;n^n)~p62v)tw0jTA=+)O7>tx*ON!xkLZ zrWT5lM1aU50;HKC84|7uzVOC!_;freo%A9&y?x7%Jc?Yd&~c3E>p!g1c%2*!29KP= zT@80u+ICQxKnRT(BH5-xUHRoU#sBJ_JTB%g&_zqHqI-8wp?$hg2_zP|zJv0dj5ul! zN`qf&4ss<{{g@`u8g}zCG%jMxnbCt3aDuRu$GmplTs3?M-Oo<~tz`A`MC+QCg4GErVvUU9+g?0i>nr z0kI>~0(vI4z&L);Jydp@jp4;toJkwc+~K=K{-4GfNC#j0!53eGEcVP=uA^(DG?&bB zBDb+pQ~~zb3_PG`3UE{Ka?3O1IoO{!f>dqZGc2B&S=#rb`U=CY&|koN6rVRLx&;;% z-c2{_02bC2vVzRaj+J=N`r zv5+P^R2h9kX+=QEa2hrm@i7v^SmKFRY({asXte)>B@?gkGoZ5U-agYEO)Ypi~B54v+;3(FM{)hb)#f$ar5~N21Gr6CAGr8Cw zKtgS3(EWD2-lc2dMlGB@IO&}rx#UzS1~8l?6UI{sTsX%hwx_Yb)1HGRx|>mGZzQhs z#>>{Q$dOSYb#ju6t$`XOl@_@))4Z(EKj`zpRsO5cHHMj`yCX+Hj_okH2RJd0X#)<$2e;E{ z_;m9W96N?)(z`yGz9R_k!=|ZV3}2t6+U#In_nUz|afjL4Zb&&kaHr|nsSW{5!ObJ5 zf_oIjqZVdgtVq32sq>tW*wU)li_lbl#uY)SI2>@MYvqeXzG81Q{Yi6rHg;iyN4|2c z+(LoV$Lq&G;c>y9;b!Shv;3s`wuu8DNB8Z+b}?)>#1`2FvV1~h|6?rCuW?HUSPzr^ zfS6*xN4)BB)>nwf*xjGGBzcd;cx}l(P0O4Vv;T1&Dm-?G%9Qiu>U|M9+OGWjO`PT& zd8PvBd<1^Kf%qXJeg`tD9vvk_9!o3;B;y_Q6PDf_ItL;*J(-x1T#VD&$LDle=bvFe zsmP>TqH)tM-nHGegNs03{U7T6fBk=?#}D!{=l}Jhz)GHBZ213W!HPgm`p$2VMN4b* z{MPD)?rNXU+v;yu95(`KXC8Rf~}K-s^65xfUllPY_4-pEiQB~ z3U~uvOaCXjNBJlXa}RBdQwjHy27kSSeQ12E7kcR@V%`?FrE~f7p#NnJ=n`2i^tZaU z7Rh`ZJvyNr=H*+aok3-No3wU9r5aYHY(1fVIKRP%j^>`-&{Q#VvKu;p)|wZnLnr6t z)d7F=*j6v3?u+k~wT?dJOcW;}xD4*0x38Epi7l;2K_wuhmlwL0HCw{7zzfzQphb74y(SVDPF zGN0ctYMKL$wJ@=M1Xb6P*{W-p4^!x?X>DlnH$(Q`)>aft#uW6mXndAP$ka&@WFWIz zy`y2n8|F9lQ&yB8mvq`J&x|QBLT5o~t81w?sPDXGey`71(%Qfxm4F#YL7H~{Y{Yn3 z=i*e!P!+$-T?mU*+wApml`Jt>%B0)H=PVC;=5DF3S>W}@mFf&Oiha#eK5$YNEVcbs z#k0(t&h=AAZ*}Ms4JlM@5^k%TdO-_ySF4lPdY3{#=ea%99^55_PF(|Z8Z0~QTlP}) z{-s8vw`o3X1T2e+S3SzTFyQmM=fM;JHToN%6qLkY?{$|}FKt*DSU8#5q0HM_Orzi8 z>PGhu+!NgAyY-`?s9BO@ere>>B33+GGSOvG|7e&Wfc`=c+zY)6n_HJT`tCPc0D~F< z@~^3<_RsfKw?`eXY8o#@$zTf95R^*QXuj7dIOE( zU>W03bB%j`prIBW5537YXex%xT3upP^E`hw>Th`)4NY~_YkhvpCLY5NQbq_;^P-_J zc8vFFw*qopN$&?sIf%NMn<&o3GZ8nOUf)%SVpcv?v&+f9$T;RUA2`V(I zagNHzy2zcbx~7H(mxO#-wSk2TmtnLaTjHbI$LBvrz3ct{mWk(|ztC6Pbl$>-n$~7t zbDjUZn&yS)dz;1veCMOUeem!G#@tF!5cMLHSAvk zcm25{+wRDhyiV0M{y=r(Q7h%h-@n|JYIMtQDmO{nk=sex%9_exjROn4t<^BoZgPbz z6>{*MB)_y`5&~KoEM2hqCj-saLA2KACr8PR!HJl0G^eeN4n8=)gIgNxVDGK08S61wM{f28c-6&>bCSw2%u_>MCD|^+strlXO;uW0-H4W< zxlbY2lZ`&jfQl;6-l`EC&FozYv+t%jO92B--lZ*Gc4la%b-oYND;i#sQ6m-T-=4Mb zQEL29N2pn2V>M6x0MT(lMorLIc_^nU)Dh^c4y-_{m!^NzYOt9NJ|A4`teWOpFY+}8 zMq_?S4j5TaW0Wt;H=4=Wnr}7OC?AJwFB}%EsTw*{Js+l=%pf;Xpot7Q#714iN4-+l z&Yjf+=aEKqxN~FNQ0>NLZj6UbETu7SufOIzVg+tfGxZGkl}e+DZR!YCoroSRzK`a| zSHkvQWmx{~QWQ*SkDAVkV2L_9ZX7Xp4ThEZUYa(?_g&T_svB2GjcQ||(@L(6v~YJp zqyZi!l}D1%5+It#u<=t13Rw-T+~RW^%9o_7NfHctZWz9Km@L5IEGsCUJIixmv*y|?s z(FIa(mBg?Vc+D|6B%`_s?_hZ8=PJq!6Zbms*~4s4ejeB@o* zWsIS=sUan*3AA!s={Qwg7-sAl7)RweJ{K%Ofaj97u&v(8^0e#fsDQh=wH4zEHKMY1 zj=X9}i08Rnx`LH zEQ%|`kXULaYy8A&QDcBjq0g8xZCZKd)QZU$pwqk8UjxKPfPLdIqP z56YmL9D_XcB@3emb>K0)3Z@WSPX&n^LU03AKh>*gvxwW4Goq} z2a#_`zp#2Ky9rVh`7cUUsZ8QRH9gUhL|2XqT;;BABrkgzuS>(Ajq)YLU(8;Lt`DY9 zEzLfxr6jLaX>q0UB?C0uY$hh0D^u3+ODv6o|E$)cYQ1&USWIxkcn7?3{L#V=IpB@7 zAm(s$9A)!#D4yrq_&V9%5sRS)&N#d$3@K=@xVj>rs;jM=3HI69-}|YI(}!+o!a5Yj zBKWV4-fJjl)4;|8*~5lLTDP>q&`JA+-8I25I`QvB{Cfw7jUL2rJ^b#e4Yh@pMP7ft zAD#w=FRxF65LHC3dH*E&Ny27JSQ)(C>Q=0f7Sg_m&TUb%vswXGzA3FZSmu34Z8I>r9^EDGvJ4w41zU{F^!ibk;-;2> ze=;wSGZi7pndQl5zN~(kuK{}}g|fJ-nx{WGtN8vA7BSu=m`=MCqGJ7t+jZz4XUl*G zS6dJ^Wh=WKkR*>?Qz0|kpyg8j(;V;{vw1gxe|+;QWh2C}5eyZY0_|OsueL?9^p*&F zIz#|DNBJ}jxCXSbS8i=UVxcYm*~%dMC~9|yRxC9IQhS5{SZT=w_^__ofC+A`Oty)w zWWiRZVlhpI16q+YV6M4H0TO`$z>3jG^M&RvQ0{R)S+pi_gCLq#8pnvT2qOiNEo*LU zs98qo9ZyygSvNNvNQsx&j9bRlJVD7?mk}w?Qp1U*I%?O5^QyjpRpS0(R`LqjW^!go z9_nN|fi>EKhz~NDUrg_5{l9uK_K11G2b)fqDABUKwG%Pgu|(_`Tc|87EUO=;q34d8 zl(nXGnNiX(?=rF-v%Iae3ZTO|6VG49xZx{O6o$px^Ys76NawbEN+Ip&3r4a)bP#*; ziIr@}*2~e-TMOef)^Y{VoghG44ICt7+ALK!n!M=J7*#F#V2Q+8Cf0eqa8j(wFKZ59 z^WmrqZ)z0xxnUc84VeF8DL^j>k~HlFd`Ih8%wbK2wjh%n3#esFfvE)V_{-MXvHU_J z#gr=Hq+sn}39lqJUE^(ScKXzIiC7=eOAM~|TiEj%lplDM()#;!E2!euYb&c+;N zNy08#LK@oL7;TVCDcd%x{_IfEF$>x4uB26C%$aC!Tmr#^&+D(W{84Lbwo;r@gC-)F zu-JQ%w0BP)aLdupdg!UYP^na|ra>jyf!K9N0GlQyMTvstN8@8##Nk_F?^5i&+fhZy zB->%Sad}DR7*@|orKET=I&WoRc_kK~iVHl39Z)ds@+rkdj)0lvGm0;F2GESaPCvs_ zHf=_^BcN>R6*G$q@=Kgzgnm>vQ3r$s+)z5ldP6gJ6W$!6tvv0JH#d1neh!J)^5d>- zHxczvN8}|qZyJC8g488Z(~r@f^$oR^)|R7X(k`zkDKT_2tECBAPSF!vqHk%kKExBJ z*rc??)4~RyUW}D^tdr2j77C(NW3aD_6Gd1_#ul}8*um-BQ}6KdRAO4d4_C@PgF6r_ zzikJopK&5b?1(nQSa-c)RN=P`|MvadFjDZ_5`v!}1aCJQ#@YBs&;MWl+qWD%;orIV zS5P;9;r!MM#u){rG-Onk@j9h`Dxh^*{h*@q;~!@m`L&DDX>AIeM^f?AY#MNRXl5VG zvy=l08k>FI%e>3_MdtSlnQcrf@t_Eh(YZL0ewb|(7Z*;!60PNR&-D5OE#N9XI6wYz zHg(=WOJM`*UC@X{gT#?>_o zq4;2-1p1m4wWn5Gn>33q<(QGls9G5dz1Vhcl-$XRJ!a%=L)TBTDo+dkSu0F^tAAO( z(LYVGK0RlZ|83GpEihBTkh)CEr>?mKdl3E0=*I^Nv72Az?w3XinTBBsX^?>Q)ykK& zWRXwO*hGS?U6%0UiN}>FMB_psZK;D5(Vw0}mPbu9+fe6s#GhfO!RMYwXI`3W9cybC z&6^vs-9av_K5yxBctq$#YKnqA!lqiaomqVTG>is(rU>p6FArL)F)*kGoGkjO^H$T6 zz%j@D796^y?L9L8Xmd>cY2gWGJJ2MY^Tw3DrqfJE_b7d>wdmjEo^k$coR5NAmzCti z6xN-rLsv9Iq{(3dEsG9(_AJ{o7*(6NBS>3*dLI`nW5j{Kxdmd->rptf)o)>k_X~U& zgR#Iz$7?Va(~x5gjXVs}nq7Q*SR+ph1~^{R;lr*r^|)0SD!{G}r)Sn`s#~h(H8f%w z%Zqw}F0Kl2DjKPW{W0b1Ra`D8WeupE1uMXOZ3+RuiUdI$4FC3Cx@Hc|a?|?OV2R9xW7L z8rQUdm!%#2a=(^7Z5dGL5zXpxS`Iy%l}L(LEn@R*+l%<6S*?0@N@q!WpTwSVLDOsr zXVctiQJ|p}q3EbQPk_>3s)>D9H7|9}?QJUmLmFHen?qHO&4#6>32RQy*@){Ne#gOR(6_^ro}%s_kM$CJhG`h{%Qs*hkZa&$zj|ga72MV$(X>*-7Ht`JeEoj_~)BzK&0nyoC2( zZXn)ko0s@3P3Aq5IGiXinrt3RJ{0fNPEN1*jX&Fuid9l1DW4h{)iV)yK2vEC6@utu!0EGj*7Q+*rrS2l-~}ay+OQ4L0h4fbovDP zO`C|wP0Ixip84Dor?rMjFQ!Ixq|jSgUsLNKKvk`7X{e-0Ikmg0I?njiHLJxTD@=Gm zA*|;JS8dGFRHanXSt1GNE@Y)iY*L-Kzrj&-SwGbH;^=UQOZ?BGe^m95^5v}#;V-W1 zXgW%5^un2>O;m4QGlb6YYYW6vTsb;>CAq(LTz@sFh+joBu=(z$DR6=>OSo3bLQ~{}L^FVf06!H5~h*L|6Zp_g}bM8*eZ3f6K6@ zvD7d!@UP`~thbzq-!%L?4*&3SS=ADx0v?E;LeNSBEy88c)V7s|k===ZxU^>#0yFMF z`fCh>t_!GgAr0+Sh6rsfe!ttwXruk!TrJhOq~G;(52??lD}^ z!~apl-SB0>c*b{-7r$$Tmd-HeM-WN|=b*9lZ?Xl_q9NWBY;!}%$ zFy*G(&Zw_`|Ig1qBn`S^nCEKN>$aXSDmm^K#B3chPtr|EMhn8!rnw2mGn9 zWrBV$h+ckwm~*5HqAO6JLs+IkpJ`LERf2pH`-+6UE$CB;9fJC+atnbJl@dW!K&p(t zO1cpcp31RE(C-EPL(umJ>2ym4MS)Zqoq~Q3q{?_t(jAf50k{T7<)H5Zt8`fsmMy4I zV&_O$l_0;wwo4dYu%jrilh{oX)+K1K#1^8zSrQUd38c7sSHeCN^p(WsqVKA_`GSfC zT?J%Ok+2U1eI>EEP+E(MpkhH+0VyhPOV|g3j!5jq=o^ZPM^LGtY9K}BMj+DFOd~4j zAwe$*dP~rUg8p03S+EjHUqV2t+?xgc7D$!$goHgM=uL@@0VyhjVZHV+S0@4~dZ!D@ z22%8v0jV6j1f6t(&T*Qc93YirHjtv+AhC-C-6H9pk#uiK>;XZ8PSo@+0a6^)11ZYa z04bht6!cr5=eS0zTsp_UfK<9K1P#g1>Ba!5*ztl&Bz8W~de9qe+zzydDgPQs<+xAK z79dsbXF#f@hv6k|g~kA_XDZ`>o?zsaumwPL0mERU9q0uv;|`z~8T|oBmG-cpr-4*y z`+yYXw3BtZ3_)2yDqSwn9;TNsv896QB;B(T_OhUu#Gd|LUB=mhegve-m?vRB6BLx# z-vYhF92942D$@lu0VyhXNZ8$iHcD*TP@OkJP!^ENI|*nnm*E3ar9BL!TH#rsmpS&- zQ#6&c1x*A}R7!yqm0wHjJ%Tn%x?Pg)Q;9tyC-wLhEZ6d zHw0y#rg3=qMfo*J_l}?=K#GIGqqTIu z52SL80a9`qFQ^nq<@g2AdT#x#68kaGHV#YqfnjtpS_P!2+ySI=&`r9pBR13corFCk z>7JFaQ+{X|+nLIhKq~Kpg8m_~lg8+Dh> zIr@N9jqw`)3q{5gxV)T%ppZr);DH2o(q^K+b`YY#H38XaQ zcarWwL0f=Sj<+Q2BcL~tH`7R&pvyQ7NQIS1Sh=7^AVuYRptm^h8M%h>cSiX@uQIv< zNY%Vr&@v#E_ZA=}wSNPtHacyh&ii8^MQ=KglB6F<(fhfe4j@JE9w0?!Cy;8bm>}aK z9hL=TaVlZg11ZX3LB9l2l<$+UKLfqZbvtX4rdJ50@|Fmy0#bR~C9F%(r$DbUm7YHYz)cQ5*i7l=w%Coerd^oDK92*W(93e`j=&q$?0~ zC6LPTGoW`lT}Wc@7PJj$8)63=uK+1}|B~1*1f5u@>E!^aTILFxEwM`^>~}y)hn|tJ zmj!(Ur1%@)(eld#Qj~`ax&TO}^8jsSPUlK&t)Ocq-3kf2MbK{~c9Vp43ED5Qha~K{ zDOjOmseKPfaWz8F1we|cLJ2DoR3)*`0KLIfGKw@6x1cORc|eNZuO#elK~G5RVIU>b zFQ;mHsl^(d0i>v00Q6Uu)%z0rv7kYh>U2K=Qgtg5G+SbC2inivzY3&um_WHp!X&A#LIPQZb8{VDsL{3;;&RAKuBLBoJl8KWgEN03KiuaYpYpn$}7O4yx( z9+lXWXJ`-QXFxkxBW?#$68g2EzW^y-9s^SS4-8P`NS$=;5QtdXmT(?%epv6Fn z@-GB^03_sm2Mi4N>?LjfuJyuD(xN#+aTx(ASJ(NfmAKeoulc| z*;N%=45VUzFR>2^+6AP_I4oht6`D#0kcu5EVHXN2k=TVmsz%pIY)H^=B;B7S-ByY1 z7PL>&#efvgnLpLMoGEBLkm72tgf$3SBxt#$yA?>a)?*U8UC;}XE+%202>Q;Iy0qtj zR4qRMQtkFHLC4S4=|%%7?i+zrj%$Hbj-a61fmA*20#f|_Sx}Fp+bd{4kjjyAm8P5t zq$m#;^dlgZ?otVxA*fMe+a&B}L2D)UWeIyr&>@Na5=ilU%GH{K5rQrNvN({i8G?Q$ zu}dWEMnQK->^cd17)VKSyM(Mc2)#yBl z{V~uk#11wJfK==>L9>CBmefgDtDtKnHX>o2g6@>q2PABhpe~7hUc%lG^q$0iDq&v> z8eFZp8VaO%K1_K&izKW~!a5}E9tnF$!n!1EuY|oPVV_7CF88r`$pliZ zKSIKCBrH$D$|bBu!WKzbn}l^p*gX>Vkc4$f*j@>HPr^QtFr!xZ1G4y&up9}?lduX2 ztCg@;30p2<9TIkrggqo-T@toe!rqgxPb3VNBw6ws3Z(cODPiLzEMLN^B&;4t_0?-7 zECi%_=qezkC3i{edI{SuVS6O(9SJ)qVJUT*s|+AZ>m)2&!ty1oOv0)qtVP0>OV}z2 zyGz2>OW1Y^+aqD`NZ3IM`&z}^5+lGs5DbQvcI`aY1NJYK>k2`ZD=S_$(D3JK~Ebf2I< z3)%*x%6MABUKI4M#C{BU?VK)Is~l~ zv;j!vcuc~&1??5IU(g{z$1T*nxCEUEWJyxO3I&x5sukoH6cW@SXq})9f}RqzSI~Yz zhXkcGY5q?!(IUTfHiwRkdpXEf{bQe%O3)%*a?ElBzBR6 zEfe$$iG2u2@v;x-c`hx#Mbj%5G!N)Gj{UiWtrYZYi9H1L8mGH>k>0DE0i^i*si0OM zMQ=6G)5tN{cpqphqkjYKVJc~@I&X%c(LgG15s>1!Nn#fZx=GUg1?U;3Os@<)%&0_A zxuAL=MfsmV2bhD8{5r=WL0<~W2?1+Ojhf0iK#J4z1bHNOk%TQ1 z6qVSUgW8Jz5=c?GOVA@gic^0`$6hDsRv;C7H_%ptZ0ut|dw?>Hosw>kp!a}Oj$R<8 zFPULYdAOi)Kq}oF39AxxgT(#@=w&YL8K74f4P2pHbrg__y$ndjHUgI`g6@;pjS}{hgzW}W z^j?kRf4<{>zA-LLG2QIhlJfD=#LWn zxP)~JdQM{BlCYSdPbAj3N!KG?P$rPlp%D^xzMvmV>=X%`CSm1*f`V=lbT^RF#0P7@(;(ziCt-&qY~anh+>?NmB;67=Ucw3_Y`TP1Ntj>4f)e%%30o^+8zgLpguNhP z`y}j;gbj=ee?S(05;k7K3M6d0gjGqHU&4YC_P-iC8{n#nD~{iYO;d{%ra^H0Xy~LP zDvdAizL)o2OQ+E!5^98)L`$c%H(w8l=xdR2l65?A|@Q=iMar4j=#b+p}kP@9y1uU*Mi|6SEO!JD5Gk zY&Wxg%#JXdb|d!>D(oM#1hX1umosZ+HVXBuT32sFy`7%S(X1mv*^gZ6Y)%Yu6RR*Q| z+yte2`Vy4({65=#!s=^VOpVi^wC96Rx~E52mE30Rx}mh^0am-AbdCM24nyg_%-w2g zEQHc_OITe6rR{dG-7!|h+f46gLFu~XtP)VV?iEnF_qRal@&1nOp5oF&%#J|mah!R( z@$5rsb|sYdvYbnQ!Rk6F-R{j$y2fr+hoE%b6HvO(vwv$;IjaPe_OcM_bv66HhSL7- zhI&P@7nzmZVZ6+O(soH^)lhG#8kaI_X0;MZx0Z*}b+3o|Sk>49bx^5Cq5i4VvrxJR zv+p!Dz6+)IjU`Zel$9ro(q&NEOCOhB!|HmryOY^NP`bu5%wAyi29zGr`)qfVOHZ)+#@)uQ97_B1 zp>$8b&#H;-ZiO1f887zsbLq#dzF@o75o32B)JLdM>Lu;6(G-C8r0ZY^Ln2&H?! zgW1!pUgy%1drceXLTN7-vZ{m9UT)1J5v=M#Ns+NDJ;|uDX-4gxWBxz&K2`@Tj&ZS-r+;539Yb_OUv^>H}5>S^bOE5mv`o9cSfz z$BgJ?Rwb;avzo!Gl+_$o^uN#_#u+d6%2<`Nn#XEBs~D>Ut2CUt2Csf7JwTabcDBaVotVXzWJF5p+JIjtX%Q05RS<#!cx^z0L8La4?U0qrRrRThy)jU@7S;bf-SfyDlU{%ek zmQ_8g23C!%T39V*wTx9Ot4>xcSaq|iKv0G(t~WYPe1W&zi}1d-ddFP9w_VYp%g)h% zc|~5CHw}B?L`NN9D}E~*WzdX2hXv`uC%Ox0n?S$7y|fwxo2mNk(T^b18^+cTZVn#h zv9&gjg3#N?*5)~odBWy35PI|1+I#|XGOpmS;BWHfc^I;KQ`p+fMvVs&uFbh1WNvL1 zfW+diO#=wMZEbD3K*nOO4ZYjzebu$O4P>3LxgUhy^0t0n06BJ{>*o!!DRFI%g6t7C z#kfn+o8#8cSs-J=WIF#%&)1Tl*{;o25PBosw)F%Ey{B%;KR|{BISk_Y?irhQGHlLpYkdnOEyi92 z55*qOJX1t3&E0$KqwM`B|iaa5q-WIWUU~-0vQx! z8wl+iwm*LW*(>JauOOp>yb01NY8?g13sPE)mA4{5MO!J5 zMp0`aNWZAn4MGtf?3@mPtP_5QK{g1o9b~g0Pl1dG@^_GN;dw8J*Xp+Q9!R68^%)55 z<92P##4cMe$ax^Og4BUj3$hG^?hw|`AV@-x>p)_H+zm2ckf%V(1$h~yG3$CnT0zy$YY^_I# zh+Xsf zuxSSw7iVLD{9NPup{NL*;>_O(LJ?bRTYm!CF7CN6f>2}^YjcQ*usH$Z4Y@XF;GVox z*qjGKkz1^vi$V5@*=Yiy$S>9=4?>Bb?3KG7gd(R{oBODiIERl@t+lSrOCX-Gc^hP( zu=xz+fH;Sz;HhC)5Q^L|BFOn5qk?=7q*jn0fl!ni+vlYq6fee-EXXo(?Q8&IWGUv%C(3;`UgZyFlpMj9m#&fY5g%O)Bz8a)?TF;56cy z|Hr5wP$3@`Dn`2gh{rP6lw-@IUC$mB?YW%!r1rz2?c`1z6$93hYQ1P2J;UNIICjw} zaNrh&wq_|^_{XcT841Tlee%3RAftjz$CK%pAU;TIQjcBNss$MqHp@ZE1X&GY4qa<= zggh1@yCUSx2zf6;K97)@rGAe5TWB7VMC-cLN1Gt_6XT1NPwiD$QDZOaG17!Utp8%>7Z>^9meJb zX@dka(oc{>bhF<4a$74vAkU7T{sKSm3O`i%d4zm(W>`t}ko@462*>o-b+< zxmb`OmqXmPu!Gt&!oJ&KsJTGC>S&*@5Prz>)e*8jLLQ2c=LJ#cXGP(-kja}Gz@hqs zk@j+jh#Y_qwNF)09@3TB?jcWaCFN_@tnmW<0}K^}FA@bXKwM1~`j^c*D1JMCqF{fz zQkccjlnk2Cc24X;6^bw#uP+FK&hBnisN+ZLkcuL>UQkbglWoc$(+nDqB%^>oic%c} z6)E3O_-q;mtTdtZJYna@bgPA723@1HbvDSOcEfqP#)(R_Y-2J`-OofUm2s^nimmB5 zPsIGh1m-eSrLd1DU3(|grLeN&qd<@pU>$!`Fnn`vI0T|o&CehaU$}^9)+vypspZT> zGLv$@X|cnT=Il50_K&c^2E5c%nhSasSFq>Z_a+ujFIpP$Q%1V4T zBUmCbEd>2&NG1+Z$mIPHeqtG{BYS3iwUauZD{1SqpW~S{t_HK;=+uk>W$ezOH!_`w zQ_GK4qLvAo8}9wix)1VMq&h%sT;n>(4k9csJkXs@tqDY14b1ILW0l;bfSI%^1=!?k zVN7dRH$h6p0OrN$B#mSyG6Hzv-87Qik=K3drfF z&infyR*~AI-7w{}Qjm*kRhIUlY+Fx2&%l&mqZ&O8pSubJ13SI;eV_eLerNS#jn~R! zZkxa@sjaKWj?~@D{5U-|(gyG)o?`rT3d_Wq=~NuOaz7{JgHj6raOak%Y4Xhp(tA(1 zPV|LXu$M=Z(zxF6ScYvG^*M}tMOSX1ts;&&wtb3cVz8nCMwVha=1fJLSl&+;|NkckfE7#G7xy#bml+`(`X*_DeI_&T&D6W3+!>GHj4IA%J4v&81ji#2}7Hlarba;Sy9tp2<^t~i(pTEcI5_S-7=%$#u YW;RRYN$SA!#1MYMK|2SQ9pxweACRa^Qvd(} literal 0 HcmV?d00001 diff --git a/src/ini/LICENSE b/src/ini/LICENSE new file mode 100644 index 0000000..2b5ae44 --- /dev/null +++ b/src/ini/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2020 9hkke + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/src/ini/ini.zig b/src/ini/ini.zig new file mode 100644 index 0000000..c5d8060 --- /dev/null +++ b/src/ini/ini.zig @@ -0,0 +1,324 @@ +const std = @import("std"); + +const Token = struct { + kind: enum { + nil, + comment, + section, + identifier, + value, + }, + value: ?[]const u8, +}; +const TokenizerState = enum(u3) { + nil, + comment, + section, + identifier, + value, + string, +}; + +const booleanMap = std.ComptimeStringMap(bool, .{ + .{ "1", true }, + .{ "enabled", true }, + .{ "Enabled", true }, + .{ "on", true }, + .{ "On", true }, + .{ "true", true }, + .{ "t", true }, + .{ "True", true }, + .{ "T", true }, + .{ "yes", true }, + .{ "y", true }, + .{ "Yes", true }, + .{ "Y", true }, + .{ "0", false }, + .{ "disabled", false }, + .{ "Disabled", false }, + .{ "off", false }, + .{ "Off", false }, + .{ "false", false }, + .{ "f", false }, + .{ "False", false }, + .{ "F", false }, + .{ "no", false }, + .{ "n", false }, + .{ "No", false }, + .{ "N", false }, +}); + +pub fn parse(comptime T: type, data: []const u8) !T { + var seek: usize = 0; + var state = TokenizerState.nil; + var val = std.mem.zeroes(T); + var csec: []const u8 = undefined; + var cid: []const u8 = undefined; + + while (consume(data[0..], &seek, &state)) |token| { + switch (token.kind) { + .nil, .comment => {}, + .section => csec = token.value.?, + .identifier => { + cid = token.value.?; + const tk = consume(data[0..], &seek, &state).?; + if (tk.kind != .value) + return error.IniSyntaxError; + const info1 = @typeInfo(T); + if (info1 != .Struct) + @compileError("Invalid Archetype"); + + inline for (info1.Struct.fields) |f| { + if (std.mem.eql(u8, f.name, csec)) { + const info2 = @typeInfo(@TypeOf(@field(val, f.name))); + if (info2 != .Struct) + @compileError("Naked field in archetype"); + + inline for (info2.Struct.fields) |ff| { + if (std.mem.eql(u8, ff.name, cid)) { + const TT = ff.field_type; + @field(@field(val, f.name), ff.name) = coerce(TT, tk.value.?) catch unreachable; // error.IniInvalidCoerce; + } + } + } + } + }, + else => return error.IniSyntaxError, + } + } + return val; +} + +fn coerce(comptime T: type, v: []const u8) !T { + return switch (@typeInfo(T)) { + .Bool => booleanMap.get(v).?, + .Float, .ComptimeFloat => try std.fmt.parseFloat(T, v), + .Int, .ComptimeInt => try std.fmt.parseInt(T, v, 10), + else => @as(T, v), + }; +} + +const IniMap = std.StringHashMap([]const u8); +pub const IniResult = struct { + map: IniMap, + allocator: std.mem.Allocator, + + pub fn deinit(self: *IniResult) void { + defer self.map.deinit(); + var iter = self.map.iterator(); + while (iter.next()) |i| + self.allocator.free(i.key_ptr.*); + } +}; + +pub fn parseIntoMap(data: []const u8, allocator: std.mem.Allocator) !IniResult { + var seek: usize = 0; + var state = TokenizerState.nil; + var csec: []const u8 = undefined; + var cid: []const u8 = undefined; + var map = IniMap.init(allocator); + + while (consume(data[0..], &seek, &state)) |token| { + switch (token.kind) { + .nil, .comment => {}, + .section => csec = token.value.?, + .identifier => { + cid = token.value.?; + var tk = consume(data[0..], &seek, &state).?; + if (tk.kind != .value) + return error.IniSyntaxError; + var coc = try std.fmt.allocPrint(allocator, "{s}.{s}", .{ csec, cid }); + try map.putNoClobber(coc, tk.value.?); + }, + else => return error.IniSyntaxError, + } + } + return IniResult{ .map = map, .allocator = allocator }; +} + +fn consume(data: []const u8, seek: *usize, state: *TokenizerState) ?Token { + if (seek.* >= data.len) return null; + var token: Token = std.mem.zeroes(Token); + var start = seek.*; + var end = start; + var char: u8 = 0; + + @setEvalBranchQuota(100000); + while (char != '\n') { + char = data[seek.*]; + seek.* += 1; + switch (state.*) { + .nil => { + switch (char) { + ';', '#' => { + state.* = .comment; + start = seek.*; + if (std.ascii.isSpace(data[start])) start += 1; + end = start; + }, + '[' => { + state.* = .section; + start = seek.*; + end = start; + }, + '=' => { + state.* = .value; + start = seek.*; + if (std.ascii.isSpace(data[start])) start += 1; + end = start; + }, + else => { + if (!std.ascii.isSpace(char)) { + state.* = .identifier; + start = start; + end = start; + } else { + start += 1; + end += 1; + } + }, + } + }, + .identifier => { + end += 1; + if (!(std.ascii.isAlNum(char) or char == '_')) { + state.* = .nil; + return Token{ + .kind = .identifier, + .value = data[start..end], + }; + } + }, + .comment => { + end += 1; + switch (char) { + '\n' => { + state.* = .nil; + return Token{ + .kind = .comment, + .value = data[start .. end - 2], + }; + }, + else => {}, + } + }, + .section => { + end += 1; + switch (char) { + ']' => { + state.* = .nil; + return Token{ + .kind = .section, + .value = data[start .. end - 1], + }; + }, + else => {}, + } + }, + .value => { + switch (char) { + ';', '#' => { + state.* = .comment; + return Token{ + .kind = .value, + .value = data[start .. end - 2], + }; + }, + else => { + end += 1; + switch (char) { + '\n' => { + state.* = .nil; + return Token{ + .kind = .value, + .value = data[start .. end - 2], + }; + }, + else => {}, + } + }, + } + }, + else => {}, + } + } + + return token; +} + +test "parse into map" { + var file = try std.fs.cwd().openFile("src/test.ini", .{ .read = true, .write = false }); + defer file.close(); + var data = try std.testing.allocator.alloc(u8, try file.getEndPos()); + defer std.testing.allocator.free(data); + _ = try file.read(data); + + var ini = try parseIntoMap(data, std.testing.allocator); + defer ini.deinit(); + + try std.testing.expectEqualStrings("John Doe", ini.map.get("owner.name").?); + try std.testing.expectEqualStrings("Acme Widgets Inc.", ini.map.get("owner.organization").?); + try std.testing.expectEqualStrings("192.0.2.62", ini.map.get("database.server").?); + try std.testing.expectEqualStrings("143", ini.map.get("database.port").?); + try std.testing.expectEqualStrings("payroll.dat", ini.map.get("database.file").?); + try std.testing.expectEqualStrings("yes", ini.map.get("database.use").?); + try std.testing.expectEqualStrings("bar", ini.map.get("withtabs.foo").?); +} + +test "parse into struct" { + var file = try std.fs.cwd().openFile("src/test.ini", .{ .read = true, .write = false }); + defer file.close(); + var data = try std.testing.allocator.alloc(u8, try file.getEndPos()); + defer std.testing.allocator.free(data); + _ = try file.read(data); + + const Config = struct { + owner: struct { + name: []const u8, + organization: []const u8, + }, + database: struct { + server: []const u8, + port: usize, + file: []const u8, + use: bool, + }, + }; + + var config = try parse(Config, data); + + try std.testing.expectEqualStrings("John Doe", config.owner.name); + try std.testing.expectEqualStrings("Acme Widgets Inc.", config.owner.organization); + try std.testing.expectEqualStrings("192.0.2.62", config.database.server); + try std.testing.expectEqual(@as(usize, 143), config.database.port); + try std.testing.expectEqualStrings("payroll.dat", config.database.file); + try std.testing.expectEqual(true, config.database.use); +} + +test "parse in comptime into struct" { + const config = comptime block: { + const data = @embedFile("test.ini"); + const Config = struct { + owner: struct { + name: []const u8, + organization: []const u8, + }, + database: struct { + server: []const u8, + port: usize, + file: []const u8, + use: bool, + }, + }; + + var config = try parse(Config, data); + break :block config; + }; + + try std.testing.expectEqualStrings("John Doe", config.owner.name); + try std.testing.expectEqualStrings("Acme Widgets Inc.", config.owner.organization); + try std.testing.expectEqualStrings("192.0.2.62", config.database.server); + try std.testing.expectEqual(@as(usize, 143), config.database.port); + try std.testing.expectEqualStrings("payroll.dat", config.database.file); + try std.testing.expectEqual(true, config.database.use); +} diff --git a/src/main.zig b/src/main.zig new file mode 100644 index 0000000..5a11476 --- /dev/null +++ b/src/main.zig @@ -0,0 +1,7 @@ +const std = @import("std"); +const ini = @import("ini/ini.zig"); +const usb = @cImport(@cInclude("libusb.h")); + +export fn chuni_io_get_api_version() c_ushort { + return 0x0101; +}