From 8a32b3fef6fddafae3b8a598b957d11f5cbcf0f6 Mon Sep 17 00:00:00 2001 From: annie_wangli Date: Mon, 29 Nov 2021 11:13:51 +0800 Subject: [PATCH] update docs Signed-off-by: annie_wangli --- en/device-dev/driver/Readme-EN.md | 3 +- .../driver/driver-peripherals-usb-des.md | 1571 +++++++++++++++++ .../figures/USB_device_driver_model.png | Bin 0 -> 33914 bytes .../driver/figures/USB_host_driver_model.png | Bin 0 -> 42495 bytes 4 files changed, 1573 insertions(+), 1 deletion(-) create mode 100644 en/device-dev/driver/driver-peripherals-usb-des.md create mode 100644 en/device-dev/driver/figures/USB_device_driver_model.png create mode 100644 en/device-dev/driver/figures/USB_host_driver_model.png diff --git a/en/device-dev/driver/Readme-EN.md b/en/device-dev/driver/Readme-EN.md index eb21fdeec40..c2c3dea84df 100644 --- a/en/device-dev/driver/Readme-EN.md +++ b/en/device-dev/driver/Readme-EN.md @@ -33,4 +33,5 @@ - [LCD](driver-peripherals-lcd-des.md) - [TOUCHSCREEN](driver-peripherals-touch-des.md) - [Sensor](driver-peripherals-sensor-des.md) - - [WLAN](driver-peripherals-external-des.md) \ No newline at end of file + - [WLAN](driver-peripherals-external-des.md) + - [USB](driver-peripherals-usb-des.md) \ No newline at end of file diff --git a/en/device-dev/driver/driver-peripherals-usb-des.md b/en/device-dev/driver/driver-peripherals-usb-des.md new file mode 100644 index 00000000000..0dd421ec369 --- /dev/null +++ b/en/device-dev/driver/driver-peripherals-usb-des.md @@ -0,0 +1,1571 @@ +# USB + +- [Overview](#section175431838101617) + - [Available APIs](#section17667171301711) + +- [Development Guidelines](#section65745222184) + - [Developing Driver Using Host DDK APIs](#section865734181916) + - [Developing Driver Using Host Raw APIs](#section865734181916) + - [Developing Driver Using Device DDK APIs](#section865734181916) + +- [Development Examples](#section263714411191) + - [Developing Driver Using Host DDK APIs](#section18249155619195) + - [Developing Driver Using Host Raw APIs](#section3571192072014) + - [Developing Driver Using Device DDK APIs](#section6356758162015) + + +## Overview + +USB host development aims to provide host-related functions, including protocol encapsulation, device management, and driver installation and uninstall. + +USB device development aims to provide device-related functions, including device management, configuration management, and I/O management. These functions implement creation, configuration, and data communication of USB devices. + +The following figures show the UBS host and device driver models. + +**Figure 1** USB host driver model +![](figures/USB_host_driver_model.png "USB host driver model") + +**Figure 2** USB device driver model +![](figures/USB_device_driver_model.png "USB device driver model") + +The USB driver model offers the following APIs: + +- The USB host Driver Development Kit (DDK) provides driver capability APIs that can be directly called in user mode. The APIs can be classified into the DDK initialization class, interface operation class, and request operation class by function. These APIs can be used to perform DDK initialization, bind/release and open/close an interface, allocate/release a request, and implement isochronous or non-isochronous transfer. +- The USB device DDK provides device management, I/O management, and configuration management APIs, which can be used to create and delete a device, obtain/open an interface, and perform isochronous or non-isochronous transfer. + +### Available APIs + +Table 1 describes the APIs provided by the USB host driver model. + +**Table 1** APIs provided by the USB host driver model + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Header File

+

API

+

Description

+

usb_ddk_interface.h

+

+

+

int32_t UsbInitHostSdk(struct UsbSession **session);

+

Initializes the USB host driver DDK.

+

int32_t UsbExitHostSdk(const struct UsbSession *session);

+

Exits the USB host driver DDK.

+

const struct UsbInterface *UsbClaimInterface(const struct UsbSession *session, uint8_t busNum, uint8_t usbAddr, uint8_t interfaceIndex);

+

Obtains a USB interface.

+

int UsbReleaseInterface(const struct UsbInterface *interfaceObj);

+

Releases a USB interface.

+

int UsbAddOrRemoveInterface(const struct UsbSession *session, uint8_t busNum, uint8_t usbAddr, uint8_t interfaceIndex, UsbInterfaceStatus status);

+

Adds or removes a USB interface.

+

UsbInterfaceHandle *UsbOpenInterface(const struct UsbInterface *interfaceObj);

+

Opens a USB interface.

+

int32_t UsbCloseInterface(const UsbInterfaceHandle *interfaceHandle);

+

Closes a USB interface.

+

int32_t UsbSelectInterfaceSetting(const UsbInterfaceHandle *interfaceHandle, uint8_t settingIndex, struct UsbInterface **interfaceObj);

+

Sets a USB interface.

+

int32_t UsbGetPipeInfo(const UsbInterfaceHandle *interfaceHandle, uint8_t settingIndex, uint8_t pipeId, struct UsbPipeInfo *pipeInfo);

+

Obtains USB pipe information.

+

int32_t UsbClearInterfaceHalt(const UsbInterfaceHandle *interfaceHandle, uint8_t pipeAddress);

+

Clears the state of the pipe with the specified index.

+

struct UsbRequest *UsbAllocRequest(const UsbInterfaceHandle *interfaceHandle, int isoPackets, int length);

+

Allocates a request object.

+

int UsbFreeRequest(const struct UsbRequest *request);

+

Releases a request object.

+

int UsbSubmitRequestAsync(const struct UsbRequest *request);

+

Sends a request asynchronously.

+

int32_t UsbFillRequest(const struct UsbRequest *request, const UsbInterfaceHandle *interfaceHandle, const struct UsbRequestParams *params);

+

Fills in a request.

+

sint UsbCancelRequest(const struct UsbRequest *request);

+

Cancels an asynchronous request.

+

int UsbSubmitRequestSync(const struct UsbRequest *request);

+

Sends a synchronous request.

+

usb_raw_api.h

+

+

+

+

+

+

int UsbRawInit(struct UsbSession **session);

+

Initializes the USB raw APIs.

+

int UsbRawExit(const struct UsbSession *session);

+

Exits the USB raw APIs.

+

UsbRawHandle *UsbRawOpenDevice(const struct UsbSession *session, uint8_t busNum, uint8_t usbAddr);

+

Opens a USB device.

+

int UsbRawCloseDevice(const UsbRawHandle *devHandle);

+

Closes a USB device.

+

int UsbRawSendControlRequest(const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbControlRequestData *requestData);

+

Performs a control transfer synchronously.

+

int UsbRawSendBulkRequest(const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbRequestData *requestData);

+

Performs a bulk transfer synchronously.

+

int UsbRawSendInterruptRequest(const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbRequestData *requestData);

+

Performs an interrupt transfer synchronously.

+

int UsbRawGetConfigDescriptor(const UsbRawDevice *rawDev, uint8_t configIndex, struct UsbRawConfigDescriptor **config);

+

Obtains the configuration descriptor of a device.

+

void UsbRawFreeConfigDescriptor(const struct UsbRawConfigDescriptor *config);

+

Releases the memory space of a configuration descriptor.

+

int UsbRawGetConfiguration(const UsbRawHandle *devHandle, int *config);

+

Obtains the configuration in use.

+

int UsbRawSetConfiguration(const UsbRawHandle *devHandle, int config);

+

Sets the configuration in use.

+

int UsbRawGetDescriptor(const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbRawDescriptorParam *param, const unsigned char *data);

+

Obtains descriptor information.

+

UsbRawDevice *UsbRawGetDevice(const UsbRawHandle *devHandle);

+

Obtains the device pointer based on the device handle.

+

int UsbRawGetDeviceDescriptor(const UsbRawDevice *rawDev, struct UsbDeviceDescriptor *desc);

+

Obtains the device descriptor of the specified USB device.

+

int UsbRawClaimInterface(const UsbRawHandle *devHandle, int interfaceNumber);

+

Declares the interface on the specified device handle.

+

int UsbRawReleaseInterface(const UsbRawHandle *devHandle, int interfaceNumber);

+

Releases the previously declared interface.

+

int UsbRawResetDevice(const UsbRawHandle *devHandle);

+

Resets a device.

+

struct UsbRawRequest *UsbRawAllocRequest(const UsbRawHandle *devHandle, int isoPackets, int length);

+

Allocates a transfer request with the specified number of sync packet descriptors.

+

int UsbRawFreeRequest(const struct UsbRawRequest *request);

+

Releases the previously allocated transfer request.

+

int UsbRawFillBulkRequest(const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbRawFillRequestData *fillData);

+

Fills in the bulk transfer request.

+

int UsbRawFillControlSetup(const unsigned char *setup, const struct UsbControlRequestData *requestData);

+

Fills in the control setup packet.

+

int UsbRawFillControlRequest(const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbRawFillRequestData *fillData);

+

Fills in the control transfer request.

+

int UsbRawFillInterruptRequest(const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbRawFillRequestData *fillData);

+

Fills in the interrupt transfer request.

+

int UsbRawFillIsoRequest(const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbRawFillRequestData *fillData);

+

Fills in the isochronous transfer request.

+

int UsbRawSubmitRequest(const struct UsbRawRequest *request);

+

Submits a transfer request.

+

int UsbRawCancelRequest(const struct UsbRawRequest *request);

+

Cancels a transfer request.

+

int UsbRawHandleRequests(const UsbRawHandle *devHandle);

+

Handles a transfer request event.

+
+ +Table 2 describes the APIs provided by the USB device driver model. + +**Table 2** APIs provided by the USB device driver model + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Header File

+

API

+

Description

+

usbfn_device.h

+

+

+

const struct UsbFnDevice *UsbFnCreateDevice(const char *udcName, const struct UsbFnDescriptorData *descriptor);

+

Creates a USB device.

+

int UsbFnRemoveDevice(struct UsbFnDevice *fnDevice);

+

Deletes a USB device.

+

const struct UsbFnDevice *UsbFnGetDevice(const char *udcName);

+

Obtains a USB device.

+

usbfn_interface.h

+

+

+

+

+

+

int UsbFnStartRecvInterfaceEvent(struct UsbFnInterface *interface, uint32_t eventMask, UsbFnEventCallback callback, void *context);

+

Starts to receive events.

+

int UsbFnStopRecvInterfaceEvent(struct UsbFnInterface *interface);

+

Stops receiving events.

+

UsbFnInterfaceHandle UsbFnOpenInterface(struct UsbFnInterface *interface);

+

Opens an interface.

+

int UsbFnCloseInterface(UsbFnInterfaceHandle handle);

+

Closes an interface.

+

int UsbFnGetInterfacePipeInfo(struct UsbFnInterface *interface, uint8_t pipeId, struct UsbFnPipeInfo *info);

+

Obtains pipe information.

+

int UsbFnSetInterfaceProp(const struct UsbFnInterface *interface, const char *name, const char *value);

+

Sets custom properties.

+

usbfn_request.h

+

+

+

+

+

+

+

+

struct UsbFnRequest *UsbFnAllocCtrlRequest(UsbFnInterfaceHandle handle, uint32_t len);

+

Applies for a control transfer request.

+

struct UsbFnRequest *UsbFnAllocRequest(UsbFnInterfaceHandle handle, uint8_t pipe, uint32_t len);

+

Applies for a data request.

+

int UsbFnFreeRequest(struct UsbFnRequest *req);

+

Releases a request.

+

int UsbFnSubmitRequestAsync(struct UsbFnRequest *req);

+

Sends a request asynchronously.

+

int UsbFnSubmitRequestSync(struct UsbFnRequest *req, uint32_t timeout);

+

Sends a request synchronously.

+

int UsbFnCancelRequest(struct UsbFnRequest *req);

+

Cancels a request.

+
+ +## Development Guidelines + +The USB driver is developed based on the Hardware Driver Foundation (HDF), platform, and Operating System Abstraction Layer (OSAL) APIs. A unified driver model is provided for USB devices, irrespective of the operating system and chip architecture. This document uses a serial port as an example to describe how to develop drivers for the USB host and USB device. + +### How to Develop + +### Developing Driver Using Host DDK APIs + +1. Configure the driver mapping table. +2. Initialize the USB host DDK. +3. Obtain a **UsbInterface** object. +4. Open the **UsbInterface** object to obtain the **UsbInterfaceHandle** object. +5. Obtain pipe information of the specified **pipeIndex** based on the **UsbInterfaceHandle** object. +6. Allocate an I/O request for the **UsbInterfaceHandle** object. +7. Fill in the I/O request based on the input parameters. +8. Submit the I/O request in synchronous or asynchronous mode. + + +### Developing Driver Using Host Raw APIs + +1. Configure the driver mapping table. +2. Initialize the host raw data, open the USB device, obtain the descriptor, and then obtain interface and endpoint information based on the descriptor. +3. Allocate a request and fill in the request based on the transfer type. +4. Submit the I/O request object in synchronous or asynchronous mode. + +### Developing Driver Using Device DDK APIs + +1. Construct a descriptor. +2. Instantiate a USB device using the descriptor constructed. +3. Call **UsbFnDeviceGetInterface** to obtain an interface, call **UsbFnInterfaceGetPipeInfo** to obtain pipe information based on the interface, call **UsbFnInterfaceOpen** to open the interface to obtain the handle, and call **UsbFnRequestAlloc** to obtain the request based on the handle and pipe ID. +4. Call **UsbFnInterfaceStartRecvEvent** to receive events such as Enable and Setup, and respond to the events in **UsbFnEventCallback**. +5. Send and receive data in synchronous or asynchronous mode. + +## Development Examples + +The following example helps you better understand the development of the USB serial port driver. + +### Developing Driver Using Host DDK APIs + +``` +root { + module = "usb_pnp_device"; + usb_pnp_config { + match_attr = "usb_pnp_match"; + usb_pnp_device_id = "UsbPnpDeviceId"; + UsbPnpDeviceId { + idTableList = [ + "host_acm_table" + ]; + host_acm_table { + // Driver module name, which must be the same as the value of moduleName in the driver entry structure. + moduleName = "usbhost_acm"; + // Service name of the driver, which must be unique. + serviceName = "usbhost_acm_pnp_service"; + // Keyword for matching private driver data. + deviceMatchAttr = "usbhost_acm_pnp_matchAttr"; + // Data length starting from this field, in bytes. + length = 21; + // USB driver matching rule: vendorId+productId+interfaceSubClass+interfaceProtocol+interfaceNumber. + matchFlag = 0x0303; + // Vendor ID. + vendorId = 0x12D1; + // Product ID. + productId = 0x5000; + // The least significant 16 bits of the device sequence number. + bcdDeviceLow = 0x0000; + // The most significant 16 bits of the device sequence number. + bcdDeviceHigh = 0x0000; + // Device class code allocated by the USB. + deviceClass = 0; + // Child class code allocated by the USB. + deviceSubClass = 0; + // Device protocol code allocated by the USB. + deviceProtocol = 0; + // Interface type. You can enter multiple types as needed. + interfaceClass = [0]; + // Interface subtype. You can enter multiple subtypes as needed. + interfaceSubClass = [2, 0]; + // Protocol that the interface complies with. You can enter multiple protocols as needed. + interfaceProtocol = [1, 2]; + // Interface numer. You can enter multiple interface numbers as needed. + interfaceNumber = [2, 3]; + } + } + } +} + +#include "usb_serial.h" +#include "hdf_base.h" +#include "hdf_log.h" +#include "osal_mem.h" +#include "osal_time.h" +#include "securec.h" +#include "usb_ddk_interface.h" +#include "hdf_usb_pnp_manage.h" + +#define HDF_LOG_TAG USB_HOST_ACM +#define STR_LEN 512 + +static struct UsbRequest *g_syncRequest = NULL; +static struct UsbRequest *g_ctrlCmdRequest = NULL; +static bool g_acmReleaseFlag = false; +static uint8_t *g_acmReadBuffer = NULL; +... +static int SerialCtrlMsg(struct AcmDevice *acm, uint8_t request, + uint16_t value, void *buf, uint16_t len) +{ + int ret; + uint16_t index = acm->intPipe->interfaceId; + struct UsbControlParams controlParams = {}; + struct UsbRequestParams parmas = {}; + if (acm == NULL || buf == NULL) { + HDF_LOGE("%{public}s:invalid param", __func__); + return HDF_ERR_IO; + } + if (acm->ctrlReq == NULL) { + acm->ctrlReq = UsbAllocRequest(acm->ctrDevHandle, 0, len); + if (acm->ctrlReq == NULL) { + HDF_LOGE("%{public}s: UsbAllocRequest failed", __func__); + return HDF_ERR_IO; + } + } + + controlParams.request = request; + controlParams.target = USB_REQUEST_TARGET_INTERFACE; + controlParams.reqType = USB_REQUEST_TYPE_CLASS; + controlParams.directon = USB_REQUEST_DIR_TO_DEVICE; + controlParams.value = value; + controlParams.index = index; + controlParams.data = buf; + controlParams.size = len; + + parmas.interfaceId = USB_CTRL_INTERFACE_ID; + parmas.pipeAddress = acm->ctrPipe->pipeAddress; + parmas.pipeId = acm->ctrPipe->pipeId; + parmas.requestType = USB_REQUEST_PARAMS_CTRL_TYPE; + parmas.timeout = USB_CTRL_SET_TIMEOUT; + parmas.ctrlReq = UsbControlSetUp(&controlParams); + ret = UsbFillRequest(acm->ctrlReq, acm->ctrDevHandle, &parmas); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%{public}s: failed, ret=%{public}d ", __func__, ret); + return ret; + } + ret = UsbSubmitRequestSync(acm->ctrlReq); // Send an I/O request synchronously. + if (HDF_SUCCESS != ret) { + HDF_LOGE("UsbSubmitRequestSync faile, ret=%{public}d ", ret); + return ret; + } + if (!acm->ctrlReq->compInfo.status) { + HDF_LOGE("%{public}s status=%{public}d ", __func__, acm->ctrlReq->compInfo.status); + } + return HDF_SUCCESS; +} +... +static struct UsbInterface *GetUsbInterfaceById(const struct AcmDevice *acm, + uint8_t interfaceIndex) +{ + struct UsbInterface *tmpIf = NULL; + tmpIf = (struct UsbInterface *)UsbClaimInterface(acm->session, acm->busNum, \ + acm->devAddr, interfaceIndex); // Obtain the UsbInterface object. + return tmpIf; +} +... +static struct UsbPipeInfo *EnumePipe(const struct AcmDevice *acm, + uint8_t interfaceIndex, UsbPipeType pipeType, UsbPipeDirection pipeDirection) +{ + uint8_t i; + int ret; + struct UsbInterfaceInfo *info = NULL; + UsbInterfaceHandle *interfaceHandle = NULL; + if (pipeType == USB_PIPE_TYPE_CONTROL) + { + info = &acm->ctrIface->info; + interfaceHandle = acm->ctrDevHandle; + } + else + { + info = &acm->iface[interfaceIndex]->info; + interfaceHandle = InterfaceIdToHandle(acm, info->interfaceIndex); + } + + for (i = 0; i <= info->pipeNum; i++) { + struct UsbPipeInfo p; + ret = UsbGetPipeInfo(interfaceHandle, info->curAltSetting, i, &p);// Obtain information about the pipe with index i. + if (ret < 0) { + continue; + } + if ((p.pipeDirection == pipeDirection) && (p.pipeType == pipeType)) { + struct UsbPipeInfo *pi = OsalMemCalloc(sizeof(*pi)); + if (pi == NULL) { + HDF_LOGE("%{public}s: Alloc pipe failed", __func__); + return NULL; + } + p.interfaceId = info->interfaceIndex; + *pi = p; + return pi; + } + } + return NULL; +} + +static struct UsbPipeInfo *GetPipe(const struct AcmDevice *acm, + UsbPipeType pipeType, UsbPipeDirection pipeDirection) +{ + uint8_t i; + if (acm == NULL) { + HDF_LOGE("%{public}s: invalid parmas", __func__); + return NULL; + } + for (i = 0; i < acm->interfaceCnt; i++) { + struct UsbPipeInfo *p = NULL; + if (!acm->iface[i]) { + continue; + } + p = EnumePipe(acm, i, pipeType, pipeDirection); + if (p == NULL) { + continue; + } + return p; + } + return NULL; +} + +/* HdfDriverEntry implementations */ +static int32_t UsbSerialDriverBind(struct HdfDeviceObject *device) +{ + struct UsbPnpNotifyServiceInfo *info = NULL; + errno_t err; + struct AcmDevice *acm = NULL; + if (device == NULL) { + HDF_LOGE("%s: device is null", __func__); + return HDF_ERR_INVALID_OBJECT; + } + acm = (struct AcmDevice *)OsalMemCalloc(sizeof(*acm)); + if (acm == NULL) { + HDF_LOGE("%s: Alloc usb serial device failed", __func__); + return HDF_FAILURE; + } + if (OsalMutexInit(&acm->lock) != HDF_SUCCESS) { + HDF_LOGE("%s:%d OsalMutexInit fail", __func__, __LINE__); + goto error; + } + info = (struct UsbPnpNotifyServiceInfo *)device->priv; + if (info != NULL) { + HDF_LOGD("%s:%d busNum=%d,devAddr=%d,interfaceLength=%d", \ + __func__, __LINE__, info->busNum, info->devNum, info->interfaceLength); + acm->busNum = info->busNum; + acm->devAddr = info->devNum; + acm->interfaceCnt = info->interfaceLength; + err = memcpy_s((void *)(acm->interfaceIndex), USB_MAX_INTERFACES, + (const void*)info->interfaceNumber, info->interfaceLength); + if (err != EOK) { + HDF_LOGE("%s:%d memcpy_s failed err=%d", \ + __func__, __LINE__, err); + goto lock_error; + } + } else { + HDF_LOGE("%s:%d info is NULL!", __func__, __LINE__); + goto lock_error; + } + acm->device = device; + device->service = &(acm->service); + acm->device->service->Dispatch = UsbSerialDeviceDispatch; + HDF_LOGD("UsbSerialDriverBind=========================OK"); + return HDF_SUCCESS; + +lock_error: + if (OsalMutexDestroy(&acm->lock)) { + HDF_LOGE("%s:%d OsalMutexDestroy fail", __func__, __LINE__); + } +error: + OsalMemFree(acm); + acm = NULL; + return HDF_FAILURE; +} +... +static int AcmAllocReadRequests(struct AcmDevice *acm) +{ + int ret; + struct UsbRequestParams readParmas = {}; + for (int i = 0; i < ACM_NR; i++) { + acm->readReq[i] = UsbAllocRequest(InterfaceIdToHandle(acm, acm->dataInPipe->interfaceId), 0, acm->readSize); // Allocate the readReq I/O request object to be sent. + if (!acm->readReq[i]) { + HDF_LOGE("readReq request failed\n"); + goto error; + } + readParmas.userData = (void *)acm; + readParmas.pipeAddress = acm->dataInPipe->pipeAddress; + readParmas.pipeId = acm->dataInPipe->pipeId; + readParmas.interfaceId = acm->dataInPipe->interfaceId; + readParmas.callback = AcmReadBulk; + readParmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE; + readParmas.timeout = USB_CTRL_SET_TIMEOUT; + readParmas.dataReq.numIsoPackets = 0; + readParmas.dataReq.directon = (acm->dataInPipe->pipeDirection >> USB_PIPE_DIR_OFFSET) & 0x1; + readParmas.dataReq.length = acm->readSize; + ret = UsbFillRequest(acm->readReq[i], InterfaceIdToHandle(acm, acm->dataInPipe->interfaceId), &readParmas); // Fill in the readReq object to be sent. + if (HDF_SUCCESS != ret) { + HDF_LOGE("%{public}s: UsbFillRequest faile, ret=%{public}d \n", __func__, ret); + goto error; + } + } + return HDF_SUCCESS; + +error: + AcmFreeReadRequests(acm); + return HDF_ERR_MALLOC_FAIL; +} + +static int AcmAllocNotifyRequest(struct AcmDevice *acm) +{ + int ret; + struct UsbRequestParams intParmas = {}; + acm->notifyReq = UsbAllocRequest(InterfaceIdToHandle(acm, acm->intPipe->interfaceId), 0, acm->intSize); // Allocate the interrupt I/O request object to be sent. + if (!acm->notifyReq) { + HDF_LOGE("notifyReq request fail\n"); + return HDF_ERR_MALLOC_FAIL; + } + intParmas.userData = (void *)acm; + intParmas.pipeAddress = acm->intPipe->pipeAddress; + intParmas.pipeId = acm->intPipe->pipeId; + intParmas.interfaceId = acm->intPipe->interfaceId; + intParmas.callback = AcmCtrlIrq; + intParmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE; + intParmas.timeout = USB_CTRL_SET_TIMEOUT; + intParmas.dataReq.numIsoPackets = 0; + intParmas.dataReq.directon = (acm->intPipe->pipeDirection >> USB_PIPE_DIR_OFFSET) & DIRECTION_MASK; + intParmas.dataReq.length = acm->intSize; + ret = UsbFillRequest(acm->notifyReq, InterfaceIdToHandle(acm, acm->intPipe->interfaceId), &intParmas); // Fill in the interrupt I/O request. + if (HDF_SUCCESS != ret) { + HDF_LOGE("%{public}s: UsbFillRequest faile, ret=%{public}d \n", __func__, ret); + goto error; + } + return HDF_SUCCESS; + +error: + AcmFreeNotifyReqeust(acm); + return ret; +} + +static void AcmReleaseInterfaces(struct AcmDevice *acm) +{ + for (int i = 0; i < acm->interfaceCnt; i++) { + if (acm->iface[i]) { + UsbReleaseInterface(acm->iface[i]); + acm->iface[i] = NULL; + } + } + if (acm->ctrIface) { + UsbReleaseInterface(acm->ctrIface); + acm->ctrIface = NULL; + } +} + +static int32_t AcmClaimInterfaces(struct AcmDevice *acm) +{ + for (int i = 0; i < acm->interfaceCnt; i++) { + acm->iface[i] = GetUsbInterfaceById((const struct AcmDevice *)acm, acm->interfaceIndex[i]); // Obtain the UsbInterface object. + if (acm->iface[i] == NULL) { + HDF_LOGE("%{public}s: interface%{public}d is null", __func__, acm->interfaceIndex[i]); + goto error; + } + } + + acm->ctrIface = GetUsbInterfaceById((const struct AcmDevice *)acm, USB_CTRL_INTERFACE_ID); // Obtain the UsbInterface object corresponding to the control interface. + if (acm->ctrIface == NULL) { + HDF_LOGE("%{public}s: GetUsbInterfaceById null", __func__); + goto error; + } + + return HDF_SUCCESS; + + error: + AcmReleaseInterfaces(acm); + return HDF_FAILURE; +} + +static void AcmCloseInterfaces(struct AcmDevice *acm) +{ + for (int i = 0; i < acm->interfaceCnt; i++) { + if (acm->devHandle[i]) { + UsbCloseInterface(acm->devHandle[i]); + acm->devHandle[i] = NULL; + } + } + if (acm->ctrDevHandle) { + UsbCloseInterface(acm->ctrDevHandle); + acm->ctrDevHandle = NULL; + } +} + +static int32_t AcmOpenInterfaces(struct AcmDevice *acm) +{ + for (int i = 0; i < acm->interfaceCnt; i++) { + if (acm->iface[i]) { + acm->devHandle[i] = UsbOpenInterface(acm->iface[i]); // Open the UsbInterface object obtained. + if (acm->devHandle[i] == NULL) { + HDF_LOGE("%{public}s: UsbOpenInterface null", __func__); + goto error; + } + } + } + acm->ctrDevHandle = UsbOpenInterface(acm->ctrIface); + if (acm->ctrDevHandle == NULL) { + HDF_LOGE("%{public}s: ctrDevHandle UsbOpenInterface null", __func__); + goto error; + } + + return HDF_SUCCESS; + +error: + AcmCloseInterfaces(acm); + return HDF_FAILURE; +} + +static int32_t AcmGetPipes(struct AcmDevice *acm) +{ + acm->dataInPipe = GetPipe(acm, USB_PIPE_TYPE_BULK, USB_PIPE_DIRECTION_IN); // Obtain pipe information of dataInPipe. + if (acm->dataInPipe == NULL) { + HDF_LOGE("dataInPipe is NULL"); + goto error; + } + + acm->dataOutPipe = GetPipe(acm, USB_PIPE_TYPE_BULK, USB_PIPE_DIRECTION_OUT); // Obtain pipe information of dataOutPipe. + if (acm->dataOutPipe == NULL) { + HDF_LOGE("dataOutPipe is NULL"); + goto error; + } + + acm->ctrPipe = EnumePipe(acm, acm->ctrIface->info.interfaceIndex, USB_PIPE_TYPE_CONTROL, USB_PIPE_DIRECTION_OUT); // Obtain pipe information of the control pipe. + if (acm->ctrPipe == NULL) { + HDF_LOGE("ctrPipe is NULL"); + goto error; + } + + acm->intPipe = GetPipe(acm, USB_PIPE_TYPE_INTERRUPT, USB_PIPE_DIRECTION_IN); // Obtain pipe information of the interrupt pipe. + if (acm->intPipe == NULL) { + HDF_LOGE("intPipe is NULL"); + goto error; + } + + acm->readSize = acm->dataInPipe->maxPacketSize; + acm->writeSize = acm->dataOutPipe->maxPacketSize; + acm->ctrlSize = acm->ctrPipe->maxPacketSize; + acm->intSize = acm->intPipe->maxPacketSize; + + return HDF_SUCCESS; + +error: + AcmFreePipes(acm); + return HDF_FAILURE; +} + +static void AcmFreeRequests(struct AcmDevice *acm) +{ + if (g_syncRequest != NULL) { + UsbFreeRequest(g_syncRequest); + g_syncRequest = NULL; + } + AcmFreeReadRequests(acm); + AcmFreeNotifyReqeust(acm); + AcmFreeWriteRequests(acm); + AcmWriteBufFree(acm); +} + +static int32_t AcmAllocRequests(struct AcmDevice *acm) +{ + int32_t ret; + + if (AcmWriteBufAlloc(acm) < 0) { + HDF_LOGE("%{public}s: AcmWriteBufAlloc failed", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + for (int i = 0; i < ACM_NW; i++) { + struct AcmWb *snd = &(acm->wb[i]); + snd->request = UsbAllocRequest(InterfaceIdToHandle(acm, acm->dataOutPipe->interfaceId), 0, acm->writeSize); // Allocate the I/O request object to be sent. + snd->instance = acm; + if (snd->request == NULL) { + HDF_LOGE("%{public}s:%{public}d snd request fail", __func__, __LINE__); + goto error_alloc_write_req; + } + } + + ret = AcmAllocNotifyRequest(acm); // Allocate and fill in the interrupt I/O request object. + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s:%{public}d AcmAllocNotifyRequest fail", __func__, __LINE__); + goto error_alloc_int_req; + } + + ret = AcmAllocReadRequests(acm); // Allocate and fill in the readReq I/O request object. + if (ret) { + HDF_LOGE("%{public}s:%{public}d AcmAllocReadRequests fail", __func__, __LINE__); + goto error_alloc_read_req; + } + + return HDF_SUCCESS; + +error_alloc_read_req: + AcmFreeNotifyReqeust(acm); +error_alloc_int_req: + AcmFreeWriteRequests(acm); +error_alloc_write_req: + AcmWriteBufFree(acm); + return HDF_FAILURE; +} + +static int32_t AcmInit(struct AcmDevice *acm) +{ + int32_t ret; + struct UsbSession *session = NULL; + + if (acm->initFlag == true) { + HDF_LOGE("%{public}s:%{public}d: initFlag is true", __func__, __LINE__); + return HDF_SUCCESS; + } + + ret = UsbInitHostSdk(NULL); // Initialize the host DDK. + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: UsbInitHostSdk failed", __func__); + return HDF_ERR_IO; + } + acm->session = session; + + ret = AcmClaimInterfaces(acm); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: AcmClaimInterfaces failed", __func__); + goto error_claim_interfaces; + } + + ret = AcmOpenInterfaces(acm); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: AcmOpenInterfaces failed", __func__); + goto error_open_interfaces; + } + + ret = AcmGetPipes(acm); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: AcmGetPipes failed", __func__); + goto error_get_pipes; + } + + ret = AcmAllocRequests(acm); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: AcmAllocRequests failed", __func__); + goto error_alloc_reqs; + } + + acm->lineCoding.dwDTERate = CpuToLe32(DATARATE); + acm->lineCoding.bCharFormat = CHARFORMAT; + acm->lineCoding.bParityType = USB_CDC_NO_PARITY; + acm->lineCoding.bDataBits = USB_CDC_1_STOP_BITS; + acm->initFlag = true; + + HDF_LOGD("%{public}s:%{public}d========OK", __func__, __LINE__); + return HDF_SUCCESS; + +error_alloc_reqs: + AcmFreePipes(acm); +error_get_pipes: + AcmCloseInterfaces(acm); +error_open_interfaces: + AcmReleaseInterfaces(acm); +error_claim_interfaces: + UsbExitHostSdk(acm->session); + acm->session = NULL; + return ret; +} + +static void AcmRelease(struct AcmDevice *acm) +{ + if (acm->initFlag == false) { + HDF_LOGE("%{public}s:%{public}d: initFlag is false", __func__, __LINE__); + return; + } + + AcmFreeRequests(acm); + AcmFreePipes(acm); + AcmCloseInterfaces(acm); + AcmReleaseInterfaces(acm); + UsbExitHostSdk(acm->session); + acm->session = NULL; + + acm->initFlag = false; +} + +static int32_t UsbSerialDriverInit(struct HdfDeviceObject *device) +{ + int32_t ret; + struct AcmDevice *acm = NULL; + + if (device == NULL) { + HDF_LOGE("%{public}s: device is null", __func__); + return HDF_ERR_INVALID_OBJECT; + } + acm = (struct AcmDevice *)device->service; + OsalMutexInit(&acm->readLock); + OsalMutexInit(&acm->writeLock); + HDF_LOGD("%{public}s:%{public}d busNum=%{public}d,devAddr=%{public}d", \ + __func__, __LINE__, acm->busNum, acm->devAddr); + + ret = UsbSerialDeviceAlloc(acm); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: Serial Device alloc failed", __func__); + } + + acm->initFlag = false; + g_acmReleaseFlag = false; + + HDF_LOGD("%{public}s:%{public}d init ok!", __func__, __LINE__); + + return ret; +} + +static void UsbSerialDriverRelease(struct HdfDeviceObject *device) +{ + struct AcmDevice *acm = NULL; + + if (device == NULL) { + HDF_LOGE("%{public}s: device is NULL", __func__); + return; + } + acm = (struct AcmDevice *)device->service; + if (acm == NULL) { + HDF_LOGE("%{public}s: acm is null", __func__); + return; + } + + g_acmReleaseFlag = true; + + if (acm->initFlag == true) { + HDF_LOGE("%{public}s:%{public}d AcmRelease", __func__, __LINE__); + AcmRelease(acm); + } + UsbSeriaDevicelFree(acm); + OsalMutexDestroy(&acm->writeLock); + OsalMutexDestroy(&acm->readLock); + OsalMutexDestroy(&acm->lock); + OsalMemFree(acm); + acm = NULL; + HDF_LOGD("%{public}s:%{public}d exit", __func__, __LINE__); +} + +struct HdfDriverEntry g_usbSerialDriverEntry = { + .moduleVersion = 1, + .moduleName = "usbhost_acm", // Driver module name, which must be the same as that configured in the .hcs file. + .Bind = UsbSerialDriverBind, + .Init = UsbSerialDriverInit, + .Release = UsbSerialDriverRelease, +}; +HDF_INIT(g_usbSerialDriverEntry); +``` + +### Developing Driver Using Host Raw APIs + +``` +root { + module = "usb_pnp_device"; + usb_pnp_config { + match_attr = "usb_pnp_match"; + usb_pnp_device_id = "UsbPnpDeviceId"; + UsbPnpDeviceId { + idTableList = [ + "host_acm_rawapi_table" + ]; + host_acm_rawapi_table { // Driver mapping table information. + // Driver module name, which must be the same as the value of moduleName in the driver entry structure. + moduleName = "usbhost_acm_rawapi"; + // Service name of the driver, which must be unique. + serviceName = "usbhost_acm_rawapi_service"; + // Keyword for matching private driver data. + deviceMatchAttr = "usbhost_acm_rawapi_matchAttr"; + // Data length starting from this field, in bytes. + length = 21; + // USB driver matching rule: vendorId+productId+interfaceSubClass+interfaceProtocol+interfaceNumber. + matchFlag = 0x0303; + // Vendor ID. + vendorId = 0x12D1; + // Product ID. + productId = 0x5000; + // The least significant 16 bits of the device sequence number. + bcdDeviceLow = 0x0000; + // The most significant 16 bits of the device sequence number. + bcdDeviceHigh = 0x0000; + // Device class code allocated by the USB. + deviceClass = 0; + // Child class code allocated by the USB. + deviceSubClass = 0; + // Device protocol code allocated by the USB. + deviceProtocol = 0; + // Interface type. You can enter multiple types as needed. + interfaceClass = [0]; + // Interface subtype. You can enter multiple subtypes as needed. + interfaceSubClass = [2, 0]; + // Protocol that the interface complies with. You can enter multiple protocols as needed. + interfaceProtocol = [1, 2]; + // Interface numer. You can enter multiple interface numbers as needed. + interfaceNumber = [2, 3]; + } + } + } +} + +#include "usb_serial_rawapi.h" +#include +#include "osal_mem.h" +#include "osal_time.h" +#include "securec.h" +#include "hdf_base.h" +#include "hdf_log.h" +#include "hdf_usb_pnp_manage.h" + +#define HDF_LOG_TAG USB_HOST_ACM_RAW_API +#define USB_CTRL_REQ_SIZE 64 +#define USB_IO_THREAD_STACK_SIZE 8192 +#define USB_RAW_IO_SLEEP_MS_TIME 100 +#define USB_RAW_IO_STOP_WAIT_MAX_TIME 3 + +static struct UsbRawRequest *g_syncRequest = NULL; +static UsbRawIoProcessStatusType g_stopIoStatus = USB_RAW_IO_PROCESS_RUNNING; +struct OsalMutex g_stopIoLock; +static bool g_rawAcmReleaseFlag = false; +...... + +static int UsbGetConfigDescriptor(UsbRawHandle *devHandle, struct UsbRawConfigDescriptor **config) +{ + UsbRawDevice *dev = NULL; + int activeConfig; + int ret; + + if (devHandle == NULL) { + HDF_LOGE("%{public}s:%{public}d devHandle is NULL", + __func__, __LINE__); + return HDF_ERR_INVALID_PARAM; + } + + ret = UsbRawGetConfiguration(devHandle, &activeConfig); + if (ret) { + HDF_LOGE("%{public}s:%{public}d UsbRawGetConfiguration failed, ret=%{public}d", + __func__, __LINE__, ret); + return HDF_FAILURE; + } + HDF_LOGE("%{public}s:%{public}d activeConfig=%{public}d", __func__, __LINE__, activeConfig); + dev = UsbRawGetDevice(devHandle); + if (dev == NULL) { + HDF_LOGE("%{public}s:%{public}d UsbRawGetDevice failed", + __func__, __LINE__); + return HDF_FAILURE; + } + + ret = UsbRawGetConfigDescriptor(dev, activeConfig, config); + if (ret) { + HDF_LOGE("UsbRawGetConfigDescriptor failed, ret=%{public}d\n", ret); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} +... +static int UsbAllocWriteRequests(struct AcmDevice *acm) +{ + int i; + + for (i = 0; i < ACM_NW; i++) { + struct AcmWb *snd = &acm->wb[i]; + snd->request = UsbRawAllocRequest(acm->devHandle, 0, acm->dataOutEp->maxPacketSize); + snd->instance = acm; + if (snd->request == NULL) { + HDF_LOGE("%{public}s: UsbRawAllocRequest failed", __func__); + return HDF_ERR_MALLOC_FAIL; + } + } + + return HDF_SUCCESS; +} +... +/* HdfDriverEntry implementations */ +static int32_t UsbSerialDriverBind(struct HdfDeviceObject *device) +{ + struct AcmDevice *acm = NULL; + struct UsbPnpNotifyServiceInfo *info = NULL; + errno_t err; + + if (device == NULL) { + HDF_LOGE("%s: device is null", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + acm = (struct AcmDevice *)OsalMemCalloc(sizeof(*acm)); + if (acm == NULL) { + HDF_LOGE("%s: Alloc usb serial device failed", __func__); + return HDF_FAILURE; + } + if (OsalMutexInit(&acm->lock) != HDF_SUCCESS) { + HDF_LOGE("%s:%d OsalMutexInit fail", __func__, __LINE__); + goto error; + } + + info = (struct UsbPnpNotifyServiceInfo *)device->priv; + if (info != NULL) { + acm->busNum = info->busNum; + acm->devAddr = info->devNum; + acm->interfaceCnt = info->interfaceLength; + err = memcpy_s((void *)(acm->interfaceIndex), USB_MAX_INTERFACES, + (const void*)info->interfaceNumber, info->interfaceLength); + if (err != EOK) { + HDF_LOGE("%s:%d memcpy_s failed err=%d", \ + __func__, __LINE__, err); + goto lock_error; + } + } else { + HDF_LOGE("%s:%d info is NULL!", __func__, __LINE__); + goto lock_error; + } + + device->service = &(acm->service); + device->service->Dispatch = UsbSerialDeviceDispatch; + acm->device = device; + HDF_LOGD("UsbSerialDriverBind=========================OK"); + return HDF_SUCCESS; + +lock_error: + if (OsalMutexDestroy(&acm->lock)) { + HDF_LOGE("%s:%d OsalMutexDestroy fail", __func__, __LINE__); + } +error: + OsalMemFree(acm); + acm = NULL; + return HDF_FAILURE; +} +... +static int UsbAllocReadRequests(struct AcmDevice *acm) +{ + struct UsbRawFillRequestData reqData; + int size = acm->dataInEp->maxPacketSize; + int ret; + + for (int i = 0; i < ACM_NR; i++) { + acm->readReq[i] = UsbRawAllocRequest(acm->devHandle, 0, size); + if (!acm->readReq[i]) { + HDF_LOGE("readReq request failed\n"); + return HDF_ERR_MALLOC_FAIL; + } + + reqData.endPoint = acm->dataInEp->addr; + reqData.numIsoPackets = 0; + reqData.callback = AcmReadBulkCallback; + reqData.userData = (void *)acm; + reqData.timeout = USB_CTRL_SET_TIMEOUT; + reqData.length = size; + + ret = UsbRawFillBulkRequest(acm->readReq[i], acm->devHandle, &reqData); + if (ret) { + HDF_LOGE("%{public}s: FillBulkRequest faile, ret=%{public}d \n", + __func__, ret); + return HDF_FAILURE; + } + } + + return HDF_SUCCESS; +} +... +static int UsbAllocNotifyRequest(struct AcmDevice *acm) +{ + struct UsbRawFillRequestData fillRequestData; + int size = acm->notifyEp->maxPacketSize; + int ret; + + acm->notifyReq = UsbRawAllocRequest(acm->devHandle, 0, size); + if (!acm->notifyReq) { + HDF_LOGE("notifyReq request fail\n"); + return HDF_ERR_MALLOC_FAIL; + } + + fillRequestData.endPoint = acm->notifyEp->addr; + fillRequestData.length = size; + fillRequestData.numIsoPackets = 0; + fillRequestData.callback = AcmNotifyReqCallback; + fillRequestData.userData = (void *)acm; + fillRequestData.timeout = USB_CTRL_SET_TIMEOUT; + + ret = UsbRawFillInterruptRequest(acm->notifyReq, acm->devHandle, &fillRequestData); + if (ret) { + HDF_LOGE("%{public}s: FillInterruptRequest faile, ret=%{public}d", __func__, ret); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} +... +static int32_t UsbSerialInit(struct AcmDevice *acm) +{ + struct UsbSession *session = NULL; + UsbRawHandle *devHandle = NULL; + int32_t ret; + + if (acm->initFlag == true) { + HDF_LOGE("%{public}s:%{public}d: initFlag is true", __func__, __LINE__); + return HDF_SUCCESS; + } + + ret = UsbRawInit(NULL); + if (ret) { + HDF_LOGE("%{public}s:%{public}d UsbRawInit failed", __func__, __LINE__); + return HDF_ERR_IO; + } + acm->session = session; + + devHandle = UsbRawOpenDevice(session, acm->busNum, acm->devAddr); + if (devHandle == NULL) { + HDF_LOGE("%{public}s:%{public}d UsbRawOpenDevice failed", __func__, __LINE__); + ret = HDF_FAILURE; + goto err_open_device; + } + acm->devHandle = devHandle; + ret = UsbGetConfigDescriptor(devHandle, &acm->config); + if (ret) { + HDF_LOGE("%{public}s:%{public}d UsbGetConfigDescriptor failed", __func__, __LINE__); + ret = HDF_FAILURE; + goto err_get_desc; + } + ret = UsbParseConfigDescriptor(acm, acm->config); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s:%{public}d UsbParseConfigDescriptor failed", __func__, __LINE__); + ret = HDF_FAILURE; + goto err_parse_desc; + } + + ret = AcmWriteBufAlloc(acm); + if (ret < 0) { + HDF_LOGE("%{public}s:%{public}d AcmWriteBufAlloc failed", __func__, __LINE__); + ret = HDF_FAILURE; + goto err_alloc_write_buf; + } + ret = UsbAllocWriteRequests(acm); + if (ret < 0) { + HDF_LOGE("%{public}s:%{public}d UsbAllocWriteRequests failed", __func__, __LINE__); + ret = HDF_FAILURE; + goto err_alloc_write_reqs; + } + ret = UsbAllocNotifyRequest(acm); + if (ret) { + HDF_LOGE("%{public}s:%{public}d UsbAllocNotifyRequests failed", __func__, __LINE__); + goto err_alloc_notify_req; + } + ret = UsbAllocReadRequests(acm); + if (ret) { + HDF_LOGE("%{public}s:%{public}d UsbAllocReadRequests failed", __func__, __LINE__); + goto err_alloc_read_reqs; + } + ret = UsbStartIo(acm); + if (ret) { + HDF_LOGE("%{public}s:%{public}d UsbAllocReadRequests failed", __func__, __LINE__); + goto err_start_io; + } + + acm->lineCoding.dwDTERate = CpuToLe32(DATARATE); + acm->lineCoding.bCharFormat = CHARFORMAT; + acm->lineCoding.bParityType = USB_CDC_NO_PARITY; + acm->lineCoding.bDataBits = USB_CDC_1_STOP_BITS; + + ret = UsbRawSubmitRequest(acm->notifyReq); + if (ret) { + HDF_LOGE("%{public}s:%{public}d UsbRawSubmitRequest failed", __func__, __LINE__); + goto err_submit_req; + } + + acm->initFlag = true; + + HDF_LOGD("%{public}s:%{public}d=========================OK", __func__, __LINE__); + + return HDF_SUCCESS; + +err_submit_req: + UsbStopIo(acm); +err_start_io: + UsbFreeReadRequests(acm); +err_alloc_read_reqs: + UsbFreeNotifyReqeust(acm); + err_alloc_notify_req: + UsbFreeWriteRequests(acm); +err_alloc_write_reqs: + AcmWriteBufFree(acm); +err_alloc_write_buf: + UsbReleaseInterfaces(acm); +err_parse_desc: + UsbRawFreeConfigDescriptor(acm->config); + acm->config = NULL; +err_get_desc: + (void)UsbRawCloseDevice(devHandle); +err_open_device: + UsbRawExit(acm->session); + + return ret; +} + +static void UsbSerialRelease(struct AcmDevice *acm) +{ + if (acm->initFlag == false) { + HDF_LOGE("%{public}s:%{public}d: initFlag is false", __func__, __LINE__); + return; + } + + /* stop io thread and release all resources */ + UsbStopIo(acm); + if (g_syncRequest != NULL) { + UsbRawFreeRequest(g_syncRequest); + g_syncRequest = NULL; + } + UsbFreeReadRequests(acm); + UsbFreeNotifyReqeust(acm); + UsbFreeWriteRequests(acm); + AcmWriteBufFree(acm); + (void)UsbRawCloseDevice(acm->devHandle); + UsbReleaseInterfaces(acm); + UsbRawFreeConfigDescriptor(acm->config); + acm->config = NULL; + UsbRawExit(acm->session); + + acm->initFlag = false; +} + +static int32_t UsbSerialDriverInit(struct HdfDeviceObject *device) +{ + struct AcmDevice *acm = NULL; + int32_t ret; + + if (device == NULL) { + HDF_LOGE("%{public}s:%{public}d device is null", __func__, __LINE__); + return HDF_ERR_INVALID_OBJECT; + } + acm = (struct AcmDevice *)device->service; + OsalMutexInit(&acm->readLock); + OsalMutexInit(&acm->writeLock); + + ret = UsbSerialDeviceAlloc(acm); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s:%{public}d UsbSerialDeviceAlloc failed", __func__, __LINE__); + } + + acm->initFlag = false; + g_rawAcmReleaseFlag = false; + + HDF_LOGD("%{public}s:%{public}d init ok!", __func__, __LINE__); + + return ret; +} + +static void UsbSerialDriverRelease(struct HdfDeviceObject *device) +{ + struct AcmDevice *acm = NULL; + if (device == NULL) { + HDF_LOGE("%{public}s: device is NULL", __func__); + return; + } + + acm = (struct AcmDevice *)device->service; + if (acm == NULL) { + HDF_LOGE("%{public}s: acm is null", __func__); + return; + } + + g_rawAcmReleaseFlag = true; + + if (acm->initFlag == true) { + HDF_LOGE("%{public}s:%{public}d UsbSerialRelease", __func__, __LINE__); + UsbSerialRelease(acm); + } + UsbSeriaDevicelFree(acm); + OsalMutexDestroy(&acm->writeLock); + OsalMutexDestroy(&acm->readLock); + OsalMutexDestroy(&acm->lock); + OsalMemFree(acm); + acm = NULL; + HDF_LOGD("%{public}s:%{public}d exit", __func__, __LINE__); +} + +struct HdfDriverEntry g_usbSerialRawDriverEntry = { + .moduleVersion = 1, + .moduleName = "usbhost_acm_rawapi", // Driver module name, which must be the same as that configured in the .hcs file. + .Bind = UsbSerialDriverBind, + .Init = UsbSerialDriverInit, + .Release = UsbSerialDriverRelease, +}; +HDF_INIT(g_usbSerialRawDriverEntry); +``` + +### Developing Driver Using Device DDK APIs +The core code of the USB Abstract Control Model (ACM) device is available in **drivers\peripheral\usb\gadget\function\acm\cdcacm.c**. The following is an example. + +``` +1. Create a device. +static int32_t AcmCreateFuncDevice(struct UsbAcmDevice *acm, + struct DeviceResourceIface *iface) +{ + struct UsbFnDevice *fnDev = NULL; +struct UsbFnDescriptorData descData; +uint8_t useHcs; + ... +if (useHcs == 0) { + descData.type = USBFN_DESC_DATA_TYPE_DESC; + descData.descriptor = &g_masterFuncDevice; +} else { + descData.type = USBFN_DESC_DATA_TYPE_PROP; + descData.property = device->property; +} +/* Create a device. */ + fnDev = (struct UsbFnDevice *)UsbFnDeviceCreate(acm->udcName, &descData); + if (fnDev == NULL) { + HDF_LOGE("%{public}s: create usb function device failed", __func__); + return HDF_FAILURE; + } + ... +} +2. Obtain an interface and open the interface for pipe information. +static int32_t AcmParseEachPipe(struct UsbAcmDevice *acm, struct UsbAcmInterface *iface) +{ + ... + for (i = 0; i < fnIface->info.numPipes; i++) { + struct UsbFnPipeInfo pipeInfo; +/* Obtain pipe information. */ + ret = UsbFnInterfaceGetPipeInfo(fnIface, i, &pipeInfo); + ... + } + return HDF_SUCCESS; +} +/* Obtain the interface and open the interface to obtain the handle. */ +static int32_t AcmParseEachIface(struct UsbAcmDevice *acm, struct UsbFnDevice *fnDev) +{ + ... + for (i = 0; i < fnDev->numInterfaces; i++) { + /* Obtain an interface.*/ + fnIface = (struct UsbFnInterface *)UsbFnDeviceGetInterface(fnDev, i); + ... + /* Open the interface. */ + handle = UsbFnInterfaceOpen(fnIface); + ... + } + return HDF_SUCCESS; +} +3. Receive events. +static int32_t AcmAllocCtrlRequests(struct UsbAcmDevice *acm, int num) +{ + ... + req = UsbFnCtrlRequestAlloc(acm->ctrlIface.handle, + sizeof(struct UsbCdcLineCoding) + sizeof(struct UsbCdcLineCoding)); + ... +} +static int32_t AcmDriverInit(struct HdfDeviceObject *device) +{ +... +/* Start to receive events.*/ + ret = UsbFnInterfaceStartRecvEvent(acm->ctrlIface.fn, 0xff, UsbAcmEventCallback, acm); + ... +} +4. Perform USB communication (read and write). +static int32_t AcmSendNotifyRequest(struct UsbAcmDevice *acm, uint8_t type, + uint16_t value, void *data, uint32_t length) +{ +... +/* Send a request asynchronously. */ + ret = UsbFnRequestSubmitAsync(req); + ... +} +5. Close the interface, stop receiving events, and remove the device. +static int32_t AcmReleaseFuncDevice(struct UsbAcmDevice *acm) +{ +int32_t ret; +/* Close the interface. */ + (void)UsbFnInterfaceClose(acm->ctrlIface.handle); +(void)UsbFnInterfaceClose(acm->dataIface.handle); +/* Stop receiving events. */ +(void)UsbFnInterfaceStopRecvEvent(acm->ctrlIface.fn); +/* Remove the device. */ + ret = UsbFnDeviceRemove(acm->fnDev); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: remove usb function device failed", __func__); + } + return ret; +} +``` diff --git a/en/device-dev/driver/figures/USB_device_driver_model.png b/en/device-dev/driver/figures/USB_device_driver_model.png new file mode 100644 index 0000000000000000000000000000000000000000..3766cf8117505a0d47720dcbccc1030536921bdb GIT binary patch literal 33914 zcmeFZ2UJtr*Do67D0V!@g9r#56-B8>st6=1D$KJp|{W# z=_T|42}Gns2qCl(l91%?;Q4>!d*i!zy!XEGzI)%hJtj@rqt*LO4-Ll_1az{Hoaqe#w9qy(LzHRzFE&hw* z!KSlz*Z&%QmgwMk*Re1AkK3=M(8bo`e_af3kC%)H7r(j?6>_`p^`WERPYXWs*GbIz zYI9HPYWu5WMxu(mGCglx;-6&X`!)%xXhNqVYh(tS<@^V6b2ys%$_W|`#C0-^fL5dS zr)I4&2fecrfWCr2w+_w3i`s%WxXDR;`xn|6%M+XXXCR~JAVJPqxK;yFwLFiC=~LhT z!NdBz2&4BaRlNKF=ldto1B(0ClSJD%ashpa|7CLjf>HdxUhvyvF3y#Qng`wXe-YOV zKgl_{b@}N3UN4z35e7Yew^uN}_$x5H538oqi5idpI_4JcdOLtK;+YNMwBpnMl7_|K zAS+i_Tgf<%EC|Aqac%PdD}>q>^KEwxw>cN*Px0+C@72PYDZjm^gQ_)`uoIzbGSF*fW9FB$ z#6WEfokM_5wLLX&6t~QR$o}ds5)|Mcn`CkT^dX3&LiKN~Ysi}@f>&1r1YxlnG!LC~A61um3% zcSJ$*_l)YD8Cr0i6)6A&D!Rqd=6>_}LXM0u-uY^~YSh5mnVL(C{Fk5ks$dqMa3`v@ zKNGElf&w(w0(P|x+X;@x<5Z^aQ2k~^s9&HnBPCzJU?v;^f9Aha`|2wZQ~Jzu`aIT4 ze?kn9Y1~b4%0#GTT*B|qeLVH1xqcL9CFC~F9{>eFjsW%(uB_s{_H+U^l~u>46XE2t zRs?kxmxa`fk5ZmE`*Q!K2<`Zw&5?AZFC>$q>9vP?GZaAFg3h}_tXJy{?`19L zPF3c>&%+>iTo+2l_e6K2+S7>8rzgJv|V?5X?$*jEdgd|qw3yt?KBP_bi z1r}E_5N=S)B$#RyN-T`(nGUL?4)l0$&ZcW@jwBn)AreaCxIy1S{s7P+Tu`$ZdAF)tDm4RX+?ft&|e?h!NSx{Q+gQZsB#=F6n0IpaYnxyLv)%sKcv1M$p6 z1cE=|ls*B2i^BAOSqPJFX8V|SH9wdr)j_IGR64K|=hxhfg(qd(;m^Qz6n*f>iEjyZ z`XSexD#e4c@L6gk-Z58G2jUi^%Ad60H|pc73IbuWI6C~kied>?=08|hEgmao1TpGW4xM!Gl#vJVHN}plcM);Y zJC>G~M$%|aVtwEI*7(iAS7wYJH)}>-hB7tK226c0QKsv)78luqcP005oe4YV{E7|& zDV^nDZd;AV+S5l0&3=mq?`#-PZ7rxxG1iI7fJyDBqQsqI`INq{n&~2ddAF^j2XcWV zLjb@5fii0jPST!H!omKYb4lH#hDn%R1;ZTOUNJuap0PY@_G{~6!c>}x;Jcod?+GOJ zczfeVnQH1$r$OO)S{z09X?p&opaO-``V_c^!fnjO5t17b=^77ar^(yG7|nQZv;%&_ zzEgM#)4nk?RqNa}1n3iHYjZ;ncv%m4p0BD7{-UqY23^Y&rdk&q;7>@u0l-NjXDZyE zo>3yJu&j23V236+2mx4B;VbS*9=B_OkI2og{=YU|=>forJSStFce2whvQ|LTYjsX& zO3@S7lRD3VqR5as@szRxIfC@kWV?!2U;Drck-%4wsqv^Ifv#(vEI8uC2ArD5UH8z9vTM#OUhWBz^ z{)E`g4P>*JjCG&)L6FDEPaF$MpDtR3Z#}Si#&Z`lo6wAwG1;BQu@k7(#wW^p=>XX7 zq{k%|{Y~yc5U>*}{>w#kv$Gmy<{MC#gk4=Ux>Q9=QQuDl>ZR)NK2f=~ke>y8z=2%?RD(=O;3kEfOIQS2X0Z53| z@m8;F)q_B{+RnRNIOu^qQo-RcXYc+eI=kNvsLg;f$P@M+7RD&+ZLgwpLnwx{sVt@k z{2VBpn#xh>`X|wQwq2X}RwilF!<1FWO|RVCv6bZE0LwInRp%d*v}R3D1_${`y7 zPy2tKW`!#^CUzFf*nfMjvHAHVRVR3c)^>?MV8>oyaXh8+xR~7f*W(zra&tr3jWYcV zNg31?0rXi&pGsD;tSS9|oJvq&D`~K~Hi`*}=i-xIY&(Obi1f4-r%X>Y0J36uIbrSi;@EfY zW2X_(U{8JUWRYSkFv8WLxCZQeLxVPdh@Wi*JGM*3x-L$|)s|Qb#>$mp=XP(ZnrPQ` z9R~Sma8P#W)v#&QdM$ZYH}7&LMUDROnWjLQ-w~Ns^XiK(Jke1P;ej1~^HX}v+VtjH z%LCq;^HX6dbG4`IcZQP&$UwKa;(mVuFVygt2q4w^Q-fn&8@>k|2IE6xr5(24Xm}B- zQm_;0@+ndU*Gs&I^Kug!Y|GiS**CQi8o9y^-Y79Oy7{ zrRSBlvZ;kUoyIp}#(W5fR1FVd2DY#_5!*;TuQ~g}(=UdP%Pf3G+ltent$S7#Ys;7| zW=d9Hce6xP?+=&TD|yi^f!9Lx>n6ga8%_AM1<~ zn@D5z-8+&s&a;RdEh8}Wm0rxkg)ly6x)OHguk8$9o%utq2PfiB$$zs&Uv&Ar*E43T zTe>4h3J6AeZ>}6SY-gc_fpPHuGYZgopUw8h($B2T7{1ImwCYWEL=p5sur7%ku;KdJXVkMuseC}Nelv_ahi#<9Uoh67#v!)7 z>s(a(`X<&($6K>!A7D)IU|QT!i7MhErmC2NKAtkNyR?|WSjrod$>{$f8B!oNz^>1) z_o#Hv2KpFU)qXRC>aLY01wOVFgqtpdYLT{5A{8&jmAWCQ+RE#zJ)#n$R96X0!Q^U| zvuDsmQf%2zqat0}Qc(mw_T$j*aC6@AF_K!blae>6VJAnT;FLVlx>+{$NIb!iqSn}1 z#n}9oh#0(#Z%Vv>^Ow~#XKD4|>0?RS;0D>6Y7v4eXR5Z5p%-F~i)}3)=ixQpsCr4z zykgl}ZSmP^Ts7__=zS6gG9Q~rRITM`N>>-<^!2H{Hv|PLq|15*qEA4jm-07OFQK-8 z&WDxQq)uzV(9`1*qwHbb<-X&zZyAB|GP9lo16Csb4t{D4*V^>~VTjoDmIC+ewqHC) zHapt-hqoFq9>uz3j=bNOl4n0^_zV*R{E(ET-{KLC9@lz$$G~Y;H4!^a0M?*wwT4Gg z^{8)_`sAMO9G*OwMeAy@`NBMXDQ}SAJ-vHSm^y2#Yim&bs|yjT=FNDk!r$@U+Hkhrz2#XV$S?^-|7clHGzhnc3(L%Je5t}o;UBF zch_P!UlS&dOHW6LqMlt1nR|sp%^`x+c<6=AD2HLmh${ z8>IBru+TaCQ`Mm+P=;AIARM_-E)G^(7K`*+%7}5bZr!;LDDV0iF*z$6G0jTZ5Pe9> zJN`fi>P+Lc98SLkwT_!W68W$awWh!a#9!7wlw}|wguy4iD~Ou7QiV;l&azA$M)Mum z;O>jEOiP-svA?+OZWVCB-#y?0%3r^Qy`6tgrF1$6?Xd7gjX!{5@H#8Nz857q_^2=q zejzT1T$V2*md-m=Rn6m4q(+CyZLeJ7=ZJy_C+9n-z%)MqlG+c^m!4A8`QbEF6J=X{ z*|OQI_v7@+#rjaw3~{nMvu%0~DHfTPciD2dB>X_qD@!w9#Ukti@#X zVr`a{qVL>^L3WqvW+p7;QY-yUoRcnECW(*W1m4cZ1rooHvE&g_(^1=MOnUSIDNx(M z+U}(3l@`pMUqB!;1J(jbj>atWbAF3kO5SWU#(8O1?1+Ssh_v~#kmhQ6+N&_S{^qw< z8glbbAgoU{cx_>Dy{xgLD<4y&9)= z%jhWHWi__4iZkFj2!A~7Hn^6aLmOa_T`dIx-nyS>l2op#ag7%h3uQ~7Hh0odi_HsJ z<4Yn>>-J{+TQlWg(RxSA!oG`zer%d<8W#?c#)nm_9s{-M{OrV-@Kg3ws#1ca*LR+lh7YHMECQH<&0kzW;m7t(K!cX~>uEy7O%O<|U{LZRZz>HYa;eXO_9_r@!lCKD$sm99^ z6Z*508)R0))RqO1e0m7yK=`-Ua+kllH>HZ2SFlVuz0i){C#e^b)K}RXKn5Z^YVHr)Ogk`Yk^nWGivUe%|85dqzP z`Il(2fJ2I?W+($=bxbJ-&s68#mBdAugq5fQ26n3>nEXYlSG`>HfA+ZcEyPGW=Uv4d zX{yQ7+(Z%<0_|Rk!OBfICt~zgu-FOWcFl!!?$>e?Pew%(usmaZ+E)}-_}xgbd5_M% zz5*9ytD2qRYbTY7p0a^`><@u91e_jdUgV?r$Dy^M;$)`<;T66YjXT1E$B* zRG!&4wLo4768MiPt?=U}PkeN3+?p=T-cG~-0eITJBJn;#f9quO>yM0v$(LmYikXHE z(QjsA?$bvTfQOsCPtSx^Lz%T@h6UdBt;wSNBC~HlqZaTnb00TVH0g2DHUVm*6}2JF zibm(R4bc7c;tsHMam(mR%D&+ZRrKB#KivzqPLjKQR(T05@1T46bt z6HeZiA42o^KX8FOnEOGP*0OnBsj7To*wwi4c=;80p8Bsl#uSl(IhJT4A!(|p9NSLJ z{z&KGj{bgQ?F|;g7wrT7h;Ten;5r2_a=upSEi9xM$VfAu%rVt0@0+XPBuUAF9D@4r zWKH(!YT0F%g>Rh><`tgmha)27Okh5EX?w+ix2jHPzgedc#@&F->9zA`0qblkTG=~) zjnz4IY&ysVL+iB;-2{YlZ@<4<=%L}JofrOIi(|v*g;(@pNaI5@-IMD(ZZ<6!USLGc z-0f8XDK*IrE84r=dVd169=acLjvEp6$wR~E!M-<5)1L3x4V=AX$Ay(Mv1t{I;kSqo z)qDnD9a}!XCKG7OrxfhA@GW+(*iBBKsS!mO+i(qKHXi`F-{lzmhl4BpRxOee$+nl@ zmr|Sv43YkQdky_4$L};WD$Lnl!YA=I8RxupR`xI`mMs(fD1bfsZ z3&k|aTKs}R{?X`q=7LYy8u3c2UOX#@{sfToeh_=>^7e_7y0xp5^=c6-1AZd9^D%*k z0p0$5KYn^`byfDIFic)nvHXHW8uZo`ix)nHPR^o$mbgyv0P4WcDGPu=0b$#O^}?K< zSQ5YMn779V#0#!P-}v0*uGka0nYLDX9dsb+PJt!W-Tebm(V5z{8{m#M-KRfMS6=Ea=)If_kb4Jg?e_nTnt;mcdC9y)P4C ztw+!x5caFR9~$JP*&uMLiqf7JoR>2hKhlo5J$|&e9s%js>695ot~rr4^Hd3##{t zLqC84X5}UUOah)B^`;_=Hl$yN!CM2#BH0{-iGf*x4TiP#ZuOT{-FgHn)bOW$ay7TlAtt7}#Oe(Tj-R3p;}k zgYUK0NTFKXQH#lYQMNW&NyVWRP0nvz?cD-yMBFFx!*pVI#^_aB-46p@YkEEti{7bo zaVeX@gp9&iq@k(3#<}}}uk{Eu*;Hcv+1ojY&s^2WM>LZg8E!nH*S6b zOMZO@yIF`nue}y_&6fFnVsk{%$;*CJ2)?mLR}I)Ct(qCyAVi%uJLMQ&3tua&zz}7? z_aUb?Ua6si2IxJXE4P3j-)z&V zhp2*bX&Z4^$Qn8T>hG7FVyv6016ivenZT8LrFmx1he z8-bTzP?*Zwq1-)Wv8}^H=LWyUGWlI4qMi8xjGvuERLofjtN7kjamu)K^Uqe0|v3Z6ifwaAf^OHW38XT$o_&q)gpMrLu#y(jbv7P(ZS^%sZDwx$jUe|oP z|E!Hz54w!Cxc7pGZ56slg`~+2Qm9IJ8VofOASXiWMkn)0SyM<;xRNWY%XsS|0XGu| z9*mp~9x*^H^*?8bmY|4UYen(*CS~{3xQnW(7ZlTQfE$n(;1`726LiLRV}_#@B8!SP zYQ-h$F932%(hD1Nm6!E<{KpH*{mux0Da@!SVZE7M4TkX8)>J)of)4eqe=BL^s=C5z$tW;c? zrJT%>NENy%Q$}^xMmI!~J8h0aqP8Yl$H4|jP^=BOqU=bgihGdVk1I`j@s{q*3L^BZ z&}`Ly#FG`t!pS)BsiZ$&|2gr%H zEt_#2W)cpJ)*$Bm^rM#;xf=PELXKx;t-95M)3&T!044uZ$#da~=YHR3Y=c#7cb^6Y zWQr2Ksq+crqbXTaDN56PSvO4f8qJ@m@dFb{$IY6+Lug<7go>(DYTesi>ytYH8ka1} z)KGbefzsm?i=PfEN_;F3DC2PgWLaW1yEk2b;YItXWqdRbtUGeCPu5IkI@t|TIk0n0 zqB2 zN=^9a>28dE)$%*Gb-1Z%$;<@Anb^yWYLi4Q?F;(WC@8yK~?aoUdzAQ7z)MgEl-IqqeJAHYqNAif~ub7>~`-Z ziEv~RAXXOhJM8YrBwkt6MSee`Qoyu&6;a*|_b6Ss_jp!-jGhzu{QzA@iN-G?>>R3E z4T;cKpkhzpx>iQxp0EV?iU`DJ4^&8!@+O4RNGGgBKjL&oThx@k17SMCOg^rBOSV+Vmph9na z2jXh7)GYS~`zZoN6ke+653?teMXPJysin-DumLs7T;W`gRUFcCDF&Wlx^-B4O4Y_z zk?=--`UO@RcWbLJ5!#Sx*Dup{@Mt;eXhu&~j9AY^@JF>oM3h2M?><(R@A`+GQsTmGR5^*65N(Kd1vRREE6!Nmt5I!r0XgM==hpzBp`!p? z&1G&R0Iu8{a|dCWH0Zq*^R4<%=%!smW{|1$w>=-qKk8%0z2nqGJ7?&A&bTvztf`T%b)~AGA^TJ8ib*i$ne6gS_69t*kEF@ayxa-U- z^?)DrcK8%xAKEn`wbhA37sI(4yw&?rw$R-$ca*Hs6j_nU#0?61=Yv21arx z$K)o?=JWF2VooWKGQQ^DgFx~qjkD~g(iD?(N4$sVOkG*B>!*p7*=g2!x3MiPyHCn6 zzBwJjhn&JFl--Cb$0APFzv(AX9Eko7bP=4R@1=ej%_Ww_1OOr#z??0zQZ~nBY>;u3 z)bmq58a5dQp4NRN*LcZ0ygM%yEWN2|NEBnk-ZVY~l6(oh+7~4@xDbPO>l0&b=HaYo z9gj9pCM>rE*>p_8-MA)l(aV6jKVc^u|h zQoPvW8?rp$(bd=~qkHf2u30m0z5-)?aQFJmml`kx6Ua`Wdk1_}QtAI__s4aNt8?XM zsqquDZ9l1{`L(}d-3KTf-L6+8@D@48mdPY2vpysH_nw9xSkmTkb3aJjic-_`lC)KM zWHa%Z7NWeK8lvp=v3|qOOOiX3l^nc6s9TJ=CQ)l%rJ!;}ysR-e6uxi$RNqFVeePnVWjRXV-w12fid4Fn`u~SN>@5T4q#a?d(9T#g`TJm5|e9Qv~ zrShMT%xCtewm(&rxbysk^@b7km>vV*_vY7L2dB-Nr54NEJ2AP~(+n~&uPjD~ z9IXt$8y4J*w+*9E<9Pd?r(0B5M5>B4uLF}lEw z*EjO*!my!04p3QsD9}#P*7zn`YT$7Rz^B~hnr^3i=%V$PDmeV0xzUd=&JbYgTu?PB zLCX2*$>0|O)?ufNh68|%>+_RmM0m(Tse8`UJEhqsujW2KcbDLGMU|DoGhuFxgPaGh zhlm_ku3dYtR5}2EC0^t}c=vr;qzs0RjKLPL5SRI3V{-MLn-mjs-g$@wpAGJ~q-H@Lm1cZY(nz*MVbG!V)rzl>4IJ+TT2mUz}K0>|vH zZSo9-fg6`~goA_i!Jce@&{~CZ0vg&X@DsQvt$E6my-=$Z?;iM+y{N&-%Q1Q!|hrr}uK^3_WgX-TBv|Sb(-pwvBZFUe$FG zTKW!={Z3V};Q}`&J8U(vp{z3sN$ff`=3PGA{rUMx?o>e2rm8m=gH4YA}WqNBTJs4OZICV4`LwLJC_}( z$fG3737Qs_KGgI;j(DE=1W0jH;o*p!&&>#|%$rwM>PW$)%RO%6uXIhD2VEPz>zk)N zFLX`tZgtiumpyz`lilPe&X22r*u?~%IyF|%G?-?jO@81~no*SpX%*di|1S~($FU7s z);pj8Hrb(qpTbUMOr~>EeYjAz_LKtY{yWPm;(~UM6980OU7O#XVi!9`1YS|#>&Jtx z{6!KRcDu0C2nlq0IupbGo+8%LI<-e2?{$2ovcF$~U}_iW4U5T^2E|MRcz`Bx8Ip#X zP~gOJ5rc~PxbdcfiL6YG*CUq1^T|MJSWh3nb3*u&zPo90ULEYJN(7y-@iDCB*%W-m zC)5RaXeB|-Hi+);L}<8wID#ldzo6$X_h`zBh_-8dUFkjJtjMEp&3Fdn9r(hIIJaVh ziK^Rq=0`{Ou7*iz0t6=)GLMW*H4hXvA*k~G^vB%+nA_7om*g{jV^t+x|)TK5iGEz{~O`?Dy6x(cqVM!#`Uo_>{lI6 z@7=NPM$LFUt0s~yHUG6Xctx%&o?+W-TJWlmG`P^6ud?}_2FQH@YgqJ23~>EQ2!L7h zLlXK3Vi7P~z=O1u7a+wO6M%62sqHD%(f8AYzyUfggpF7Y2qwlKD+{CYL}jr}xtCa5 z?2Wjv4E8$1wg%Hi_b2D}}ml zr5fh)oxy`-O)eZfTiT)~ad@R8YLB*Ky0GN=!b%3;xE}L{Y>G5jMm_#DweG|6;Z&tr z*pk%y=gRq&rCm)5BCSD7$T#E&7ENqA*`rDYyp!~XOh8zCX3TN?f2$;qUnN*YuO&rj zan8?mg0LpjV!izpQAI&9f!|*VR^RKk>Nk3GvOgd3c@Zm@Y#}Uotq5+>No*ewJmPEm zu6>}5af4z+YWXG0}hJQ18LU#ySt_KWjz!s3^6kl!h&;#trt0)x8CLART z17YHo57)EYrFcO7_awgBH0Fx|<=*ySDmKi<=Frt;Avh3`Z1eeN!$u8>=s82Mdyi2m z-{aDL!L}Ov*aM|XypwHzB}r5yEX??`TS9n0^|8x{f&EcG@Wu+m;S_bm`e zyh=uz{LMVh-p&%$WNkp`4_x-Ma_*}rh*N5F$O zfm$YTMBU~TKmPyhEg*vbstp>P`bRiwclH%5F#;q$&~!*rVMz+)?)V=n4Y{w5fV^v; z4fJlFzLl3+7oOMIbO>~a7btWA$A4-+iH{{51akD=*vs2I4ZK6Utw=$lPyM0Gf4Ax5 zo7v+c5uIe?LCV+tUH|>}iA=?@X zU{|RWu`|zs;$;6jPQ}dZE>I?$eqf*tvy}pvO@Ua?)xXCzUx*NhIWOQ0mBV^-fj;aPC?ye{&cFVFp?lj(X(DBsYeZuL zZBnmSL4j0`*AW~*Dqg#RhYEl7tzazy{G;!QZ%Ei-r9qGR?y7d6w9QToZ#?o@TS>bq zazA7#2mJUBxASYVpwp@4E}jz$k1d^Ns`R3GK;iED_1=4OV2hVSY9S%Zn(<>^wm_qo zxOsfmF3Eyb-@b?eGA(n4Nbul(^?BpkZOd7-y32VRog?=#hxyN;AZZIt{Uzn9y~-(&%kI6@WH-)V~{}Z%r1CLgOsYy9zL>P)0~= zXZw=b2jmB?>7!HES`UMMMD9<4DCN8W!cAmkWE5lj%NI&ugchME`BGfX!9`I`PJ+|B zK2=EnnI-!HgRc3EIfW{oe7xrt(My_MYw~;M?3Hd2c1pzM^|(+Rw5WoMAvYV0%dDy8 zE*&3Hku`WpkRt&w`>U7CYx>SLs9}ESz{8MJpz^z%I#77W@G%%8BH!d3=5=KiT(0Zl zH+MsKWrGo{sa`p!x{ZuP4R;4L1L^U(6Q|tXPn0#x*c%6=*V;AGW3C9&Myoo)c#`Sv zb$`u&jNEf$RjY^NfZPE52q;|o=aS#|aTUXk2d#i2hTO}~^Eo**_EaNdvUW`cO%?H- zDcJTb=$vh?uPe8TFz9FxQ1o?@`Su~nvP;mf|Chpx2DcOH{oY1R@bgDnh&FyAy^WrK zDt7PVk&&+_Pmj4|{C>UgYV)b)C*J~|`e1$6Nc)v}(T#!=%kIT(r z=Dh0q`uf9*lmO9Y+wg}g{)kXQ_qDvZ7CI|G?k@4gLTM@ey5>q`kviqLs2*f5=Jjzg zt@tZqNRumw?E4`F$c^wZRHwalE6La!t6v1w1rTRK`DY<9$~4qW{p1~@z#^YdZSY;8 z&*ol+`64YgjhR|&&PGDk)+;|EpTSJyehUm36kqLV)CJZnow>Z%4!pwbEXQ~O>mD#~ z@+@6>EEW*Dx_ew;n|$Wsb!bdVi1EZY7>lQ+hj*Ojduy$)Z$Tiwuj$2;&PyAn-H4OtD87<>n7`WR73i>gIKHOMI`4^Ht}tGQO7V8UFyf zV~Xw2XO%efB)mp!KlZGs=k6z=HcXb&kK=wGAz0`Zg0oI@;1UPjK;>8U9K1F3^+S%o z70@$-$}Bm@`JJcb>EW(uI;i<|QRu50;1YD`LZDD^cF9*L>+YW7N#TmYM;=sWIhgSZ z_M;;078W0PR}1Hto^QMR+Ak>f+T>@(QAS4mvpbtJA~cVh0>ACQ8?)G|CgEY}db^f6 zK&y`*?XR8$Nq#wglku16y`=K?WmJ9A;G&&E6!;1v$dnK_DRo~|^U-AlBTsMJi0bJB zbP8sxIsEB2jnI!-oR+@yy4)?{&8CCr``cy!XJLzkm7v$BImnhD1*PU zuL9pD4*ugEf%ELUKWP+jdgSsywR3<}UH$cEJsr6GKYH`U{ka8h0KNQeU#U2!euDs z9mtP!=~7Q%=}Nd(pq&e2TSIWIc}1$FDw$hQc8dw^4KN>)M}KO{*88!ANzWOS+Ap`g zoTYa7r8ajr>(_9hDV>+E1)9N{XllMRDsaEqi=SFy7O1~m7q+L%>`HGPs%kblf0NT9 z;XS$DVT|%kW*ZA(-G`~3i@)IqG+oifeJ#vZC1bsT`a6g6o0MhKE2g&PrTBeBY*i{t&cU0#H{MC5e^`-zi7P0lIfA3yFDKU=qCwX6j@ z8$|B>SWh=WucWmMF3yiXR;K$>?p{vnQn2yU`{q#;8#Fdb#G5G4hOBSeB3Ufyvg6an|a_8NbU^Wc1=&+dTjk0~38^18FZ z8DksRl$I1F0NT#|+{o>010Ol{mI;*(+%6fly}3TmXVQ2|(;(#(WbzWMF|Ox&vDAH2 zGA8{Os=ZkT8!b`VL{Dh=v#r zJ{uH_c~P)BadEpH@bARFD{Kx5ho5}5Ds5f0EX{U~S^4r@c$mCA#objipRK7IJCi5G z^1iDEm2L`bEftQzj-z#}c`AI>0<JL>8oE12AlJaH&vTm`y8mu?1-DPUNxuwZ`62et^N3BSN;6+>4L3mU4$>Dex;P=2Jy951IT;2syWJ1I{})J zq580)pECfB-~O&GgTBdCcjfyy5)^(2zB`cBSk~&gy6*PVA;oWhqP=F&yLV*ZwU2Wc zF4;d?_BXL{BmsD@f9Hb#(~k1rc@>uqE;l(rLrcqa%DY~M5_VHdnNi)5sKCUk5B5u> zM_yZ+ec>xoVWtK5M$P~_x_^|!>aq?<#-_$xOFnw6P&YNd&`46|lA*yh=&t`iw}1jl z0uJpoI698=owLEn%3W8G1ap`h=Xmh(V2~z|g*Kii=6dC2#Or0(q?#7V+%Rmdde8h=|zuxW-)~a|<}JP$FKd6Oys*jGI-?ie>-`|cK0nuL`mK&({_vlE$?+}@(M=_a zllhyeiJSbc2~R|mbgqo2>nWZph332TK3MXZRzgn)$t98cCO_9?>lBK*T0bDO@@1!* zMh0WXw||t@-nhPXP33RJq~*RM%$ZV|9iW^17dXrw@Fw3&kjLDrO1vm%(1+D~d2%4%8ml-r-%dWn8Lk{2(l(5x<*pK5v~!Js5n zQS^T2sj|y#)g<(^@yP3u%ZyN`%=PKn*4r>r@Wjz3hs;qF(!NySRyw~!W?Ntd`qX~o zK(zA&dT8>#k$b`^IT+>d*t|rfYxdmS$>x(eflZ><#Oppx%d5@RYgBvoy?y+81QqY- zq}}Tvt997O&61f*I1)lE1r~EqoqJEDeR2`cLR&D)xv+un#Z5(CMo)8R+YcUXR~sLT z3i11=x$+~N2{BlX&Tg{gmF(%4Na&Tg)bqeGQIBy}Uoz+mR4&KNva@QqxTNwLZS+}t z*0$onLs{t6R6WbAwERswa|by;N=@n`#jI0q&DZe?eQS4h7Y#$axpzw|3nF}thUr$# zvlp|3fac0aW+hY8ike6w2uv5mFUF6&G7$mZzQDc${8;jlm!};0>J%Z)viMoM$t7!p zYiY)cmW|!nqORHP!T0ay=Ni-$boTyP71<%XlX*EQol?zwE86~Wr2AUY`=@>&+mj#p z@~4Rw@hA9ua^rh!@{)`#AM&IhuA4Lcx{;YjXD zg-!TkQpw4{yy*$v1JU*ts9fVIx1}wCK0*@Ol%bWLTC(Y)aw}Fq)*dD&D-J(<)ylvx z=#1+r_~O=PHS?3WY2ODy*@4QXW3@St)Mcv>HsdXAs(&`tT7;Tqhb8ciN>EmTrou08 zvKUqIx!r8P1lBk=WECs0YRV??YmSJ4H$3rYIWnkCB0m?RNWXk6`UAMOv!#Mfy-qX*bev>#VsH%|uUz*Wj@j$CfL*v3aV`pXt7pfl2PwvhjSFqG5~yf%(2XPRJ;}{I{tMX z?;BBm*?9g%t*Qghi+r1{t`w&A@xKOsb|mtc-MEA_7^<;9G};qAzGgqDa3!I@SlnU3 zo)T{_Dkn}m`&ws7tM_s<`ocH<_i%XQt8>foj@rtXLlWcwl+XLnA!E8e^%F=z;Tq|p z&ATIg6Ix>NKZE6`{cbwf8)G8g9X%G$xvAgDdHdyT2-TX&uxv%@>PmmV;k!{1%CyB# zAeG4D1eJ@df#<#Yvq&Kb?js>I)g&$~2ZJgB)7xHFiy`r9BP4u7NgCo3!1=oOsvr8; zmKpq9b6#RB7r23ou68p0`^8+%pFmzDoc7b#-ja~kb>52~t8#LXD6*_Py9C6SL%;kC zcARh1#*ZeAm;NB^S$?sT>Ic~E2mW6sFFeWBPRq<3UtN`Ca`r)mpJt5b@w-^owX_VV z+|1b!tD5#?no@>|twnJ*VRdUal;&r$^=P;_Uk&oi4r}MSzTT(R8G@!OBUa2wHAk3G zIZ?r*Gj;;gKRiXCmvp-B#QQ9F?PQQAHngSIfShpo!JjPngUgw~xs2auMv^_G183`YF}7(N(Sy!=5$2>H%!(kykC+MHUc$2%(5_u& ziTY9~@Ave1L^T3y7lVIv#s~dlH>|ppm$~!eW)rd_1Q?PD=x2N{PsAOH(WdVarf0G@ z6L^;AwByH+gie-4D`U|Xz^A=;2<&L7m+mcSt$TL3^ zKOc^^Hpm;=ZmjNN`SpW%;u+u9aCD((8Hv(a}C7p(@)+2CF~bs{*Zg`z9*7@RU5%dL7`&L(YW!$zh4 zl-bMS6<4*K2$6D$9OiA`c4e)GpSq|?y1AKxHyU%-zNk6Rv-@S!WakhNQab)5>VL*< z;%(kp9wMD#PQ-2FgnN#qkS8?C*hSz#=1jvpPG|jTB(|l{5bvHMnuKlk=45`#9Ahq`6XaR9LLLOnKtMV3BgK;Cm zzqTaL2>(hs&*{*;59#!F= zN*|!65C6}Do$8V(;2#G8&RWZ&|6*+2Y}0=$?z`ifde*#SK~xk(1r-EDKm-J&BUM4F z2-16#-ldlif}+wC1VsddNbiJ>)S!SU9qBdn7D9wT0)!;*33~7S?S4LY_uYN(?tA`8 zIcMg~JoC)=sWW2;!$j;#0IpA~7iAFuS|485wtu4><;OpBB>u%d`m6UdZM==6mQ;$p9b$&u#C9iOWb?YfO1AW zzrCtPx};4685)FX#B-{V=V9d9CB=BTtuigAfgHL(x}<@2(hkDY65P9JHjjRgIEAK^ zHU4|qZ7D_I{nEnRP%gDPT(A3JF1ef0pO6z9tmo|FEf4D@kMB6_!{i(sahB7GoW#vW zfBg`&5^)xf&<4yrcP-p*3{YdU`tQ|L&B@+aSo_WkC_Xnn>w(9C27;JtiBcR1He;(> zn%{4xCM9@a_8`AnMvU4+euV`QE-i0|Bgx7z(sr)TFDSwkw!gqltUsjkZwH9cTT;sg ze1(R*p(REjAsn}M61S0LQWP}t{Q=MzJI#hXC@GwrqXpg9-B&I!gdMbUAJhZzWkvOy z@J1Eyd0YLy0?TCPp#!<{N|deg&i#pb3|Ep%34C=Vtr|he))E>x;c$KJ*Jp=t+MMh^ z@Y>Q>aow`&++*@49c4i?$XfZ(5p8AuL}4ADa;A*D8}4t{q)$>siF~Y$n9j4%5Jisl0s0OU$28G`K&5xxegW;o85|q|LN$q4q z7-^9E6h&GqxGx@C4_0?`a~oFS#UP!9Dxv_x8c<33vrm9ac;Zet5BbtHiZ%JFpv)Ce*)-L91(+lMsrfA~ z%H8@t%aVljaNZ~LssriFz;H8_Z!wH|ckt<7uwd?Z=cVpG=sMh0Ab7i>#LoV)bM_~S zI2yg#kTClDagz%fAZfT>*933tqa3}T$^y5<+qat3w~f1d#@U*zz?wsteveTk@r#pFb?co_C1-E%V$Y^ zJ6)kexL+yqc)-pEzR@KTIRHo7@fcTfJoMz7i-503cg#p*Nb?Hz#YoOpzIdBX8jx6^ zp$nM#Wr0CX3%WuQ4ZvbzZF5ti#-gi6**k9FrwCl51DRvviFJJWHy6NkpJ9Cb9W5n4 zlc%w_kcR&9_Hy%ue*WUN4AI%|@=w9Je!O#9N{DKES3G6KuW_aHgY7R;C%G%M^ct{O zpK=*B=+l*Ac{~F6d6LpN8s2xgT8gP^F6ku$8lbCMZC0Z!EV+iwM_9L95gD&Z5U@|q zInx^`f(y(Z7iW1O6dTAj(D8XdB%wF!V)UWq1NdylifYD@rx$;naiuWD2KA=|8%BZ%tpR7$&Y*cc$Llld^-B6xMt*kNY)enXw_ zodw;Y>Pu%iy(`lC2KnH6DY|z)>bZ;OuDPeVDJyenDV5h`zl2USOmr7L?)e(OQO)&1 zML2hCCS_YF;i0~1+Hs-yJE=WfVeokbEV;JV5bcf)>6XFv)bTkl=I?bLx{=EI=Eru(FyB-^PR!fCRL^_w+h!A#Lwt6yQ=C` z2GI@_Z7g4U-NO>oQ#Ex5qtlh?MDYRW=YRZha~1MP9I&Ep4bLPEO=;<CEN};J;33^hgn|iVigUcS(x76&k zJnR9}KV?X>W&c<8b)LejPd;;AA!Yfpzqev77I~+Uo4}_(0b39rDsV}<5?BwGT&hQU zbstAt47#~FN4LFGw>!FTE!~kOH>|CM^4>8i-0J#Gb5N08A*&U0QoNU%qVP}k`h+j> zNvnmXx1T5qRiwRgXZyzr+MBa=dA zE5KD0$aI_Ad%Ed+6%9x|K0~=`ZuI+TH0T6Gw0|T}$lx)n^5B3yhhXo1oLI+@@XB5L z7FPE6dAd?=_Oc9L&ftaHWq`gqHu z%KdZi*a{nUMVJAxYm@q^jV@XAZ}77>JVTQz*VF^9S~{}s#o_Q_9U1_Fli547{Nt5+#m-ZIVF&&^P-yuXcV1mkwK@ zPT8}g=mT`+APRaCFp^2OYYrrKE458lI#6L4KEU<(Z`JH%cm-r_dh3XfQ+2?Y4axdHcF9e>wt zkdz-;k;AE2Pnzs2A^aTYUHv+b-FXYVY*P-6+&WU@@3+5hR;;37E;o@&1b-wJ#}e`O zzF$VX30w0c`QT3KcXE7AQiYYvABgxRmnGlXX}UactnA2Ykrh=Cpjpn*H@h` zP|-^F(ng~uflUyM^EM)25EAfCQt3Et;;~CHMYdH?Ew^U37c-EDHIlUlyS{#^8)wrW znqOWU2;ttv0so+-R!<>xm4lKX<82=n@Y#irR6CP|Fd1Je_Fkh9> z71J4uEO|Q+|4t7#Nl5;@)pVnzA$#3IG12AO!bRbF{a`6yP?Gx zpPdihx#%ad@Je&LMpPtlzo&r7P{l;cGSKpZ7H9DV4Tl64;p~_!+K=E)Z*!NDdDt;UaV-UAYqs^P#P(`hJudWHPsM(P_XbX=m8+1B{JvR4; zhUZ4rwe*#6r`3GLe!{NHx=~F6?_<7t=mZEIntxscW-BTd-cWTxG=7*Lh$Zl568Tkv z{m@l~F!Pr<7*HB<25T8!lHK-vw){4BxeAHUy4zOi-%v2_KxnQFrJ_$c)ekArFkPNt+Vt3ra&`&# zu^xA)pF;=$Em=~cbEWjEu-Vv1D9^!Hf97!vOXF}x)PPO$Nyq-#YA#QWL|-N6(SKw` z>7jwFDB(fYI8MG$c%orYC-q=sHaz4oCrb5?jlk3+XUlK3A`meedck1i){ehP7TuXCe2XaRpszh-5;yDSn(`_^h$@ z&JU*wAbG18-J*LxAGKlMGmokLm z2$w#rtMWl$4o_92IT13cLnQt&XVZ5vl|RF5#^r6-yk-L9JNAJzDi>CaQ}^fnF85Tk zcnmwp3PQnR(DRO=$S|qEdH2-79Px(tS%o50skII@nyh?-?ndmo?S9~p%ZY>2=~{;J zrtdy^Lv!}8l=dv_R8+*1_gI~4ud{`Y6RzGl5OiH5Ef-9l%r}~iRJh5il-$V=PKQ0kua>4KbNIk6* zl|pdxInusL8rJ(;E`THqX-06HN-^;B7?(G5KtVj5=H$pXOW*%W8!qZ5^ay^zp97VW zfb4Z(^fNw*_ytS_Za2_g-FZ0@KbYPF;r5wvREYQ4Nn(E(C;|UK3(1+1uhx5y1#qH> zb9w+s?+v2_yU(3=zcvL?sPX9qR$2j{4F-KlkxoD#Qk(3n4Y^49Xo-=>aVj&duXpBzi^(8UWc=2{hS-1=$ zyi9c4Y1igjD@)Ylr3M4HpS$Qf-PGBJ|Pj4g)H@xkqq>bdD(tyCPjj&VvrF)dqf>@YapD&k+;zexwW6_nFE6 zQpa`>0&%X<+)tVAx#+W$wyJc{EL$9nUmr$^RM`Mrhtj|w;Fq6-lopG*RXwUb9}IX* zi`a@0F!3PF#~^#Brb|ZO_uy$#c|5&%?v$FY&FFn){6W{fhvwSmMsy(NBf$PNpt~nE zP$Pz%JlclZQB8U|x;C0o0 zcD=C(vNv(oT6vk4bZ!ybW$D;)`TOJI{&Z`hgfQgTe$yBlneW!#pVr5(33IFGZ4gVF z+2g^$SWUm|pWRsQUh8vc;MX6&Fz!UY3+_~C0Y+W{zJnjg2ezRvkn(AXyD&bs0l`#` z`vKaF5=5|c2HQKr+AUVRI&yTQ7V<~}gL-8Ci5A3soI>PgshQ(5XL&zQP*+tDgi@1k zIy%qY@0LqJG}LTpL8`J9Q@H9ew$b*y`&FD(+=Kla6FIc#2EOzWR6)fvA4l(cQ88VB zadWF`rPF%^F+)8$A)pf=tJf}j#KAq65~s$HUWc7JhX=(@#2{rIuy0l^hKkXXbjS2% zz#U}opkQciATn?Y0rxut5!aMB7kj_(vAtsh1C7H1`t#7^vnZ z-(WHbRCz1ibW(1z)4H~o4)p6c_9`qV7F)d4g?A$@=GR;R2$RVfNtJtprZ3cSvL7!n zJN*kqwNqgMB51{2(raYNQ%ogjt~Bcof7POn2~kP)Lv|PTo*BZA9S00&$3uDv)W2wt zH{HM%=3^W{Rvd@oaJH{;q`*E|GEd}!_w#NM#h@R?gR263+a;t&#(jg&>m7!=-Uw)_ zo(0-)nAIh0Xti%d{(Ge6OR`lp>ki+S^fLNAWf^*=fi*ks;^ccYj zd~ob?8u0&a=}x1@%(J(k(w=@wD)w^~{3(_<+ds>mm1xT3h+K%>!@uEl+mK67L6=Sp zQ9xO|SmeS$vQ)LHyre@{ zI>e=#BGUUxU_!Z`^vm|)D=KiF);a=WJdB3DH)@$4(xmes4PF6-25yF&2E92nc8wS* z1ip(uMai^aetk#~0Xu(75rTSKzSxEtcP5M~X!at#k@59BOl&4o%)N9hC`>9%;14Pv8|FPwU+{+}7CE3}xoz?+&?0oR7R&UTmq@;z@PY+@lH0lc6e8LL!BVbsG5k1RK4u27LF%{L)39Y6TZ9wIBHQ#(mzW zX^DC;gu127nX&ui%UQqZV-NJl09_p<`a399RIX~90?p%{hAYymC1hAQ@qBro<<|5l z_*82+x&xJAf#V!a=zlIHeSxW1PgLs7BL|0E;DFOz?U5>k^U|kk!N1l^|a3NT^8c>gzG_`Y@IT2emzR~3gWTch8 z{2k^iv@^XAG&=6ferO+qHq=^OSNBM?d=Dyq$WZ!x|5f_H&N<79!qUc5)y2Y6dGuO! zm&Xj`SHC|T{u=+fpd%G4H4<0UEFyF}v2mbGWS!+nQGD0+Iv)4#sujXnwMB+y zCI)?hAy=J6H#oRnT=uw% zDJhx5Cw9`7>djOAMNK<@Gk0;5D?>A?N>Q!8c{3lu>bftUy_~1d7yfCL-g#rW!tu*U z{wrGNEPxG1o_tBe4!+Ad-D02*x$C%oGv<|1vE91Oq=7KUDK2F_?_z6|Z5862<7`qb z;?b|{!9vJ5f#qX6hFgoSXUWG zw1$UWf||YhUiF%@YNfBQbiYwn`#ODFcz981 zxi$=wvot@jk~D7lwz*)n4kgJB7sDh!1h}7ozB_I?z8-P)XJ081qoC93#Kpnm<@nvZ zIAV^7t0>T0_*k6nuoNuol9o=4ejYHHT#rv=NH8qoMeUBP!?l$%{dBIfRUh**<(!5q ze4#B1Yf|>@?amc;HcV0R$?Ll|Gc0b7l2ze!Cl4uLXeN1!ewo!ob2Tb8PRH0nxW;SdiG03xH0d!0OKl57eT%c3ZL>^A3|? zHyHMiqgYO)Fuu-cTc)LBqK=d2{OZVvZ8tu?;)grGjvKJYc)_NDEm&!Ph>flPZvW}F z`83EHEJejmFOr^M(sFOMYG}UEh{ySpNIHOzyCd%9V?p(oJi#NU{Yt;d?xn4{R7lu*65 z+_^@1n{>3HoR7l?=~?P{GTfq6(|(OP^Pi7Pk(DO1F0E8Gb*m>6Tf7S{%I?f$W)`#( zAiX@m4ljzlHb{9n2z@)2xFUqYFAS$z)Xi!6B84xf7in6;Cp%Cb-yOqj0BhIe_g)3J zjJ(->>;`H3CzUXqKa9WkxyR1L5bk{0_&TnxS7iVFL9XPdBPjc41eTgsIhE`@!>D^` zMNXdUd|_}$&eG#Gk?Odind+fm$k?_$uI4SH?;=3j6ywfT-T-;r>Ev8+DlZdcZ0$MA z!Go74$Si=ESX-qcr9^IbnqbTGj-c3(SFcC462#2%1dal$j)uh#ov~J5WZ1XwDjdsf zvS?3;ipm6VtwAtw||yGR2z^5&HA2qBaifolw1@`E>#>&wxoR?YMLOEq3wZL z288&rQ-nlNrvrO$mlK1|)hpU-KQ+34^nC8Ou6(0eTme3g7LXYwTHkS*u$ zENqwKqFg@TE_(Xq2m_ze>oXS_f&=b{zdWEB9g8})w!Td_9Mu|rtYqr0$TCesB2^Uh zp(g`c-3n?4=l=;$S5yLs@knkKX31GH%azin6In=pbia*WdKd5EH|i#FbR)dPWZ7-;~jExYw?V*q`TMy2&W^=H&kC z=Bwl>K=t{fI$Fh1Apdkrl*;v{(pwp-2X9`|=<}1J7VgdC5LM%yckuPQ*Y5n3Ul3T4bQJ8l%$8Pw z$gw4xntz7^6u##Amvybjp&~~?j?=(Onn?)J+$P+ibN|;RB$JONIhVQ#HFg*`Jefj1 z_@23eLIinzudwqy%ny(&Cq78yA6*GC$s_qP{C9(e{}N;Azm!_$M2VsNBG>p+!`-r+ zj)o&oz~bdO_+@@R6U6!UWS-!6eNHFWx-9GZ%<;raE>^GGd;_A-l}8~f72dz@-8{yj z+8qerY`a}>cJ1JbZ0^%B#RS`YSDtDcX;|j+kuaiK0k0vgT1aq1oA1G|dDPl@0CAg( zOAnWQgF-n^{oX`_^T$bgPzie3GNeENkTjr4DQUoK1zf7}f3`u1KTgrVL7;d}tHU7n z8_pw?sLfxhP-{L+n7F2PRGe}Hq;~$lUxmvM6=?SzdA}D^_yDL%1|(13()B$RZ%=(# zchO1a_yEVhwaE7QNf2xiLEdgZ>|NyEZ2QO%SHQXTe_@0E!#>T-{*WqbYGOsD7VWFI zNyeC<%9^I5GB>-n7O*r3lm4}UFVvvWA+KO4V~qJ*xP{2| z>*bo6MpDD7h6BKY?s_f zx0zmd64ab9N(oGqcD*$jynbDd#H3Ws+74&qxSs6!BIGQn+2I_8Pu}N4n6;J|<&%f;v=w=D--GA!IUZ=6YVXtSN&?K zY8R(=|2`w8JPFS)EElD@d^4uJ(3}T2OqaqjGqXuu*{rdA^_hioPzzrJgSDlu3(VX| zEeliogPL3A>$ho<{0JQoNPxn>q12AT-)!~-RyO;!ZRzQ|F>^BVmWsoXnx3H_R!5fG zJEi)Kt1E(nFCy7uI5HRo(~v8G>@!HFjH}Gus$Ip3%PVodCjEChmQ*5Nwa2kkW%wEu z^=zayMQsLLHO^%~DK*B}!wpZ(bg%4mn2)9!R7$DDb-V4bs`w2?8lXx)mn>leLI&so zlZ(%_xDKHAuXBTGbeR(FO5DsUexs4=rTZ}o=(gJ(!@=6akvltUa}6(G9=OM&s8)RH zEec~Xn%ylPi-rlv0)=6ZDKqGol^8JawBY`tp$_U>nu8g`!Ss!@;g_dvQQl~07+ef2 zbd|zi2^AT6&A5$84f2G$2C{~$>f?HC$M*$x> z&;Nhm_#DF)5^Qcxkrba9{0#qEqT{mwV_DZuHua1szQrRvJmWwrgUWv;JH zv~R|~#W}a3A|jNf$6rS@ko{&a$2G`D$c*<-moyy(HA5&<&q}}R8_Ezfznx_cY1f;U z2O8LBwm9d)mxiVjINQ{Auvokjv$e9JAy>iByT9inj;#o}KP|YVrWIRT#vJB#UuDR* z2MR$%`C{mC$Mp8&RBvW$f+SZtr3{z{x z>*CdqtC1;bWT~|Ybeqlnj!kwndT}qPRHU{isjWW))s+cmcVBK35{MqGS&-Y{0yUdc zx;f)Af=vB}0_dK?wJD`cz3D0+>sV=nS%)0V!w?LX4w(6FpaX-iyHoG&=n9QhP0A$& z+mnt&?%j;t$9aC#jP*C$a4)&PzzicNGa;gbTC;8Lmx#(`Axt;YN_r1^5N)eJEQI2- zy;Ao`3s2vm1H27Ln&ev{xxoSg$P7YVB5-QGDuDK(aAWeP(LI^Hz`@t^Ey4!NzBo*v({q*SwD_pPSD3J%4BwFxajxm)Gh@FK|c z9=z}}z0TB;kc3V4w^+f^?5Th&;0b#Au*=&vL0vyuI11mxP&pfTi=&`P28zbgq^?Z6qS@o=7TS$^;&L}r?GJ8teaSz%i+E;0%mW9)r&4A+B^_2 z^7@!kzYIPFdZI#+BD=|Mh>s~sQ*t~GT7s$2$ry>Zfj<&Mx_fJyAb4NW+T}Q}_U)gW z>~!6bsRy9YdUgPYn$_>XWX)wFp5Us22ASzC-SHbl7}Wih>K(fMpHl-BH>C4b_PFXt zX%gi=c-9RxJpSP+;G2y{l5aHe)`LLD*46Ic(`!5q`bMPt{>@CBcred#ffNeMh@3(V8**Y2KE1E`PpH)ZOWP5V=uD>bP}Q7OgfK051PSI6wuQ6wK9L56Fp;rqpuS;b0$+$@%}d6l>UIP z#)|tzr;fi)qUZFVo$i%K%-1y$D?f9?${|-hI&R92j`5awqCH(V-fh;EUCI?1xkCnZ z{~$!~n!ggt|Ii} zRzysR2>fqoMQ$B@K~cVi8(2l^oQ1!xb+f1k)kcJp4M97l5P z`rHmuD;G%)oX3m6OV>!kT{*~!KgY)WPiWj(Rcl8?zA10|3z8KOcim z??QY}QAFW$vSP(6`s*P7R?BAKHwe~F`@gCG|G&vdpuPVRE976;3X?*C1G^9U0M-K6 w%=Fmb#<(dd7<!I}$nsaI3Hd0Ria{L`0-UdM}Ff z5|G{!5kjbm5J-TKhrDYzuzwo(48qMg2}5{W1+C9Y_{OYB2fHZfg&3t{l0 zo1ZA%+%+=6-g`k<-RYbr`JbUj@G+?kPXn(^R7tjCEs9P_=4T#N_Ar-$&%l8-v8o(JICSW!-aSJ;tz&gy!o z544Sv*NVZ?b5q^V&y6OGF;=CLdKf&GvZ)b#7;ltCO%vLy&!<(w^7F)7*^?r+B;M|CZO?_4!BkmuE$&u%^umY>YrpQc6K z%yxCB_WrPm+T=rYeG`r-tIgG4?_5gVcqf<{bV{Z=I-`G&s2t)r3&T%I(KC1h6=f_^ z5n8*|^Bj~Y6~DBeq9yjWQht>|-z<0cl1v}6xiL<%)@h1WS_p~C^$m1~-6UAZNhl=< zP$FF%8%Z0LNpwa1h*}O*almT(I)}fzOd1{`-O8DDH7D=t&H`j?zOs#gK0shu)W za#UV;s_KIQ+J`+!d91%KNUU%xbvkXxo#`d^ z3G;%;;^vJ)&UC%+&6nqp9CMgj(4ryaMh;a=BHJ6cNc}Ozf zRUw5aiW4zY71_$jZ0!~7TEcYQjo<1y!z1QX!t1kRZoDR0Ys5xAOJ12O&JKw0wf(uN z)6=Mgphg!^0(PryYgD>6Ya4D7A|mX4$VrCPms6GF^cxftHa)r)S74~M%(18-Xox$k zE@l4(Am9ak9(AfZ++PA5~5)rNlq*9h4) zzhWsD7YDCjAm2bJn^d$oE(y;RO!z*|m#-o_8c#^;qUP_Fwa8KInPz;W@B2-m#HOBv z0_!vw*6r%JBk$3lV|7m~Ppf~}QB}1HSNWc7dnLKq!j)fm>!Js#QcP$7(~k{EoSx}p z_%FT+xIH9k#`RN;XX5fMt?5JS6R#~3RxG<4H9@;cDIw78uRgDL6Pun^LXYNUXB-jb z6Jk%YVZPsw`a}>6-afK9F;0Ux(jL#>3^R8qF6@OB zrRT}SU&QzKf?YASI>ByNC=?18CROk3B2*%zbb^@&Jk|Irn0|_sQ1D8$(1_jvOk%)^ z-Aa-K{`0`JYhhfx*Otc=$!@ghg5_ccuQ|iD{d^rgO8=g^NuIxg=vf9`WY@~tR=Yir zpCpxY_SfoUC@1gYdr7CoCnE&Ap672~Wgm(@cM*#NeL)KU<{NL}y?@AkO{oN`lhqkF zqy-gUPz&Nj9S$$wtv+*tq?^^l%{wXF%iYYARxBfrfVn^WCfBxwLVm~`avE%VGT1Sd z-GeI=%IcDkgO?t!5f%GT9t{baXF;7J1d(cTWgSoGL; zjo@AL7)A8a5-436pmNLc+?Pi^UG(_7sn4;|Fd-BVYG(%CRrQ<`WBlR+JH;1E+i0O> z%F&;=P+ng8JHtQV*}AUinm7m}4#B&nuQL!`<4qQvE}YU0Zar@K+r_K2#McOPV(Ai$ zGhnZD123(1dF!B2-IT9=1>L;;qe3q=HM4fZOF+lc-9jmOgshV^e+0AsVH*+a7g!?W z0?momj3<#UvM_wzq2G?!17aCKVeAfAul`e*t6+9bQw^<|{Ca;yb--wCqR~}nS*UQ% zkOk}hX7s0PZVx8liny%nl~XCam?B@d%>(Y|L)KlFBtes>sjY3&@Co|v`fHCBmvjdJ zK(AFE9{M|x#+=Z5rtvjLQDmkt|C#rd+K#h- zRJk`$db=m78$TyU|Ji?%Os;fY)3$@IlmpYk65Vv;8`c++kuox_{JT4~jYVesymZU> z`62!XFG7*Kt7DOb788wNX7}`=2rqgQ3}&=A4M!XU_ii>kOt4CYBM)-__$bBEyvvzuWL?H1{sG!?u)t)?MjDz|Rui%tev zhtcdsmh;k|$9O-r9H}|nDvrp+sK{$!J*XY8>D|rUJK6N%rsq@c+Ydc(dwDb)q0mBj zy#s@03CA9H4TBm^_};)lIRy8v@)}Ri#T2;GaxyUHXh!%ix^>VsY|4qs(G3OPexQA^ z>{!vy7ew!ZZxG0Tm5kL~&7^cRCs!{g_oOq}+~P%Yq70L(M901JElT64Ooe+T(32OQEN9w`92T8o4llujh+|u z5p`+W;);n^$LN+#HI0g&$`OsgntGiu7Lnzq%9Rar$YZ|%V!`EaMV%bkww+n~P9$+ZBfXEhD2A`h%j(Y24=qvhcdsD$S6ucMUvbA*FT7d< zbZtzpueo1aoTrm0`saH47BR@qW140veFePZ3NJD*V0s}SzWvS{{ZKKag%e9QN3*y# zFrZ}yBqF9^U^On(dt;rY-BmKGX{%%}Dk?;LEVOyz(wwuUuo1yBaP~H$IbJXp8`X^A zp?A6J#6RqSE#3oD0Ie#f+diGvqvodTomKjnpk5!-u87_Zo;z=%Tx~6j?wj_Q*p1*K zrd~hX(N?>#Kyzj-@!-C1N{0nJfyWCw5O*6q8y`(jO%aZy@g^@t`j3}|UAr9{dj!-> z@=7z^xv7SleHh>K2ks!mlLI7F=N_<@iqnWH*P_8n{q8C}xL&Da)V`vUirEW(z-zv@ zQyN@)TGmR)h}MKYnwCYUwyK>^7hLhf%47vyli}d9>dWTfO6fKpK;Ofkv#0-!^rRyP=7HCwR>{){qQ(-e(bOIt%yCr@PcL)3FZUgW{J?|hoNi$_W&kRd?w}Qq*=bkl-&z^d763R@`jmp|JKUn% z=R7BE!d)!ScQ4m)q<+2j{ZDc+u8u`7y~8zM(Y-Rngw=OZX{KVc7GtUHHZ)ipttt5} z^qPL}5tPZpW`jNA&L|Bns$zL2@mJqdSdu&k@DXg&#u3OQwX1p0nAV!LS18!EpsSK9 z{XrQ+1tJQ-nrJL7-q%VSBs9^Qc1o# z8Y-4tlF_$f;%hgzD`?VWxkV|4T}gx*t2qY`kcp#;Kw zs|wZXZ3G0;>xXrIAl2AJICp0~!s}Npn8_gr;$(iI-1f9;t#^Uxsd5{s0KOg$deOuf zH^ka!;LaiI1K3}?4xtOpB5Vi3M)EnE(2@3Ri^3)zjepcS9qT9(_Y+@9-<-@>N8;D2 zO;0ydaT|Bj-0m*yMxrX&wBjQomseRu?|_IRe?a;+^H&!L{%qzs@zsjrpr{uGCNa3d zfBZiA&j4adW{^3qd!0u*^=1 z-$ckOUw|_&i2pna8JIgX4!O*D`r+~@a;7{&H81Vi)<^^C>q7uA*khmhF_xP-Av9Iy z$RAQ#U<|YKRH`+(U$>nRm5QHd_-;ZuQBMrqsG(xWQ~jtiIL`tg1yYG>II1}Fsfo6? zQ9-;`P=j39QNvHMqu^!Zz5t)#b&itpA8IiC&WFbQmYM+PKd$uonHrohS-*p8hL<%2 zV4(?neQbMcds`8cbfUgLON){Xr9`or=89XtG`OaCXi<_&yX=9d%QKiYi6`nOlWmOKpUkxbW>yJyGe+G${vEhM?YjUU$BSA zlAb`TC9gE!AT!b!&640Jc&ffGsxcybpI9|}0{w$HT4IsjygnA%&=4?UTK>`Wi1njZ z7X~#*idN%!7L@jj3!K06+b0iMbc)I!mis*62FPCY*?*slfpgTOa(jH^KaC%KJ6(g@ ztK_GYy87E*Akeu(1yr{DWRm?Dw+;v#8gEg;F^BwM-XKTNRyOPzy#>BLcZu-{*%Uk= zy?>&l6~@9ixvl?)HRC?WKmzay#_@mAqz>6|Ak5C2LB1F*MB{BAv#!<07nIFV3c?KM`;6WiGBwlp2-YxE$l3Tf}w{j zCnMj=h<7Ov8q(=F1^Ola)zF%T6Ti6w;DbV;1dfpW2B$yiRjt_Ni9 z07IFx-ZCw}LN0D>Zt(dt)M;=K+xMj5VgSIVcUAajW!fG&(D*Y|Xl#fEOmXJ)D3y z0461-VYYi+CP*YULoes7mNtDAeuCVOz<31BT28ge`C>aabz)XsLhMa|{&!2AF+%sH zt263l>92GuDwI;k$)`55D`7bx*o`VHKf)l*Wjk@r0>vL@AonOLr9&f|IXU`vsy0J<}bR5!c{9s z@8#;5#mbqJDGHw$YL?5fzl7Pyms7jqI{eN)4#?N=lk~T6Cg9UEP3oU03y4>vb5eCc zp52FRn2{)%F+f@DbSAyb`ZH-)ha+XK2dIcVi{ei$AuT`mJ;@@q3+r*UE6Ff$`5vAr0q))?Lv7 zRR8wst+R=Pxu+^`B)l4uE7yIs+e*!wxrKny(n zH80em-%2sv&(if!ql^;Lx16Z85*%qWtbM|^e|ce=3biM!a1;O9f#qlFxo_$y^p^%$ z>1Cyy*sD+FfPB8jK#1EWXoN{=unpVC?^%K#IIo>@ssfC*m8n*fcIMdzQc86YlUn>0 z;g7uwbeTmYZ!eA3)IKW6$c)!bA_r>ig45lYqkedg>Y!zn5^lxF1mOjjF!9v-D9<|O zMo%nkNVLzzxF2q4;i%st+3*I)m!AepYi$D4-?cfEKeY059ejaiV#yTT8zs5b$#W4t_-a8Po}g zX$oUc;GM9Vl#dH)nHws*XHNIDqJ)P7HLJ_@O|Ya9M#eZ4dtZ5Q6jeJvC7GY6+M?`| zirey(G!zS{5l?)J3t-3LG4ZoB_I!OH84W2!6>M|Az?G-1S*5L6pYvvC48Z<|!{R+F zX~hiNx<|YgXv~-RRuuO{{CX5KhZC&SdkZi=pk%c1?@|l`w!ah+2-;h-qMZG&rZGmb z3)plMa-E!?6^Ve3FNNbI)+i9Ky^pf& zkQwC})71>L3%sHQ1iGtHq=BaEIInqZ>KSTARNG-xv;U2`dO!P`ViQud2(h6_X=o?J zcRC~ihX(qYUZnITQFt+j2Y-AmKfk=lw+Z|e++m3K{+k%TE|m1Zh3;BecAdzgYV264 z&|lV$y%K*L;fo!iuSL0aP_nFO(G9;QLf?i4(w+o3KA!4-anq4uvKQ?#%M<6c)F7EYkRQ1}DhH9h6Y|9x6f5fGpwj$Cu_ z?GLf{_j}r;Hx~~y6|L{dvm8LRduBP&I#mV4d=RQc))q0T;uXfOWI`_oLN2*a z9Q6VHbT8?3vuTBNZK>!4UB~K*rP#rrl%D!@uEfbiTj|Y`{TW~f8X?#&677*j0ws(y zD?~&9#J?&Jlc`1#{DTPRg>)ryRaT#8zm(9s7)wm2F}XEaJ}l&D&D)K$*_vIcV~>_(=W^0Ao^y6el!f2#whv`O^eqg zs%%476rsBY;$scrR*KNHp`Wv%UgbFViql$2^npi;mJtv755iofH+1o0MazB z`=T%P${p8PDadUPp#B3P(Aec~YF6FJ(wCrBqdp^q7dgtXKOx`ow*Uew!F-s`1+l)l z&+yt-u6)D41Y9^Q7v$(begA5(|EQMkeIjBU?e#aj_VTxLfISx}?%!eL#8OKCIjK;) zSI@qK=ck?k9k(3+4L+GwrzkUi8>56_hJnIw_60#K}MMgFb2^;yzc(-2| z{%(G~Pz5&SU$^nip%wu^B2)sJ7BJRXW&1hUwP4~G@i+ppJ`6Hp1`iHH>~{iU!d0h> z2S4|=(|-8%q%;1&svi2&p*#Iu^lzg4qvZaf_UNPk+G95R8#1k)g|4Y>U?{ctfUHLE zriNqk2G2lO|0ZSsH(33@(S$+#LB!okm&EFVo{J!CO5aV;hm`aWOGC7;G=QOj;Qw1j zK^J3aw!douPMn6gcL(i)Fak#6cI*y*v${LoTJ6FAr?1dhP$j@t1WjjFcg8AR-r||5 zkY+35?i~yau!;{Awmhi*Bv`jxz?(-oje*<^Uum|De zLTstyO%)+58#g8?3D{UP3{AeVmkN4g9!Vx$1Oi(4ufm(r7BK*iU}AIQHxp3U(s~ zD=-@cmq7JQJdich0`tJELdGwL5|vGpT;C{pG+I~YcGG!xRCCm zAG#R+RZUt#R|q7C!qRvir89G##pd((kNUXawwSXDqU}&0N1H~XN!Q(Sj-*@#V7IE6*Oh&KdO6HHe=NN9_G77jztfmfr`XJ|eKR6y z#ic6yI-BdFuOg(yfRR&LS5DsFbhT{Iy?Z%G{EVm?$(L8%N^I9zT-9SSUm#lTA`~~V zIN11WdP+B%#eSu8_WRejeTPLjEH|GncWOeBE6qEIq)g&4tfDr|&dKs&Wh?Ij^tA^Y zj2pH*5Qw!$K9Tnl z3rwF-!CU6=2oI%}lCh|&bD~OB5%CpOHRrjSlL+Rr_cIE;-kqOvd=|fJN_st#a8C+l zSu_5Cs!O7~$T* z1o7Ti1PaFow%al|MbEj26g**bKy_N@WUAFl)I6VzsgmY|iC&5%@xdD3dOX11j*&W- zC_*#uE42^BvxJ;X_l2zKZuagc| zN~zhSv4#Z`_05Wyq;(Fnb`y12kt%%&S{LpJng^ny01NqGj$7 z!=EiX_V*qk^vQWE@Il@MF@W6^dqkZ(v5!MBr@#C-{%);K_m zyiJdKSyy~A20J|-Yh3bXzd9nmsE>G`Rzy|CIQ3Vj#Y!EYnlc2_na@-K51 zjkH-klRp{s4J>x?xK!oUcuJt8&0g!o+~N=w$wy?k*bS2EQY7a_PF7U>QR^mVW!Z2q zSX#4D@?$&K2?>A@qj9_wlD@JDqDmDGIH<=SOiSr2VP48m;=a-w8;%mJsmrg17dx!3 zj#@wKdD$SI?08`h0JwoV0;epl31$qLEkOZZDM+L`$Mlh4V)=&Uehq1C_HLx%NTG>r zy~GM$Bk-tHn`Gv4pQ5B3o2`?g8p3hVvd&7eg#6MkuDmXSeTnyuNV|5ngx^!HdMvBT zxpM#IOtD=<_;Ob*-zw8=ol`)HDI|x)W%Osi99(*bfd&DX7k4tM&x_v zAS(I-!No0X=5JUinpmG0TvRHHnU58|&b5(@aAxuv)afcmD-1jKw;Nrmh6ctocL2@C}BQ2G@6Y}4^vX(1(+(?V=C$>Gly0)#)^0=)9SRk>Bnt3m8 zq@$3CWa+gO=xUi|&tM)ahudSbbI1mPvCp6Gk?`V(x%tlNJF!|4M%+E4x@{S_g@Jt| zLH!b-7p~TuPhu>@zJBQ{ldjAdy<=G z!y&fN>o3KW_&w#`W!0Rku!WhZiTaif4&$!dxoHj^Q8pO4wyz20pu2LfSmeQx5Cc{bJcP7X=D(jM> zK^OiT4c>3a04H$#Z>SLjRg6p!kv6})W+Mjif_yI8*Yf_6cSR;tV>c6J7&_>*G$5G+ zXD>3;V9z|TaSuNKZ_6BQPisKxy!M%3i-ou3iNf8WlMqirZEC2;3(I#0xx+5A2mVP| zC;tI>`7c6rks%m_u%N%`o}f45KfsQC&2_>O{dNGmCo|k{7mC%jAd=4my%rh+9#F3Z z2qokAFUivX27&#<8b)s1u~pusN$o7=Sqc-b*SbzQ_B{*O-Mzn%8bs|Z z`L`YwAsuhh_IvR=_O{zFGv8U!1M`YZjxF3gRAl+_ff7LwcdLd41GXmKv?E zlB=hV#A3>X~0!9MIT~Oq6_LB=GD@_p(P-hzp3w0IZ@Q%w6+Hd&nzVkiP=rcww)<>h)7re0{Zg z7GiWLh~=o;NHUR3M$CRIJpL?)K2ET_>ifk10BGbC}J+B?3LD zE!Ur+?y)|hjE;(4BaK%-%sH$B)!(d~ke5j6+VFd)Y;2DC*ss*eu{>sB?m`R@4faUd z4L)FfeP1dT?h3y*c*%A!i3h;h{faXaQ$`oywTt-{*ZZH=>+*7TX^Unrw1n4o>BXF6 z&{WbdAK%&T{x6{PkT(yJLp-?HKF;c9RHr~%Gwcmo(X721C}E_Kp_G2_#53b?$%-Fr zJX^s|?-3v3vuA5@H>E}!MysMMHqAJKnjoKnqvD(Fp)t^{b@7El`oiudWc9`?jc)$s z?=l=tyk(0!nC^$wf$m_BE56&2WE_>mBktyGycc6vW=uGLN$e3LK1Lqq0kk$*ss)j8 z?JI^V zD8{Mc{?dZ1)_P8h_LgA&f@yiRKXJUWlys`5#|EQUPAsYDrOdd9!uxvGph7$2zYe-t zEVHX!u*zSs>BBwX??IFX8sslboPdq(W}e`H6`4KyVa5^A1Q|GdK)TVU3!W>ygCZE8 zSM2#`Npo{Gr%2|sJ&9IpBh0RHa=KPDUNbqBJnUOhnUdlHFBM4G8byrs zyt8D)MbdD*mzqcXhrqILq<@rJEf#qD9U}qPCRyxU#ICP1VNw0?3m`f zsnfN)6;!BY(35*<&TlMoNHOXXVi9@_K!gSd_&41AV`{aB0bSxZ( zruAkA3ur0R?kbz31Fkmg*v2%Z3hK{0C|ja|yrDh3__)zkXyjxxpcM8l5sd6Lr>%2d zbMTK3x?A(+C;qM)0|^Pz{#|ZjXK|tJyTA(_V&*-idVhLc-Re)MCt9xhJXgub;zM7{oE;Da?s?$~voN%U+~B!~u?sm_&W2X>b`FAG z7%QY@`TNEDt3{QUYLb*z7_c36s5cStC@a@P?K6fD6Tq}59FrgP43>%+^r)$>50a|R ziPSS_wp&$nKH&7l_KuskV}OgSFr&39)3SRjPcIEC+v-VmEGS_}4i+V!nZvN2Af8XN zu+dtp%joH`3!Ul78__7mRFB|~itm5@Pze^Mc$jPv)Abi}2;v^Deozz}q@^*tEPGMO zT>P9x2LBmppMu~Sz|teD*eY!u<6O%=K}sB!y$1hyk`FFzsiWp|L)|AtW@%@}yqRYB z9FEO7h(2D8U#JmDQ;{~@SbfQQapS#;^%>FoS6l#0DrfY%@W=PUaa^Kzx;vP|rgRQV zE6stpW*kDD<{-{$NGF}soK9g@p#_t&>Je7-2(?@i?^dUUvI>w0K%&y{r_bi_xakAC znNRVeh8v~oHL?M=u5ril_TqDR=%cqBlzO7OXXvtxoSF8yRTZVeskvJnC;~QP*EB~- zgNX18TAgyN%G7e1ij_-X&%7d=H=%Cp{N(-i7hCjGp`9P$g88`I_OFR+Nx$gFAz{!9 zEg$m~w>#MlIXaXFRmkJmUA zSoR=vqhD?bF>^&76H`-q2=apRmHe3N_xcF zVdD3Xys#6GMqT7~4R89ERH|2ZG(~fb`~d36;3#5j%Pb~FOyg)kIhA*w%?Uyysv-P{ZWb(5k3oXP{W=F>eIaVZN>7rft7><0s3@Oo`42 zUh$ZqY8I)52NlbXj+Rp|y>3|bq1TtEtC9{&)GO!#{l~nwbTG*#*L2#8Htrq^QqXUl3U!KmebMx_5WE~@qHz-%MR9fqu9MtdlML-Thf-+*H4pQBfmjF7+`E-3_&;-=1UkFU$GqHT%HfED$rK>L zaK3|r?8mtA8BpWIZkgE*J8PeKPIzx`t#m^%E!HSu;x^^nNke_;R-|s7!Gm)5?M+RHI!&PNC|b^niEr&2UGV&&)xJvqI$D%sY*( zjKHQ_5A+SX20SkVO~Up<7Z6Q!5+i(_tXsncyN0nnxk}X?!{gRZ`8gb+44DBj5u}__ zEKnIUX3FDmLt|x&hxdBSPD|aF)qJVg`nNa}(_g0aIr@FYR^3bjF}eg)JBLlFGEDsG z^>JCN>>|JGisJ*+pll)NixUtE+P=DOB!o?~MXf7qXK4<&$X$OVm!m&1P zQ;nT)clrY`m|+SUpz8t|Bcz?al}&$sswZizatt_^fL5a3OR>St?u_4!W}k}JyDR;>H^ZS=zADv zAc0DX^csySQ=DPh9pU$+g2*!GlwFUECbFn~njY1tAIz#V6IBk~*)Ts5Y5(id@jeb? zzzB8{oBDq2eWdt}{gyk;43tS059QuSa;W3*I|jRNP4pK`D}C@5%FV{an2`;pwr_W# z+;KZ9Lck2qJfN1BHv6j!Nz7nQer&Y!>2sHE;rV< z@n{jV^y>v1ZUdg2(n8K)G4O*D$(rJrb3~_t*Y+MZH#;u}!C52=pp}-*wTB1ltjVtGsT8 zH~nr%Rppe1VXUiSRyz@;t*Nd{vD0Qo7B2>2ZdW4T)E$+HLiECBT?WlQ#6M$wHdKS;*VPp(rfPK|Au`{Co1*!TSFnNgR#VT=Rl`Pd;v12C zo%0`C)&6dr1#PQ7*1(kVvKj}nE7d!02LNZiJ_&#AP(t^Kw~t-zdi6@j?URFqHk)$# zpH2l=IZj$eeXcU?eM&fJV_b(X81-1#nb90*ru*wTFyY5D11U{$V0`aNaoX~(k?qpP7aI#6z<4B)7lH5s|gS$)bqQRJQ`Y#UFI zW=D_$^rfX?1!h23shQiQ>U3&aO6S{u9uFqU$iv!O5oH|z0g;U0N?(bX{*6DCldE0tc5xgHsY9e?P6sPEczE(MGzJt#LUj6CnCL#_t34rM7Vt(7MX7I@Tktn&6 zL(x@Y<*4@zvJ(--e@I6pY_GZFcV@<2q373B!P>(Y{HOBaH+clP02NZa%^K|U&Cj|vn)-#% z-$dVR?-LC&ZYsoNq{8V48e8vLn327gEzse?mWYd7)mzL({9gpUP!|#vM8&=}0C8u3 zlqdJ2n)s=&vYaNEy7Ie_y-g+{cn>@&sLB~ssn7imicG`m?<`%0++HXsNe^#N7u7V* z8l}qsY$hL}BbAJW80xE5S+?D5`(TvPl>EH$F%XLIx-_LXiT6PGyB+^876531J3~90 z&Jk%p4*9%WDMn)vj{9G#5dAl#xLx{0J>`cip3+a`*L-_DQt#*d69wN(+<&;5E+T#% zfAQ0+?5Sha$GONi7C}cO4UaC@JeWD#Hd#}3&92hu$b9PQ10&(r{bT(>paxk{8lL=Gm4z@m?@aC z8Jq1}dF!({T3kmRg{MX03!dIG;Ty`%#HUcl@R?NkTgId2o4<13l9x!C)JdfV{f?gg z?>GfJUVe1mj6%W#G2tPtY)M7U$|qCFqRm`b~6ML-+AMf?9)d`U0Xq|hpokvj;_)%F$9(OasiJi zx#jY!FR4wI0y*r-Vqd(V(ndIMc6Ob@TpMLoAU$p?&UGz9vKIQ}gg6Ir> zkOUqaCfJiP^6Ir<;+Ct<*{3#iTss=2O{ySKo`Rjqfj$3bQ4J#bxQl};@AcTF6oKn7 z-!7qb^k7frjsn_KrFau;C0~@oUU9q2qXd2WK}Vge?l&TvCR|S~UD<_oY)X@Hd-oqj z<5s7~JR1tBE6hB)EaWkj*0P~roJU>Aa&_bZ$Sxc1`g+e?I7Ofmafw9F0J4aXje zM|);9FsFfZv9IGt{}_I@9V8hZ#BKC6Z0;sb7Mn7sP}@X4xpFSgn`uooap3XAOvR4c z^~by?UXC`xi<@l$XFU6RS~csGRU6}PDR3VO?@wWkmUE}$w6kfb5P~aC^OOj;6APC? zuvDqlMCM>)Uzw>E%%;_Sq+CM&X;-MY%z5L0B4rVa{_&)~!Km`@26M$Wo3(S^U%$9< zHxPgR<R9oe&m?>3*Fxa2k1)FqTv4g>}kst_eBfj94r4|^4@*B6%+P)ct*M*wPf6@ zy^1GXdHibE(;z=KvD25d&FmrkSU@0zC|{b#BpaM4r^cpDn|)&gj(vXosT!%@2oJ}v zX}jFFscX#k+uSJH+G29q0%i4%Y>a9`;O?^@h1}1}rI3auS%c(*vJ304Js!}g^`V?{ z3W&PkD_dpv3-{PLxF~vk`|MCA^A?^G0B@oqW<{rLUr==GqxdXSWDD7Ia=6SB(F45Z zD()8tl16EA2O$Hj|M*7PhBB{^cIDy2mq!ZTU>C>z&2!xzMYzut0F35%WG!BC?Qv}% z>0-QDcxr!&FQ(3@ny}eAuh&s^GWCJqfj@D7vx+`&Qj{6BN^fq>(MCHq-2X)gN&S3x z5mSco{`K;1hkR|wn)cs|f4z-&ZX9SGon>@>bwB1~c!W>U#bL`>Fv%_77k^h&jXey=a*t)~!7|@i zxin$I5PnhW^=mzyyZQ#7uVsI@Ec{9}P~+<6{amY#j55}>=>pZ+%=R4l({_Rt2OeClE8T>M^= zNHOwkUinIOaQM^FIWT0O5B<*mFT6Ub+L)^0^Yc4*-N1(}HNv8uMT)=Sb9MjbY;^A< zi<;r0pR&V|w)yvd%7?RB)fKVlq~8Cr+&t!}dUR@HJgE!3h4xc|z!sOgCwzADUaO0V z$7C~sbcYT+weG%*N&HFG=Q*>KSf{S-kH4kItZ3L&{DJn-8->QcIQ%96%%ra%a{Mqa3gxr_d| zWM!6yU+}F8<~NAc-6v}f|EM4}vpZ2@BpK2P@mMFaCwJ6C@DnQD`+?BAQ;IjZ@NOA2573G5C9RO4)uWd6ex#KF(?_tu)|}t`GRVOb{PvRM zLhgsBd1WjPt_c$gEmpRVi#@FG_mr!1aFes+<>G?|(!je(ANvh`J##f*w(zq8ERTs9 z{5sXg-(;3vSS(R!AIx}2Dw%oYsc5v0g55H5k`8;})jkagm97J0ZcY5XVg{5Qbn5;1 z2Hy&F0S@}ACva_&yK?NMwu6-8`FI}Qsam55F0VxZM2hd_v>0pI^SUg#(k0mkEO|>U z7#2RMR5cB$D{|C!s*buk)qP{I<>wMDk`1;9ufimXN3O_Ow zenf-M2>Bs@J$F}&BC7wF@^nOZF?#rEVe3kupT`J(_GYz^lC6918e7OG5#-vv?d@IV z*@vxApL&y2G2Gt@2u<$9cEnsCCAyw4^A9(b)1Cn={PxBvkg7o-j!_t^z#D7En&NG2 zasLN%?*Y}++x3ZJFNj$FfP#PpL_t7BK)Q;6NK<+TrI!Th5Splfh=8Jibm>BXP(uv? zk=|<{Aw;B?B(xAhAej^Jo%_wb_nS4}op;u{XR#KLoO7PG_kMoQu1kV>)KlJ=(O2s{ zV|P8aVldj%ua=T!f9pDeGzj8+7adqcF20eGo+zHr%FLS##PdWuJ;w7O{qCb{O%jE8 z`_of2wgY=Z(M3MvXJoZgCVq|^n)bQ|UFn*=vOB(292N3tX`=bpkQZBE$9 z)(Wso)xpS*DxQ;QE=adi_EkIeu$D`eb6eTZdRNs5hBKEOO6RjP^GY)t zjnmd_{I3A>^y$pL$U@)7JoBt8mxr~I3d~QX$N=XU4rOdJ=gj>?PMHkFrd@NcXnQ3O znH>p!F!hXu3)+trN%TtjKGUWc`2CjZ-Fx>ZD-}*KbJKOVd{mW{!&K_(v1NB+F)f)j zuN>~(Zv_ZU$J~%x1`g4gQn@#WAilV^(Gr^87=A)h*2OEO%Sdt>IO&Xj-=DsM+KK)$ zaO^5@YPyryZz=qZ0n_O@!um3rEVR+Iupej>XoGdd3{xq`C7H|wupEH#zCn>DPcN;blOOvcYBFbc zj_`T|f?-9T8MsZbomJ<$$X!&iVn2mQzQb*?ctN$0!`-=;0VAn+4F(zjdc->%9^Uy7xhVdn{{)ik zxg0?o0dx{A`||L+aG*(K-fBsx;M9FEarPB63-W{Cf+ZTJnVJMjk)}pS3c5>NAM&&S zmh%H)wE2>iU=F`(S-%qhTX_tt8AK6gR#U)y-p=!-hwfYM&2L`B?q@EYBD|{szkuCH zf_YzN;M+geFdvmx@%W+CYu8?=?}hQU_V5{E^_Gh*D?z1(*LV5yo~b{p2*GZ8RQ*hU+EoqziqQuVfM*g9um8> zbB655glnLoS>?A(-W(Zec$tC+F97|l*gxH?Gau{uyzS@JAeH{C9E#T7HO_Ldx|K{?1iMaQ`o?4B4T> z)x_$QX5A#I^mHd6Hp@Kch~WDcF{k76pn*zl>c6^Muw={-7R546)u53MNCx zBm2>={YzB`0+j_u>W)bQ{UQOD4}fbeeLp@=sq!%5xXv^D{W*@Ff!fnNa1>D{U!A%( zm6G<{W!nEDAZ2?Of5t?d+YTsaVS!9~2u*enS2CjCo_Cr5`2+RxaST@-AYnXSeS~>$ zxJ?@#nLV;E8vX^0-Swz9{2rCe<*kp?Z^GO7Q5f!02%wcW$-^kh~dJY zw+u+FMH_26z#w&5`k)K4pL4DaXDusa$mVrUA%(jf{3$Dh_1CbKZ z{{b%+l?f~-pnEfA-$o`Ob|?3%Xge2Ume`?!QqS|3fc+AN6hxtI14y%@Pb~5?{kt zIRK3%a22QiJ5b#JXGr>=jOyQkcK?sR+S1_*c?m9z@x%ng&ZoXNiX@H}Vc_G1t^zeK zEK+QEB+<1S@E2GmW-ly(S;om#g551h& zeA#VtxKX!eloLG)&*@X}W!@)bPKFJSb43aQsu}y)kls8|2ms3)uK#6CcTR}50%Scb z62?)Vmm50X=CfH+TM=~EE!8D^u64D^N0k#2!^lnG4B6j$&)9C<3?L+J_g9zm<+-JC z+^B>OuBWt$7h9Q@#cYSB4n_B5Gj!7pIr}e9^AVqumVe@xt9`y_bHny_yrS z;FS^+!bn2^sa2nVDZgjaw8(TvF6p%)6qR|D!Zn&=Kd>!y1N4qvzPxtpL1i zS$3^~p<*l+5hP;^gQ+b`etI%x`LbTfqgR>PdgNzAhCKrc?GVrWcG<<%S$*|}zNCcw z0j2P=z!bEw;=matdhYuPyOk-xh|23;Vz1N|I^}9e?)W!#bj>Wv; zMTf|`-=Sk*rzlU$@rqLUp~9Xt|GIkqr#HR<+w$xELrVi^63I9?D>jNbHL}+stH{73 zZ5zlKw!1fr(N6w%;eozylZFenzsi%Fj4_`&0$dps!sKlJ7c)t2SoaNF+azgJcB_2D z$v3&=p3Uq%PFxs#k28K;mY8x0wH4saAW8A!sX)DC&r@Yd6*PN;&UNa&wV#rtp-&hp zx==7}cq?EDH3clj<%NCt!xz0O)m=x?kRwsb4I=T0o`PuP6qrR8u6Y(FwiH4XHV!Ty zSlmhP9S+%DaMuzPR@x2*K(8}+zh5J9yc63mz#qp(^B3i_73f*E=C6cm?Rp|_;Po7P zQxiL*x8EJ9~GPSgHL;j)SWNp zPG|St>&y_Sz>?`nZe*o$CJxh7MaLrvlFIj{Dtm9s=YCFi#ite6)1#`CuLN*Pk*hB^ zY#M*ONS$bS_~H`8r2bo`d%Mv$sRZ}JQi?UYG8T4 zuRB<}3h-f~lmYTa<|$;a=Z#NsjFoS(;wQ00&gXH|8&z(le;sM7_IOqAZeyd@shmcZ zS171hH;ju-6$Rcpz{)s*n8j>taHN`SNcuxobQ;aaivt7xXs8Y}rF}mhR0jFuOBP$n zej$Gd3R(_v843&>y>uMUIQIkggN=7`I#geeRux4*riFw&(UHKMeg6~S%m1Qo;ol)` z2jT#4i-twtpQ+(shD9G3Thj4j$!dYrAhExj8*rX~VP^7vwE1gIP0hGL&j-S$VF#tv zBU`sTlX|`fuG^LUH6Q!dk2gyWddk&)(jNQ+Zj}iPs^>4DS$fakMw(M)3!4+KvPbtnTwNpby zY=OPH{eYj^1t%!g5$hrYDQ<;x&ccRQ@jX~&HyeUd$_{HT=@=b#bGLg57eV+t=uc<3 zgc{&(PiIcviMWC;Eqvpam%Qkd1TvBm^*^2V5>x7SGuwD$t=R1*+s}uE4nOqf90zYZ zDquno9cvL|!{^=q!FPQol>v z>X{R1FX}@4px+}2RN&~Nf=eXg*}a^4!0=VegAY2ZNh#bDXHIA5){8wEc{N;lDpSVZRl6|75?Wk&A^()c*f{@ZUUN|qkwpYTh7^^y zG*aP&@_;{n|5vrf*WYrY7^I@PqGlhK=RCoj$iY!z$ZRdl))Wl7xuhqT)DibIpIh(L zBaF1|Ltlk*iSDfr3(`4j!}%vY5sId8P~Nk)n-#i3=gPjXYqZ>iUdaC>5z87f@(>Od zOe#!y-YU2qTsgk9T^T2QB)!t?Q<5+272(_sAScm|88VANCuP&AdOOFw`WmPbqNO*C&`yt^czI2OYjDq8bm^XZ(( zi=UGu(T&}h33>$bs%p)`tZ>az+L0>~_{aN{{n~o$9QKo`(F}7=fw4_7A4dC%UEbyP zF7~gzVeDESj~d}-&+?(a>FkqjCE51IAZ48in>(@HNgcE61Q=Y{sr1LoMrb{pSG7Q2HWVl~k0B$pZ^Kd&HD-tFJVGHQW4 zJ~1sB2XmXx7t4`eKoem3#)5~hc)qV4eG#wSAIpq-Yo?puiTB11vz7hMa1cxqUGTqh zp^8h{yQd@jD>MX^)8+gyL|c65(Gj%}l)S<(+Co~bq5(`h9H5utvxtqg&h0SXod*Um zbCZ#!V+uRzskETnjCf!ddho~;dD6KvCfm7hYRmw&RP#BZ8~W8#C<)X#kY&?e`lf!s zEB%I$h4#p8n+^<^UAJ%+RrGAs$>mQ}V~owsq3vtG58L#WIAfke-E5n**6|rAsBuiG zpm3<44OQV?HAvx>i6hhzA~y$)^q*^vN1ucRtj3NiLQpb65|A6f(9bRJBDaJfWbVBA zSwk2SqQs2buIZ|;-Jh2;z`Wp(X3DEo>-ID2$-%S7Cm!|HXQb2JUFg}OY*;0 zjj`G{$(3D0BsQ@Pc5goyRjV@ae8$aPY{RB=vNE?Qr2j=6TYDPz_Bh+388>+KY{E4e zdoS*nf;R#yZ8S!3C1&cr!&Bx*s5L#2OR zK7mtaWlY)|&{$0&9wl4}jz|R-`1Ly@922HXh_^@`j)n6E`k-SwhL50ay>1+@D>NOP za(24AQH%5Xg-^hje(j{_q2V8zFZ1=z8syg8H#w>Iurn@}`O#!i(O0*SS3@SeKF1bY z9cCWkpOpH}>;{J-j~5GTKqOsEr0|7)X%8eU0I9*TnLpytERt_1)2i#$HU#O#I(`7? zQES(2<5OG>xW>qP_vBve6@#`8FL7C_b;SJ~9_UUOi^;F}rLPUoioxxm;frsGx+4GN zhrY2E3zGK{6`IpKovXW|GwGc7;!1Omjb8rIE3WQ2Cx>5+a^Kd_v9(Wr*zBdBz4BnG z{&=z8%Fi`jVf)Sdnk%<fb#?y_Gppy&oadwv+zCd=|KB6Yfd)m6Ug=`j#`b>i?2l zrpK0eEY%p2C_lSEz3dJ_yu08ezju%>d|LF+1+dapRl?QK?8TRSx}G?wZd*Q~P+e!N z!f>Up3(83jbZc60ZUlLs>zP@y?u8l)4+(2K*fK}gys!tb;9iY@{7^qrztZgdr(-L! zzq$ZvI4=CF%b>zg_$JrIWCvTle0?CJnjx{;0%vdEjK=L7Ph zhc>YugWcK&26(d9Es^@{=E@1TpunXxkC|TD;~=^uZWsfuR-y(8<$5F5Q$C9Ujl4q0 zk!KtNmN0M#VFJ5(H3~;1upzcA>iNouBD=FLE4YWiU8<{HLmW;DE+;_8B$AQ4#2^D^ z82^Ikob5)uyI2Lz1??8$6}T8Qh=C&z@WNPP5E0o<*%pH=6$X7E3@FgHTBUb+1vYBw z+ur3i%t0Re!+Txf#SJ*gLg!|aTn0u8O%Q1=MSiLSCN4BX9DTy#otDD_FO6z3{Bvo( zf^Pv!gyh!58TJ3&e!h!+{rpmqy5L=>7#1}5%%hBNAz5$ar?-g*;W z>O4$Y65tlbWvFs^6qS$wbG*ZgWh8N6T;D?&N_NKe@39{NHu+*>o`8-1`5ZPWx9KMy zI+zP;vMmGSlJ%=BW?O6V8A&pwF(rHs=8TWeMVI`ty0!X${VB9w=n|ktC-u_YJ>1{M ze&knO|7rN=PMpt2ejcmv*1vyFL`uZP)*<)OyzKS;f5o!37?YKYTp7P3|T&%o6=8vMLo(jnsL(^hy| za&uZ-?4oQ0G+xVTc3$LS43~1N-T`7eN)Cy3x(n;)QLXtgITMOIVR^|zAztiQZ6>g< zR~7wjtNWJy4i55S;cc#`=Uv!mIjpD31-aULcYKY-SZgps(a#!db8?WgJ;c;HE`9Pl zZ?D?)&3>~OK0C-o;fD|}2kX1A@_*`plepntk{aN*(4gHt2~o*gW*Mc!_kE1d`|&Mg zv?#_R1GRonI`|eoc~jq62oaIo#6$u5RCD@)$X-$VowM|n{-`wcQ&G5POT{8#*=ufV+Df!X?oPHB-o!X?hM6_fN|{&7PDyR!Bz zO?E54ca<`5xVpl~mM?kxi==#Ik9_888s$29d_}#6lpu#C)X#A|!tl@e(#MZTeKud| z=_H81@wMnKp;Gl%rI;QZ+&|GbBpUWDcgB>fCCK#$Xlymk?Yt>^?4_rf`gzd(!TG@6 z+4i~t^VnBry)zWC8v67bjEmphAs4^3^6Q%(wZrKwlT&X52brIuw%w047P>Fqsr*o9 zXRtEiDVO$^Ni<+Xs787rbY)TMdqSs0zaETR#cs;@kle942@!DbDrk=zFY4uR=(8_( zTMQMGZQhi$vP8#gCz*uIjij&&l#b?R&2+!$Eke&_mVDUB=olQ(PU{|BrSy7ls|OU< zB$re)CRltbn|sigIquSXj^l#plo;oGdROa&`xiTHYK&z)tus_8eQHPaq$x850(m&e zm;yCp(j2f??c0c$oPI)E%-E4fnxTo2sTlVMVqcDpKht(Q1jDU2{elhW7YpU~v^}p> z4ibfZP6fL_vr@s?(SZ{z&5v49%k8xX47e3uxx)jM-07^V6iFYDwHQQm`+`zkpNHn2N$b}K}v2y6^N0m52>H@F4bmL z_?!kn=A%V$WMGDgcb-XpK=pJb`$C+n-TXo0?h@F#JJV~=()t7NSRI2N zx1gT5a>I@hVmx2%58eFBweTy@ftRXxRKOR!?qusW)@It0xm)47x7clryzJ%G6LQjb zD0QVd7o{%%EB&C<14`6XU4QtxBFiQuv~bx`;epv3_r(J&$)>M@7JxSAsGbH|l|Z&9 zZDYG~kkPJ(fr}|V3^FNtNW`%U`Qs_nbz^y;t>0|XZ#wmvjo-%i``Eji)1>LQtoFaB zl_JxOpVbuVU+o-zxy(`{?)ECag(v)IfrenRfwPpAi5!%A(JV)fSI3w`FCj=zyOKkj zsBIB#-B$P-xwiHu%K$ra^|R>d5!+?doD@@oarMob$(j$$FesNy9pS5)dY(|MPP#~4 z9G?jsbTj_xO}zpf1EyUz+R;A%wm@f7T7?Bn3t)>L(0VIBd++It7A=uB{E20e!;)p8+sipQXw#0x`cqB6AgOoXk_;^q>oWy}K z`BkWYmInvE>ZM+y?{10@>Fdc8BUJ3%ejYO|>RdGxe=@KSQ|GBB*3$_(iju1xmmgc_ zAbF^dj^3|K=}E`r8Ug=qcqHK!`6^B+&h=I?o1dn*k1mYrH|7T@4>yW^e$zXo6stwq zh3(RYXyc;x{@Z%u{;tJ|R`DKYX+Rpe^mm6x;{fH>n_DBg>Bf42Vxg#*WmO^Vkoq6Z zN<_93B;km|fTENssc9IB+6YSBX5IGI+VR`16`&ykiKDzj=D6+6fg_i@N6QQri)Jk7 ztXey`?f&S%f8_iVYQ)$4j*TA~&xt@w=nnZAe>kBnT$X{UjVXdsx_?ccfQCFC|y6qFDGz(okN`Vp0}#fj?}_-GM(4=K~wHk z#9KfRpQx}o&fevI@fe~yQ6cjH(f3_1IjwcHZdxSfB6@7#P4Yqp!DX#Ja))ZzH`;e7 zonrQiC}azkNm2B^#mwnvEyYHgTxEM}P5@dU1Q8yg7CfAV;2+ZZHB-a+yi3$oW53u< zKYrv`8AH#gyljq10$_Xlx7x-l63CO*3^5omYlP_Vqp;iw$aW@~gokGyR47{)TNb`zoN&0+yFxZlZkAy_l`K`-ZDI{P zvop)#drRbL47lC~Izby$Fu)+cR?;_W%V$6){D2Q_OyE`~@9^$K39#KH$UcKEU-Fwi z09r!kZgO4_%>PqyK$Um*!}Y|&ISX>N)9M`94ipW*WUOp{z*hCD*{k;eASS7P8$Oa> zvDx9HO2?;`2i|)ZKJ^(_REiuv0#27WpZ*N|ou2wVj0mtL0}q<_8A@HO(WlFyB{p7% zBF>EYtaxQln^LKV8p+kXH!Z)wq zH^-K!)kFa(Z=}cbbTNoc=jIXY-MEu5Ky54O4`0$YG0_*v){O|{1b#ibe@mPt;PRG+ zCLnZ+p7GYB<4#srNpPn`XL9G9-C=7NS=KAM;G5=rQ}=UQ z&J&5ZuLU7hD)l69i%SK9<`^rI)C31%%IWpVaA#Lk2HgTo999{iKSd@}3Ie6pjRLkT zE)8vZ?>J8v%))nn_0GrBD2-?eZ~IQv1cfHAI?yeNE5LQwlm}2Z+l;sYm=)eW2q1(9 z3#o(}Gi9yH0TlrMyP1x1mI}ZUGABF6z}dWAPPV0Yti?~aAPg!$%K3JyOXRJ9e*&u@ z#;Ppn<+nrLgt39eCPm&D%E%8%`iQs2%0tj{xw$fKbU^H1>iacqaPR!!2c;OUKN_iC zb7E_3Xh(otL zikBnZiy^#yz zv_@+dZ@qRk0nzl|?J26@L?J zU7z*MuS2jc3pD0>2mm7b{rE6$D(H={z&ECZ&p~2dOY!-n zeu>jEDJ1`?kCfZ&`#8@YG%&JLS9FLj0{GRX;6M<$; z)JPb6b28hJ3jufpGreAd4xaJ57J_PN1Wxe@G$7NerF%`_0WW}v`(9PoE0j62Z7LgE zT}ZDVwtc7v(@>fc8gKPwDIncfzcyss6f^wEvNrkqshXQIaFr(wx7FK4LItbJ1cmkW zglA%-7m)aq6}$Gij*!BA5i{YYxE%QpqkMw17fQ4N{99zj;5>-`+-a}O-Iyjl;NblT z7AnrGQl<4TEwpEZ8E5ylkD-3n8<|V*{dS>E!tz(;^6}rtJm25E_KnHt3&|U>Mpdw1 z$;&{TUI%<}n96zgm%{nhiIc_rHtQ!nTi%zSYZtV@INXdct7{n4FERWPk~ZdFPkH$f z`V!xIwotj!?ct5_;aKgWGf|MGLqrH^s?04tj&H2aWc5)S|%>7(u2+k9bp_Ex&cCG0rl|ls={OgM3Q!+ zmQ5Ldp$cZUf>%X9+tG(7@s8e)&?W*T$D!j?r05UyX}ww$iMR6qsULnq(HjaeegJ0g zK^ea(*!2fij;YA@iUg1@m#LxUYcZ3_=LdTEF8nVAEei8>+d{W*tKHSGL3#E!dR_=i zFc2rmO&=W`d!#y?y{&A=Q2*W-??HF5>zWm?BFgx^?{xpZ?R}+H+w;!xIFQ;T_=;_P zezT+MSle%PF{pNhF$(8zHVZvMT>=DnH9fbGp=}$SUjRBWYRRd%EV`7fkhVvVqpxfD z78XQhE9YIdHh$;6L5#jye);q!EHcdK{n7TM&JdW{P+G5P6d2s;LTkyj-o&zD0f&~? zEYqU2HJC?WX-3e_YBYa1!)L|vt&i_=D=CYsnE@+wC(mizjEiR3|TR6!M%g4*c!R2#L%L0 zJzIlV9(q#0kO3#*2G_)I>ke&gJlgfu?=f2`6UsJrq8b9==-ZUzoMce8wiH`o90#%l zK$_K-B_=?epFI^+d3KMApB)~RydY*V{O1o~3+9mYq&t}g_3S7`$}#jM!jHXGOZ7%; zCDNfF6TxZirxluQE~oa4sd4AAj70=g*;bbuj`mf{`I;eiVn_*BkbfBE6OmV0aNVRd^L(`q{22 zYXPKblx|8;GsZ1UJB*esPy5|UDndUWSQ22JXVt397$OFl@fw)VX$9)RsKZNgyr>DB zsNnDv&3IQ5nX_)OxjA+uyXGVdanG~v!9XNo%iiPsvoI#V^Hfr}WM)!vyT8NM_O90J z1O?ceSnWm;dl%Om@@LEi0&jDV2|_=8v0>9C9rSX)Ayj7B3BPVLhZS7A-C4?~nkSdO zf@aQMLS!t4*X3K7_t^;{%{X4FO-NM~W5nosDO#fQez9WPRUChf*5mW`S4vgSnkyPp zdmq|tXYjQHDn09HzJ!iBRE|XjFJDs5*|GCYB91PNaa{!`hb_+zH9P8M7cA&Y&W$g% zU(z1=YHi}UtogD%08`MV1xcEvKbh02yGrsmCF}Ogw^h~?>ILn}$zQymtOsQ&>_}R$ zm^G2McZ47)frxEq{8ol`OqPLeiq~5_W7br5R%+)eu~vEY`{otNZ%YP&;g5Z`&ifyh z03u{8npPlz4`X$r9ej-UwHMP&T0ps3xSEtxta11#yx@;{wQpJ8a^HYK*@q)zclGXD zXq%m_au76;hCLF@eq+H>DLXoKJIx5dQ|;DUHzy`@77hVV-Rz2UMbj+nq<0f9aRl=dmZ! z2POFs8N_b2fr1uqXOz#YlJ`d4(lL(?c;ou)IGgM}rn04`3qUQBQuwS-@kYnnL=d zuBwINP8-p2k3%fq=c2%;dBSmHyg(;((Ox4<5ZU37^(A)cihvMoJZwy8mUO^sVV zE=g}hqgdRbxq|g`mdu8xXai4B!MTaaJbQW^z6R8}`vJ4ZZ+m`NsxiV9W3>>H_4*O- zE6Tueum^PHs%oh)n~wP_yq;;84fe1}h-rFJz!Ss8Mw}OiRdSuhA+p|^iD6BpDVe(8 zka@9kj{PaNe*<(aW5_tXfI|$nenb)iFHF`pGh19-)HdjV9+Z6Bu_Eo6?o}S}K6kE? zG&D!$Q!V>K-uKtCsRd(PkuBV+%EnqLCJ+5V<1{E_;-wQBjFgQUm6YUE0t!HHP`zLqsia?rS!0!<7LjzSkgjebXC~7&*hQx{xz5zZ} zZ|w zCJO?wQdLnjQlq-ZV9b8V6vbnW+)}ajAKa@@VmcNDyFfZFrthG4<`33xk$Y#{q5-{2 zLu4@W*vriS7`=r6kP$bfmNh`O=0t<^b^_5~yvAW{@6E5KOd^qz2T|t%2W5T6ely`S z6*+IaHv}fjF@PG29gECrb98ch=NE^e+skk1VQ?25kKA5-6cDDu#dxq8aEIAw)mH)x zwy}J>(SXC!=WF|~cs&C|fET|E^x2h!AFP1%yLikszrBZ;BpA`9AP0fE zxGWHmOm>@6&#EFhB~1a7dOem#DwY0PXq}G(#V{>Z@u3Xt2V4z~83(x@sG*7wXWyX| zCP{UB$cP@~N9MXp4wySZ!+#9*NwM-8d;hETY=L54QS7CiUxBaY&O|gFH4w4EDQ8aC zeY9DbmPyZ`YxVE zYDu@7#xvTNMUsNw76h;c>S2e6^>($ecnhe7=#6LF0cs_D+@Mj3a|-l1 zdJG>0iy^k9M$-EQ@!IkH5Hlz3an4QIBx)6>JVx!9vp+U$ZhAOu{c$9hI} z9cAdPuT`KuGO2nKD0h+@`ORf!fC45c_{#eEDN6RpeT(nuwjrK}&9w_`yQg&~sDI7GEr_>VRh_Q0B>i@>`A7N*$25U00wu;lX{OWdK-vTagI2Bhr;1*bHC)Igh357_16+*_Wavx zg&swGP=nAz#eU^(3wa#w*V-o(?bh4+A)ACHmn5Jgc5W11sE=r!)5{I&SQWXCqCc@S zQBud~u#UwAL~oUq3i@63L8eYXzUU9Jmbf5yH+QySFgs0tiI3&vzOf0`4EF_7?&l{E zE?51&T(wT+o$ztjM{M3Vxu2UP_Boo!#dFBgpk}QsLwdV!OxD-!_8HBX@IP|J9Jg^* z+hwGHe0vKyGW`cCCqF19sU+6@$ZIp8az}yVonN#cXSno>$we74i!FZF9!=Lq&3!g+ zt78Mn=+^<%b0?R}pl5nOC#_?hm1Mpft;UK+Ns;noaZu&Xoe1BBbS>eHe-N&OMp=4a z?%F_g^-E+(^s7oY;ENeb7|*RYB#KzGt5#&{)Nfy=Dsd8SPFdPRHVqqZT_0ObNe4j_ zFPuztnHcG2WAYLZe*9Ye=A&g?FOt%pCi-qP6CLiqLJR5*qEhK!{Z|@eT;aGN#HwVI zqJP__ysJbSV%u_J>kP*06s9d%8d&@6M)_gY63gM85|1LU_33DK4#)9-sP&%~>p9%5 z7!6J-K5R0bE$ZP>ye)G zm@yQsOMOC`9+QRqFrWm?sEedQ?nusBbgAVEGVeZu3IxTv@W_3MPX#{R-0dHIRSQ`& zpv<=Gi^zH0N*P+8@Aczd(2P;H{u3NtcgLdqNp%peL9T~>D}};GT}&9Qynm`e_$6+2 zJm^QPn!)T^3$Q?3)a%*--%}UOEZSOG*@9O?yMbl!Yt9YYlwS!+k})W)_}8*`mYxBM z4Pw-HV07xE_q#x4*&vOWogU(jCaqOQLCR;oXcdb4r}wfdEmwvX7A%Y*dIx!H37)5h zg^f9{yDuaw#Hk^U95*O9Ebk!^ZI0i4MMa1uTsS{pGzKY>>q(ru7cbe%@z9qv4M>!} zKXHh#sJZr9?Zd+cfpI)ut3FkL zC>_^1XIyEvJt=A9DF-&m6ExtAjPxKQ4w;Ou z>hD~EKa;C|dc-|uvArzMTq>?d8tvsgQqgLJNrv#2Y03=;uRt2>r>g0F5!D{qu|2V6 zndGq_!S15)v;FdiEh|TpHFw{i@DMK*O1-f!J*o*c@HHMLvV3y*3xfC6oJH4+yNOOkow-ntgGKg_y3{lw!4j3N zS~7f19#W__Ym$(J0w%xJu!*XYj?2$?$w1xB2iB%>b>@Q>6KFZ$2a;(mlI2pZy&td( z)qZB;s&aUHMWUF8B#VaT*Siu7C%#$KkeW&clJzN*{xtQ8x|omn&xjNGtV3VA*dnBQ zRDdyZzlbGAr*h5pWPSN3tx6T(#|*MsM-N3zsQmH*UEBT6CG+Sc<{~QGu866a3n*i% z(a%~!1=Hv8hfIP?PNxXtu4-D%-TO?9W}oz$8+u#qVY7OS#*nDlx#qV5EiI1oz#G!1 zD9iO(?u2HKjDX_}J-5#gQX#kFd)S1(vv>7oyAvAghN#n8tDPM`Cj_EI{qN3a1N(Ki zkh@wGVt>oK6*yT#jCP~9kzua0Zc`m4AzGJM%)PI{y?|c%0fiKt6J-=A;g_f#^jHh} zHgR2x)~>)aaq8o9IbVrkq1F%iWic0Ia)CW-ez@AS=5BmX-m&$aymUO3c0=nld659r z3uxIB_8cyyY2Ihw)ZKvrJ=H8Fhojc#{hCD;WagrPj*hMXK8aM}6J7w>Blv|_BUrtNO7_9KVt01RVsF#u7IunO|6`Oo@z8}+c7&2td8bNklNewuk2MB#Fn*9*#baRFt^AtjonHe`(? zOUW$DBP3mbz`nIjCHXVUz7`!;FR-d>B|UEuU=jD5UGfXZ2YxZ)@lWgm**gpCC3W!ftMgq55Z83{yW&@EwU2;^P1^@ z)3W|AwD!N%W&A}RAUo2|Br1xP6`0*;FM~FB#hMh0tpMO<*}bP&mg(gU#8;)wjh6iP zsQ>~xo!gMx@fM5`FnzbCZE2Zb;CaKX^tWom|JLmNSI1-NUe1-L56zQ6H<^Tbi0Qy` zj0^2@Wa{#gHr20@AQkrwDn?=EE?HRaiR#=StSby6M^cutiZXxu+&#ZYRsaal4q>eA zjWB}xA_>Adh`-exQoG=VaoBh>@44hP2$Ix>Nt8}xMocMp-;|UD9vImRKKlAVCUV=O zMpdxF*0@kpI)w&})h~;C3JG2-EybrAyZ`=nwp&45c4n0@~lJN`!|xz zo0iaX5hs^ohZ0jfLR-+0*^}-uFM~V4*YKOV#)UwHeKVnJwftBVbXjzBv1dppjVCI< z)DYei(tR^OI9` zG*S#inAY|)!-Vq0O_&49OuF;_ps@>gm=(MR!QRKB7LHJ`3766c*JF)yj3efj%8ivg zw?@|wFfIEtQt-Ui{vmGS(0$L%za|A-ndAlhT1{ZQ-^2EBc zV;5qdI(CaCwh=GRchiyYKe|zjT*Nr+655-^+E(6TVj@g0>lglAOy&tNeC{ zPkEC@{dZUV)Ja}8cfT|{#&kk#1u`M8$*ahZY7zfpoBSoob4l9h5WO|Jk00bP9 zL@TXhYjK{GKct=HoHOQ<(C=uQk9wJfy@3wCrQ;+5M;Wd;W)Bx+-|c&9ZL?&u;u=n< ztxhc%b@HRvXa-x6B3L-Ua|g=pwihT54!>TE^Ax0&RQo25$4(W&<&@>C?N4r6T^}Ab@y|M z$8*ndJiA_-6^j8ISt!+j^&@q-6D8RvnyH;Nu;68oY8EpD*;PP8HEyVqE4yeOc)a^8}kmCP>U+}l;~41w)-LI}?7 zDlKf*ctqF^I1Q$m)P8Px8aupC19{etrEz*`552E9b4FW1tVIW5M~SvImG`H$oqm`f zV;XJTOj%Ht$z(0GUhJBlZ@!9&)P**^Rnv3qPG2he zKB5jCYg<*8!ESnRT7h%4oo2g!t2%Yxb3)kl{jeMRDyZX7=zC68@Qak#ux3Eb@jpvV z0tL51@k~sWoQ!M)4LSJ$i&P}$=?N-6bmxyn>n0Xz8fWTXDi|7Yt{89}(Ow|cn2+nL zg7OnaLfM51vb6JT@{N-Ht`Q%;&mRe}%0R_R1=Rka>6PshyjT zN8VG=-EOp?%mJqHm;Z531?G#fp=(H)(%g9J*Wt1|v1zAVjD{$xnmAvR5?nfQ7D3xG zj?##!`x4KJjSD00sGIZbymz2)mB4zZp%xTyQPj5KVt%Vgef@SW@f7b~^hCjf*WEpR zz)N_y-HNWOk`i`)cX+#@R^&})Q|i1a3CZ$&?-&~0*La{JQU`1u>rd(vQ)(t%Q|Mt0 z+{!LI0pq2(no}p^Lsh=?$W(9V((N=Y0tJY>3wCZb+YdEm@0J7V4u+EQHH%KLMm5Vj zlsD&{9%^8wN@Y(ubd?;c_PhMc;iO-n92cNMmZg_41n!`8M1D4m^6 zTzfZkUvJ1s4h3!)m#b?H`xC6m#3Pf#h?jWAt%u)M3mNg4 z!+h|y?i(GV>pq@7ml%&4hM#nP3QS6T?Ro>Nf}uT^8%Zdwy)z|!FZJSUlT_eq+waDd z&laIO(& zLyjpAr6)$83z(8t-^;4fj3v9-_%qxcv3dQxlF(VkeU?kdi*Hto&OAnzQr6<#x7P*= zG5E#otB-?zKOY8i$^a}iTz)2fhlk=CxDpAxA!u8(C~!usda23yjO&#LbZz;{I3@l` zb}~@I`RB?R;DLr5?cnaHS13su@lxS+)qYk#Yu-iSHS^r#J-md9+eY?Idy&J=H`zv) z&v?(R^2&aJhNZUqrP!?v!!C{QD4iD#l48Y4$yN=S;kIlvf9zS*yuK+=X$g~8M$aA| zUA{C-oIa-DpZnuo{mu+9FO8e;+J|f1QNQBXwj}Gn9FzYz!vE|lt?>}h9cO_95;H4p z(d%g3Y1XLQj>zX$*RUzAF#k`jVPPo$o#T@3xAw+)bw33o)4vDO{#QVmU+6I=Oa7p( zim4_=pexHv`1YmMQF^2O1Q*p}wzp!LdCiY2%u|`Ed&&1uVqy&igu%nz9b`qpo zgDtn?%tJw&Df!LyB*-;9;r*d)6gN2^rQ=dA_NQ%CV#z#)FO!ffO$&?}CgvGyA?|$H z{MK}U3A~rS^}B41SRQK0LA|o<9tNL-0p<2HXQHw(8kN{52y~ltbe%)9rwUd}B2Ym! z23&(*xVJbw)G9CsY|48jUT=i|x8lw{s);iT;OV-SZn2=-O0d$Pg0#x3E%Jy8S{6_c z@t_D2LU<{n2@nWIAS6%`V?{yX1m#hp3yKIKC?<#@yp$H?RS6hE2rt19lRyxYAP}EUG9s;MZ(YZH zZ$&eZ)!L?t{!TwgU*o>88oo)4xb=o}xX_C*MJYH^F?8rbi!-aY@@S5^NRrH+W5Zx< zT?yJRsHzJ0j08sD`F?j7;gM~w@~wjl z0}{W7XD2NTxSfNlq4~_r6C)NYI^Kh^({%_+`xQYCLI`UAxeh_sj-W*Om`%Z08$YjX zKkS{hn@n;474x6;f2?(cs-w0;hF4nrK*%=KX>Zezuy3AvSp>Q3XSJ`7ADgU#JKwdW zRj$pBEs%0A@L4_Z^}PW1NY?KDBWFsN?FavigN+*LEVXC1zRqt)ZS{2IDNo-65N~I9 zs+NO|g@5f;`@IJ@>b`HebJ3Z};f=jr9DZ(Tp8W*hkqKWCFK`^yML=yt^(cT;Hc@Yb z{@U}}W+lYOqL@Lj=TAp7N*(O;+uOrupPU%fDcDR%zez2H7-dn3@*cPLz$8yV2XUsf zpd20L`TZT`F#!gE(MBDLB|kkQ!KB(pZ?gqfEr{0u=rV!8nwvyxqM=TMJ(oMfk#}}> z9)B!4$a%h>!|Tj3_>2{~(`=*XSzdI{L}E$Q)?O2rn5_{#0)Ce_w^*{(G1$tuE;=kp zEkc_j0J6IS(+zMTzku}BOivknXYxbdUH>BtBksL@_xipT$ZUxN-Gh89psoQC0MXfH z_cGw(kogMFA&DzISMr@&iOE)I=m-&NH7rz5SCzZ4grA8NO>bY{T$1btKiYx)6IrcB zT|%dx6?pplZ96=fz_IL!vFl5&aAXH?^36s3!Be$mcAD2eyy|cC&=vr)(B+`4_IzRF zdiG@GrR~68&_gBpy}>g+xFfW)v-HECokKAXCuzgqsR|NCM922lZ`P2oj=jgqA3WZb z`;sRzr+FWY*_0OJn5=2SUIS?{Yqvlqd$s5Lu2UY)SMqOB2Eee{Df>ttl~64&Smx%s zPYJ*G;SRTXbNHW@ltD9a#xXem+2GtTm~S4oUtlOAhVOwI{w|K_ZrSh+Pm-q~3BaGn zYo%lyfz8cF??a5pfl<+SM9zo|#8#CsK^)N_9F#wVh4TC?f=&^oryc?;<~Krnfbcs| z)9?K<(M%q*i+6?SVTx(*%Wt356#qtO>-eHAK#aOPvK$8`>@uG5+?PPCx-S>@p{7qw z)cg^I23E%LC_~^?(eKSTyy3%q%ksWEy|^>Ip9aLB%K-#JT;D4_!+pfa8T7Mb_+W$k zpLuSjd08Ln8m||YAI9G4KYcr};_YC?8r;Tu{_R5lfWRkE+pAaF4qn$Cv%{+Dlja$e zAyWrj!=?80nxAdE^zFcqV<=hk$L2s%?3n1EQbw(ILO3#<^z zV-IbR!y&Y5S+;oc0u?%DUj{CU%FMN3hQS7G{_hX|FS?oVmUZ|YXJzk>O()966?yJ_ zn^&{Wrj{y>xUSP6c4TuToolN*O(uSH7C#m>{Ycy}v^em*sNqY_f^!Jx1~2=wF0Q(A zc4_1NJgq;rx(eu#>L)8Ed`uYB94YHnc#g^LYqi76{swDi2o;YV3I*62Bst6>X%UW$ z!zWT31Vt2Cln*F^Dzxv>gWWt2L3UG2oV;#GXvoYi8VMddGt#^Yc~yX}uXbg+}TbZzb(HNaq|L9x@*0MR{`-Y(0aXMv3Hq_OZw zf)h1+P3(KHP!6O9M*SU)F?%$b^~z^sz|DSxt3V?f%cd&O_0t_MdoXCDc_Z%inGOkf zT+Ojm?c$sH3_(UiXLiW`NZU`irSR^vJ&2NXqIA$QcOkbi*T458&@=oujBvVba1 zF!@yU~5?M`a%SCcJ!|~EwaHlNvSc*Ix(I{@nK=9HX;x)>h_zA_l z!xpY;Gd25iHq+MS1^s2yC@YRo)FnAFrozQ#`EFKP2(m!3=4z-?1q@&D7@x4YzPtJ3 zq$HYRC%+hUw%bC_Q2bQb*tTa$<=85fhfGYG>E&R{2s06Is=@YiqfeM`)gh0a#$_yl ziBr5wtaXtzh4~=KEv^2RG`6WZHE&gWo5Pk0wqYIqVSqC^bhJ1%w-$r+eRzCB!An_< zrgf8{c(RtHo)eB!BCntCD2(D1n}Gm5^hab9W2%MVK1t9nf*UThj2d(Vr>GJl37bC0 zAn6~c>l-6>Uwy(XvOOo!-(zj`tx3W}%DT&0@d`H#LRL#w;4uJ;HyGd@Q#5C!tNS_z zFIK*AIqpzKx2~eh(=f(EgweLzH!p=|fGoONT86KPkt3c2(w)@bkoIt7;?%xb|gyMDy^7^;YfDLUFjI1>9j zwBu@+URFxnyYOpzhE}GW@1(JApp@p_4^#S8n>E<%@}FGh8AVPx=5WHSEBLTA#3_DY zUOIGHPR;_x&p{{?S8eGkq*`d+1;@Zu-5 zj))e?@wf)FRr4)vUpDd|9M50hT@xo<0twLBHy|d8ao^X#DupY@0+P990rJ!oCtEei zB0I%e9>;yhmM%Prc1u3Wix5&}JA_c$baoze6)~fAnAhrh{y?pTUi@h2o3W#c7_IX9 z!*vqnc|_nhB0jUU!C}{(OU@k&$)9hyx5Ko$CCLNDTNY}eCUkCUVy2lmV2a8$PEo

8QX=~Mo=bE&Q#bx?h1QtawQKSKuI9dOM>K@0Ca({}< z#ocdnjq7^uv3jiJhrGqLkZc%1PM9W}_)*Cm_rs3E|{FjJibi{A5JT zgi|m}8xrM)OB)7oBcw%Jcms&Ss||3F{fOy&ebcrgI08MfwJiHuO6^iE54El6!^o?v=0ZggRe3c%8Qs tg0z`*3`LpVtaE0;6k+ei&FGDCtzJYT-RwT?1?1g_dAj?!Rk?