From 676f3ef7724001c990e1e8387d6cfb78d1ce445c Mon Sep 17 00:00:00 2001 From: YuXifeng <2860280851@qq.com> Date: Mon, 10 Mar 2025 09:36:03 +0800 Subject: [PATCH] =?UTF-8?q?=E5=A2=9E=E5=8A=A0setupapi=EF=BC=8Cwindows?= =?UTF-8?q?=E7=8E=AF=E5=A2=83=E4=B8=8B=E8=83=BD=E5=A4=9F=E5=AF=B9=E6=89=93?= =?UTF-8?q?=E5=8D=B0=E6=9C=BA=E8=AE=BE=E5=A4=87=E8=BF=9B=E8=A1=8C=E8=AF=BB?= =?UTF-8?q?=E5=86=99?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- APP-Test1.pro | 13 +- APP-Test1.pro.user | 351 ++ form_seting.cpp | 14 + form_seting.h | 22 + form_seting.ui | 223 ++ form_usb.cpp | 103 + form_usb.h | 37 + form_usb.ui | 82 + main.cpp | 15 +- mainwindow.cpp | 45 +- mainwindow.h | 6 +- setupapi-x64/SETUPAPI.H | 7531 +++++++++++++++++++++++++++++++++++++ setupapi-x64/hid.lib | Bin 0 -> 11336 bytes setupapi-x64/hidpi.h | 1829 +++++++++ setupapi-x64/hidsdi.h | 494 +++ setupapi-x64/hidusage.h | 292 ++ setupapi-x64/setupapi.dll | Bin 0 -> 4518336 bytes setupapi-x64/setupapi.lib | Bin 0 -> 141068 bytes usb.cpp | 59 - usb.h | 15 - usb_interface.cpp | 235 ++ usb_interface.h | 31 + 22 files changed, 11303 insertions(+), 94 deletions(-) create mode 100644 APP-Test1.pro.user create mode 100644 form_seting.cpp create mode 100644 form_seting.h create mode 100644 form_seting.ui create mode 100644 form_usb.cpp create mode 100644 form_usb.h create mode 100644 form_usb.ui create mode 100644 setupapi-x64/SETUPAPI.H create mode 100644 setupapi-x64/hid.lib create mode 100644 setupapi-x64/hidpi.h create mode 100644 setupapi-x64/hidsdi.h create mode 100644 setupapi-x64/hidusage.h create mode 100644 setupapi-x64/setupapi.dll create mode 100644 setupapi-x64/setupapi.lib delete mode 100644 usb.cpp delete mode 100644 usb.h create mode 100644 usb_interface.cpp create mode 100644 usb_interface.h diff --git a/APP-Test1.pro b/APP-Test1.pro index 27b307b..a3a4905 100644 --- a/APP-Test1.pro +++ b/APP-Test1.pro @@ -9,19 +9,26 @@ CONFIG += c++17 #DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0 SOURCES += \ + form_seting.cpp \ + form_usb.cpp \ main.cpp \ mainwindow.cpp \ - usb.cpp + usb_interface.cpp HEADERS += \ + form_seting.h \ + form_usb.h \ libusb.h \ mainwindow.h \ - usb.h + setupapi-x64/SETUPAPI.H \ + usb_interface.h FORMS += \ + form_seting.ui \ + form_usb.ui \ mainwindow.ui -LIBS += -L$$PWD/./ -lusb-1.0 +LIBS += -L$$PWD/./setupapi-x64/ -lsetupapi # Default rules for deployment. qnx: target.path = /tmp/$${TARGET}/bin diff --git a/APP-Test1.pro.user b/APP-Test1.pro.user new file mode 100644 index 0000000..bb2faa8 --- /dev/null +++ b/APP-Test1.pro.user @@ -0,0 +1,351 @@ + + + + + + EnvironmentId + {365fcea5-97bf-4386-8d9b-1f8d69787ebd} + + + ProjectExplorer.Project.ActiveTarget + 0 + + + ProjectExplorer.Project.EditorSettings + + true + false + true + + Cpp + + CppGlobal + + + + QmlJS + + QmlJSGlobal + + + 2 + UTF-8 + false + 4 + false + 0 + 80 + true + true + 1 + 0 + false + true + false + 2 + true + true + 0 + 8 + true + false + 1 + true + true + true + *.md, *.MD, Makefile + false + true + true + + + + ProjectExplorer.Project.PluginSettings + + + true + false + true + true + true + true + + false + + + 0 + true + + true + true + Builtin.DefaultTidyAndClazy + 11 + true + + + + true + + + + + ProjectExplorer.Project.Target.0 + + Desktop + Desktop Qt 6.8.2 MinGW 64-bit + Desktop Qt 6.8.2 MinGW 64-bit + qt.qt6.682.win64_mingw_kit + 0 + 0 + 0 + + 0 + D:\QT-APP\APP-Test1\build\Desktop_Qt_6_8_2_MinGW_64_bit-Debug + D:/QT-APP/APP-Test1/build/Desktop_Qt_6_8_2_MinGW_64_bit-Debug + + + true + QtProjectManager.QMakeBuildStep + false + + + + true + Qt4ProjectManager.MakeStep + + 2 + 构建 + 构建 + ProjectExplorer.BuildSteps.Build + + + + true + Qt4ProjectManager.MakeStep + clean + + 1 + 清除 + 清除 + ProjectExplorer.BuildSteps.Clean + + 2 + false + + false + + Debug + Qt4ProjectManager.Qt4BuildConfiguration + 2 + + + D:\QT-APP\APP-Test1\build\Desktop_Qt_6_8_2_MinGW_64_bit-Release + D:/QT-APP/APP-Test1/build/Desktop_Qt_6_8_2_MinGW_64_bit-Release + + + true + QtProjectManager.QMakeBuildStep + false + + + + true + Qt4ProjectManager.MakeStep + + 2 + 构建 + 构建 + ProjectExplorer.BuildSteps.Build + + + + true + Qt4ProjectManager.MakeStep + clean + + 1 + 清除 + 清除 + ProjectExplorer.BuildSteps.Clean + + 2 + false + + false + + Release + Qt4ProjectManager.Qt4BuildConfiguration + 0 + 0 + + + 0 + D:\QT-APP\APP-Test1\build\Desktop_Qt_6_8_2_MinGW_64_bit-Profile + D:/QT-APP/APP-Test1/build/Desktop_Qt_6_8_2_MinGW_64_bit-Profile + + + true + QtProjectManager.QMakeBuildStep + false + + + + true + Qt4ProjectManager.MakeStep + + 2 + 构建 + 构建 + ProjectExplorer.BuildSteps.Build + + + + true + Qt4ProjectManager.MakeStep + clean + + 1 + 清除 + 清除 + ProjectExplorer.BuildSteps.Clean + + 2 + false + + false + + Profile + Qt4ProjectManager.Qt4BuildConfiguration + 0 + 0 + 0 + + + 0 + D:\QT-APP\APP-Test1\build\Desktop_Qt_6_8_2_MinGW_64_bit-Debug + D:/QT-APP/APP-Test1/build/Desktop_Qt_6_8_2_MinGW_64_bit-Debug + + + true + QtProjectManager.QMakeBuildStep + false + + + + true + Qt4ProjectManager.MakeStep + + 2 + 构建 + 构建 + ProjectExplorer.BuildSteps.Build + + + + true + Qt4ProjectManager.MakeStep + clean + + 1 + 清除 + 清除 + ProjectExplorer.BuildSteps.Clean + + 2 + false + + false + + Debug2 + Qt4ProjectManager.Qt4BuildConfiguration + 2 + + + D:\QT-APP\APP-Test1\build\Desktop_Qt_6_8_2_MinGW_64_bit-Release + D:/QT-APP/APP-Test1/build/Desktop_Qt_6_8_2_MinGW_64_bit-Release + + + true + QtProjectManager.QMakeBuildStep + false + + + + true + Qt4ProjectManager.MakeStep + + 2 + 构建 + 构建 + ProjectExplorer.BuildSteps.Build + + + + true + Qt4ProjectManager.MakeStep + clean + + 1 + 清除 + 清除 + ProjectExplorer.BuildSteps.Clean + + 2 + false + + false + + Release2 + Qt4ProjectManager.Qt4BuildConfiguration + 0 + 0 + + 5 + + + 0 + 部署 + 部署 + ProjectExplorer.BuildSteps.Deploy + + 1 + + false + ProjectExplorer.DefaultDeployConfiguration + + 1 + + true + true + 0 + true + + 2 + + false + -e cpu-cycles --call-graph "dwarf,4096" -F 250 + + Qt4ProjectManager.Qt4RunConfiguration: + D:/QT-APP/APP-Test1/APP-Test1.pro + false + true + true + true + D:/QT-APP/APP-Test1/build/Desktop_Qt_6_8_2_MinGW_64_bit-Debug + + 1 + + + + ProjectExplorer.Project.TargetCount + 1 + + + ProjectExplorer.Project.Updater.FileVersion + 22 + + + Version + 22 + + diff --git a/form_seting.cpp b/form_seting.cpp new file mode 100644 index 0000000..4e6a23e --- /dev/null +++ b/form_seting.cpp @@ -0,0 +1,14 @@ +#include "form_seting.h" +#include "ui_form_seting.h" + +Form_Seting::Form_Seting(QWidget *parent) + : QDialog(parent) + , ui(new Ui::Form_Seting) +{ + ui->setupUi(this); +} + +Form_Seting::~Form_Seting() +{ + delete ui; +} diff --git a/form_seting.h b/form_seting.h new file mode 100644 index 0000000..b67ffdb --- /dev/null +++ b/form_seting.h @@ -0,0 +1,22 @@ +#ifndef FORM_SETING_H +#define FORM_SETING_H + +#include + +namespace Ui { +class Form_Seting; +} + +class Form_Seting : public QDialog +{ + Q_OBJECT + +public: + explicit Form_Seting(QWidget *parent = nullptr); + ~Form_Seting(); + +private: + Ui::Form_Seting *ui; +}; + +#endif // FORM_SETING_H diff --git a/form_seting.ui b/form_seting.ui new file mode 100644 index 0000000..780673e --- /dev/null +++ b/form_seting.ui @@ -0,0 +1,223 @@ + + + Form_Seting + + + + 0 + 0 + 713 + 467 + + + + Seting + + + + + + + + 0 + + + + WIFI-蓝牙 + + + + + + + + WIFI + + + + + + + + SSID: + + + + + + + + + + PASSWORD: + + + + + + + + + + STA/AP: + + + + + + + + + + + + + + + 蓝牙 + + + + + + + + Name: + + + + + + + + + + Qt::Orientation::Horizontal + + + + 40 + 20 + + + + + + + + + + + + + + + Qt::Orientation::Horizontal + + + + 40 + 20 + + + + + + + + + 16 + + + + 设置 + + + + + + + + + + + + 本机 + + + + + + 本机信息 + + + + + + + + + + + + + Qt::Orientation::Vertical + + + + 20 + 40 + + + + + + + + + 24 + + + + 读取 + + + + + + + + + + + + + + + + + + + + + + + Qt::Orientation::Horizontal + + + + 40 + 20 + + + + + + + + + + + + + diff --git a/form_usb.cpp b/form_usb.cpp new file mode 100644 index 0000000..238cea6 --- /dev/null +++ b/form_usb.cpp @@ -0,0 +1,103 @@ +#include "form_usb.h" +#include "ui_form_usb.h" +#include +#include +#include +#include "form_seting.h" +#include "qmessagebox.h" + +Form_usb::Form_usb(QWidget *parent) + : QWidget(parent) + , ui(new Ui::Form_usb) +{ + ui->setupUi(this); + this->winId();//必须,不然nativeEvent不触发 + // myusb.hello(); + // QStringList devices = myusb.listUsbDevices(LIBUSB_CLASS_PRINTER); + // for (const QString &device : devices) { + // ui->textEdit->append(device); + // } + + connect(this, &Form_usb::usbDeviceChanged, this, &Form_usb::onUsbDeviceChanged); +} + +Form_usb::~Form_usb() +{ + delete ui; +} + +bool Form_usb::nativeEvent(const QByteArray &eventType, void *message, qintptr *result) { + Q_UNUSED(eventType) + Q_UNUSED(result) + + MSG *msg = static_cast(message); + if (msg->message == WM_DEVICECHANGE) { + if (msg->wParam == DBT_DEVICEARRIVAL) { + qDebug() << "USB Device Inserted!"; + ui->textEdit->append("USB Device Inserted!"); + emit usbDeviceChanged(true); // 发送信号 + } else if (msg->wParam == DBT_DEVICEREMOVECOMPLETE) { + qDebug() << "USB Device Removed!"; + ui->textEdit->append("USB Device Removed!"); + } + } + return QWidget::nativeEvent(eventType, message, result); +} + + +void Form_usb::on_pushButton_clicked() +{ + QMessageBox::information(this, "USB打印机", "连接成功"); + emit usbDeviceChanged(true); // 发送信号 +} + +void Form_usb::onUsbDeviceChanged(bool inserted) { + if (inserted) { + qDebug() << "USB Device Inserted!"; + } else { + qDebug() << "USB Device Removed!"; + } + QTimer::singleShot(5000, this, [this]() { + qDebug() << "2 秒后执行的任务"; + ui->textEdit->clear(); + ui->textEdit->append("USB Device Inserted!"); + + // if(myusb.ctx == nullptr) { + // ui->textEdit->append("myusb.ctx = nullptr"); + // } + // libusb_device_handle *handle = libusb_open_device_with_vid_pid(myusb.ctx, 0xfe6, 0x8800); + // if (handle == nullptr) { + // qDebug() << "Failed to open device!"; + // ui->textEdit->append("Failed to open USB device!"); + // }else{ + // ui->textEdit->append("Successfully to open USB device"); + // } + if(Printer_Usb.Usb_Open(0x0fe6,0x8800) == true) + { + const char data[] = "Hello, USB Printer!"; // 一个字符串数组 + DWORD dataSize = sizeof(data); // 获取数组大小 + ui->textEdit->append(Printer_Usb.DevicePath); + ui->textEdit->append("Successfully to open USB device"); + if(Printer_Usb.Usb_Data_Send(data,dataSize) == true) + { + ui->textEdit->append("Successfully to Usb_Data_Send"); + }else{ + ui->textEdit->append("Failed to Usb_Data_Send"); + } + Printer_Usb.Usb_Close(); + }else{ + ui->textEdit->append("Failed to open USB device!"); + } + + }); + +} + +void Form_usb::on_pushButton_2_clicked() +{ + Form_Seting settingWindow(this); + settingWindow.exec(); // 使用 exec(),阻塞主窗口 +} + + + diff --git a/form_usb.h b/form_usb.h new file mode 100644 index 0000000..56aa245 --- /dev/null +++ b/form_usb.h @@ -0,0 +1,37 @@ +#ifndef FORM_USB_H +#define FORM_USB_H + +#include +#include +#include +#include "usb_interface.h" +#include "form_seting.h" +namespace Ui { +class Form_usb; +} + +class Form_usb : public QWidget +{ + Q_OBJECT +public: + explicit Form_usb(QWidget *parent = nullptr); + ~Form_usb(); + +private: + Ui::Form_usb *ui; + Usb_Interface Printer_Usb; +protected: + bool nativeEvent(const QByteArray &eventType, void *message, qintptr *result) override; + +private slots: + void on_pushButton_clicked(); + void onUsbDeviceChanged(bool inserted); // 槽函数 + void on_pushButton_2_clicked(); + + void on_pushButton_windowTitleChanged(const QString &title); + +signals: + void usbDeviceChanged(bool inserted); // 声明信号 +}; + +#endif // FORM_USB_H diff --git a/form_usb.ui b/form_usb.ui new file mode 100644 index 0000000..204230b --- /dev/null +++ b/form_usb.ui @@ -0,0 +1,82 @@ + + + Form_usb + + + + 0 + 0 + 400 + 300 + + + + Form + + + + + + + + + + USB设备: + + + + + + + + + + 连接测试 + + + + + + + + + + + + + + + + + 18 + + + + 设置 + + + + + + + Qt::Orientation::Vertical + + + + 20 + 40 + + + + + + + + + + + + + + + diff --git a/main.cpp b/main.cpp index 115a22b..caffae3 100644 --- a/main.cpp +++ b/main.cpp @@ -1,10 +1,21 @@ #include "mainwindow.h" #include +#include "form_usb.h" +#include "form_seting.h" int main(int argc, char *argv[]) { QApplication a(argc, argv); - MainWindow w; - w.show(); + // MainWindow w; + // w.show(); + + Form_usb L; + L.show(); + + // Form_Seting S; + // S.show(); + // Form_usb *usbWindow = new Form_usb(nullptr); // 设置 parent=nullptr + // usbWindow->show(); + return a.exec(); } diff --git a/mainwindow.cpp b/mainwindow.cpp index 6264198..eba6329 100644 --- a/mainwindow.cpp +++ b/mainwindow.cpp @@ -11,7 +11,8 @@ #include #include #include "usb.h" - +#include +#include MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent) @@ -19,8 +20,6 @@ MainWindow::MainWindow(QWidget *parent) { ui->setupUi(this); - myusb.hello(); - myusb.listUsbDevices(); // 创建 QStandardItemModel(表格数据模型) QStandardItemModel *model = new QStandardItemModel(3, 2); @@ -108,19 +107,20 @@ void MainWindow::on_pushButton_clicked() void MainWindow::on_pushButton_2_clicked() { // 获取当前的模型 - QStandardItemModel *model = qobject_cast(ui->tableView->model()); + // QStandardItemModel *model = qobject_cast(ui->tableView->model()); - if (model) { - // 获取当前表格的行数 - int rowCount = model->rowCount(); + // if (model) { + // // 获取当前表格的行数 + // int rowCount = model->rowCount(); - // 插入新的一行 - model->insertRow(rowCount); + // // 插入新的一行 + // model->insertRow(rowCount); - // 为新行设置单元格内容 - model->setItem(rowCount, 0, new QStandardItem("")); // 第1列 - model->setItem(rowCount, 1, new QStandardItem("")); // 第2列 - } + // // 为新行设置单元格内容 + // model->setItem(rowCount, 0, new QStandardItem("")); // 第1列 + // model->setItem(rowCount, 1, new QStandardItem("")); // 第2列 + // } + ui->lineEdit->setText("000000"); } @@ -138,3 +138,22 @@ void MainWindow::on_pushButton_3_clicked() } } +bool MainWindow::nativeEvent(const QByteArray &eventType, void *message, qintptr *result) { + Q_UNUSED(eventType) + Q_UNUSED(result) + + MSG *msg = static_cast(message); + if (msg->message == WM_DEVICECHANGE) { + if (msg->wParam == DBT_DEVICEARRIVAL) { + qDebug() << "USB Device Inserted!"; + // ui->textEdit->append("USB Device Inserted!"); + ui->lineEdit->setText("USB Device Inserted!"); + } else if (msg->wParam == DBT_DEVICEREMOVECOMPLETE) { + qDebug() << "USB Device Removed!"; + // ui->textEdit->append("USB Device Removed!"); + ui->lineEdit->setText("USB Device Removed!"); + } + } + return QWidget::nativeEvent(eventType, message, result); +} + diff --git a/mainwindow.h b/mainwindow.h index 8f114de..dd14cad 100644 --- a/mainwindow.h +++ b/mainwindow.h @@ -2,7 +2,7 @@ #define MAINWINDOW_H #include -#include "usb.h" +#include QT_BEGIN_NAMESPACE namespace Ui { class MainWindow; @@ -26,6 +26,8 @@ private slots: private: Ui::MainWindow *ui; - usb myusb; // ✅ 在 MainWindow 类中定义 USB 对象 +protected: + virtual bool nativeEvent(const QByteArray &eventType, void *message, qintptr *result) override; + }; #endif // MAINWINDOW_H diff --git a/setupapi-x64/SETUPAPI.H b/setupapi-x64/SETUPAPI.H new file mode 100644 index 0000000..09e038f --- /dev/null +++ b/setupapi-x64/SETUPAPI.H @@ -0,0 +1,7531 @@ +/*++ + +Copyright (c) Microsoft Corporation. All rights reserved. + +Module Name: + + setupapi.h + +Abstract: + + Public header file for Windows NT Setup and Device Installer services Dll. + +--*/ + +#ifndef _INC_SETUPAPI +#define _INC_SETUPAPI + +#if _MSC_VER > 1000 +#pragma once +#endif +#if defined (_MSC_VER) && (_MSC_VER >= 1200) +#pragma warning(push) +#pragma warning(disable:4201) /* nonstandard extension used : nameless struct/union */ +#endif + +// +// Define API decoration for direct importing of DLL references. +// +#if !defined(_SETUPAPI_) +#define WINSETUPAPI DECLSPEC_IMPORT +#else +#define WINSETUPAPI +#endif + +// +// determine version of setupapi based on _WIN32_WINDOWS and _WIN32_WINNT +// +// NT4 version of setupapi (_WIN32_WINNT_NT4) is earliest, and installed onto Win95 by IE. +// Win2k version of setupapi (_WIN32_WINNT_WIN2K) also shipped in WinME +// we'll use "0x0410" to indicate version of setupapi shipped with Win98 +// +#ifndef _SETUPAPI_VER +#if defined(_WIN32_WINNT) && (!defined(_WIN32_WINDOWS) || (_WIN32_WINNT < _WIN32_WINDOWS)) +#define _SETUPAPI_VER _WIN32_WINNT // SetupAPI version follows Windows NT version +#elif defined(_WIN32_WINDOWS) +#if _WIN32_WINDOWS >= 0x0490 +#define _SETUPAPI_VER _WIN32_WINNT_WIN2K // WinME uses same version of SetupAPI as Win2k +#elif _WIN32_WINDOWS >= 0x0410 +#define _SETUPAPI_VER 0x0410 // Indicates version of SetupAPI shipped with Win98 +#else +#define _SETUPAPI_VER _WIN32_WINNT_NT4 // Earliest SetupAPI version +#endif // _WIN32_WINDOWS +#else // _WIN32_WINNT/_WIN32_WINDOWS +#define _SETUPAPI_VER _WIN32_WINNT_WINXP +#endif // _WIN32_WINNT/_WIN32_WINDOWS +#endif // !_SETUPAPI_VER + +#ifndef __LPGUID_DEFINED__ +#define __LPGUID_DEFINED__ +typedef GUID *LPGUID; +#endif + +// +// Include spapidef.h for basic definitions and flags +// +#include + +// +// Include commctrl.h for our use of HIMAGELIST and wizard support. +// +#include + +// +// Include devpropdef.h for our use of DEVPROPERTYKEY and DEVPROPTYPE. +// +#include + +#ifdef _WIN64 +#include // Assume 8-byte (64-bit) packing throughout +#else +#include // Assume byte packing throughout (32-bit processor) +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// +// Define maximum string length constants +// +#define LINE_LEN 256 // Windows 9x-compatible maximum for + // displayable strings coming from a + // device INF. +#define MAX_INF_STRING_LENGTH 4096 // Actual maximum size of an INF string + // (including string substitutions). +#define MAX_INF_SECTION_NAME_LENGTH 255 // For Windows 9x compatibility, INF + // section names should be constrained + // to 32 characters. + +#define MAX_TITLE_LEN 60 +#define MAX_INSTRUCTION_LEN 256 +#define MAX_LABEL_LEN 30 +#define MAX_SERVICE_NAME_LEN 256 +#define MAX_SUBTITLE_LEN 256 + +// +// Define maximum length of a machine name in the format expected by ConfigMgr32 +// CM_Connect_Machine (i.e., "\\\\MachineName\0"). +// +#define SP_MAX_MACHINENAME_LENGTH (MAX_PATH + 3) + +// +// Define type for reference to loaded inf file +// +typedef PVOID HINF; + +// +// Inf context structure. Applications must not interpret or +// overwrite values in these structures. +// +typedef struct _INFCONTEXT { + PVOID Inf; + PVOID CurrentInf; + UINT Section; + UINT Line; +} INFCONTEXT, *PINFCONTEXT; + +// +// Inf file information structure. +// +typedef struct _SP_INF_INFORMATION { + DWORD InfStyle; + DWORD InfCount; + BYTE VersionData[ANYSIZE_ARRAY]; +} SP_INF_INFORMATION, *PSP_INF_INFORMATION; + +// +// Define structure for passing alternate platform info into +// SetupSetFileQueueAlternatePlatform and SetupQueryInfOriginalFileInformation. +// +typedef struct _SP_ALTPLATFORM_INFO_V2 { + DWORD cbSize; + // + // platform to use (VER_PLATFORM_WIN32_WINDOWS or VER_PLATFORM_WIN32_NT) + // + DWORD Platform; + // + // major and minor version numbers to use + // + DWORD MajorVersion; + DWORD MinorVersion; + // + // processor architecture to use (PROCESSOR_ARCHITECTURE_INTEL, + // PROCESSOR_ARCHITECTURE_AMD64, or PROCESSOR_ARCHITECTURE_IA64. + // + WORD ProcessorArchitecture; + + union { + WORD Reserved; // for compatibility with V1 structure + WORD Flags; // indicates validity of non V1 fields + } DUMMYUNIONNAME; + + // + // specify SP_ALTPLATFORM_FLAGS_VERSION_RANGE in Flags + // to use FirstValidatedMajorVersion and FirstValidatedMinorVersion + // + // Major and minor versions of the oldest previous OS for which this + // package's digital signature may be considered valid. For example, say + // the alternate platform is VER_PLATFORM_WIN32_NT, version 5.1. However, + // it is wished that driver packages signed with a 5.0 osattr also be + // considered valid. In this case, you'd have a MajorVersion/MinorVersion + // of 5.1, and a FirstValidatedMajorVersion/FirstValidatedMinorVersion of + // 5.0. To validate packages signed for any previous OS release, specify + // 0 for these fields. To only validate against the target alternate + // platform, specify the same values as those in the MajorVersion and + // MinorVersion fields. + // + DWORD FirstValidatedMajorVersion; + DWORD FirstValidatedMinorVersion; + +} SP_ALTPLATFORM_INFO_V2, *PSP_ALTPLATFORM_INFO_V2; + +typedef struct _SP_ALTPLATFORM_INFO_V1 { + DWORD cbSize; + // + // platform to use (VER_PLATFORM_WIN32_WINDOWS or VER_PLATFORM_WIN32_NT) + // + DWORD Platform; + // + // major and minor version numbers to use + // + DWORD MajorVersion; + DWORD MinorVersion; + // + // processor architecture to use (PROCESSOR_ARCHITECTURE_INTEL, + // PROCESSOR_ARCHITECTURE_AMD64, or PROCESSOR_ARCHITECTURE_IA64. + // + WORD ProcessorArchitecture; + + WORD Reserved; // must be zero. +} SP_ALTPLATFORM_INFO_V1, *PSP_ALTPLATFORM_INFO_V1; + +#if USE_SP_ALTPLATFORM_INFO_V1 || (_SETUPAPI_VER < _WIN32_WINNT_WINXP) // use version 1 altplatform info data structure + +typedef SP_ALTPLATFORM_INFO_V1 SP_ALTPLATFORM_INFO; +typedef PSP_ALTPLATFORM_INFO_V1 PSP_ALTPLATFORM_INFO; + +#else // use version 2 altplatform info data structure + +typedef SP_ALTPLATFORM_INFO_V2 SP_ALTPLATFORM_INFO; +typedef PSP_ALTPLATFORM_INFO_V2 PSP_ALTPLATFORM_INFO; + +// +// the following flags are available to SP_ALTPLATFORM_INFO_V2 +// +#define SP_ALTPLATFORM_FLAGS_VERSION_RANGE (0x0001) // FirstValidatedMajor/MinorVersion + +#endif // use current version of altplatform info data structure + + +// +// Define structure that is filled in by SetupQueryInfOriginalFileInformation +// to indicate the INF's original name and the original name of the (potentially +// platform-specific) catalog file specified by that INF. +// +typedef struct _SP_ORIGINAL_FILE_INFO_A { + DWORD cbSize; + CHAR OriginalInfName[MAX_PATH]; + CHAR OriginalCatalogName[MAX_PATH]; +} SP_ORIGINAL_FILE_INFO_A, *PSP_ORIGINAL_FILE_INFO_A; + +typedef struct _SP_ORIGINAL_FILE_INFO_W { + DWORD cbSize; + WCHAR OriginalInfName[MAX_PATH]; + WCHAR OriginalCatalogName[MAX_PATH]; +} SP_ORIGINAL_FILE_INFO_W, *PSP_ORIGINAL_FILE_INFO_W; + +#ifdef UNICODE +typedef SP_ORIGINAL_FILE_INFO_W SP_ORIGINAL_FILE_INFO; +typedef PSP_ORIGINAL_FILE_INFO_W PSP_ORIGINAL_FILE_INFO; +#else +typedef SP_ORIGINAL_FILE_INFO_A SP_ORIGINAL_FILE_INFO; +typedef PSP_ORIGINAL_FILE_INFO_A PSP_ORIGINAL_FILE_INFO; +#endif + +// +// SP_INF_INFORMATION.InfStyle values +// +#define INF_STYLE_NONE 0x00000000 // unrecognized or non-existent +#define INF_STYLE_OLDNT 0x00000001 // winnt 3.x +#define INF_STYLE_WIN4 0x00000002 // Win95 + +// +// Additional InfStyle flags that may be specified when calling SetupOpenInfFile. +// +// +#define INF_STYLE_CACHE_ENABLE 0x00000010 // always cache INF, even outside of %windir%\Inf +#define INF_STYLE_CACHE_DISABLE 0x00000020 // delete cached INF information +#if _SETUPAPI_VER >= _WIN32_WINNT_WS03 +#define INF_STYLE_CACHE_IGNORE 0x00000040 // ignore any cached INF information +#endif + + +// +// Target directory specs. +// +#define DIRID_ABSOLUTE -1 // real 32-bit -1 +#define DIRID_ABSOLUTE_16BIT 0xffff // 16-bit -1 for compat w/setupx +#define DIRID_NULL 0 +#define DIRID_SRCPATH 1 +#define DIRID_WINDOWS 10 +#define DIRID_SYSTEM 11 // system32 +#define DIRID_DRIVERS 12 +#define DIRID_IOSUBSYS DIRID_DRIVERS +#define DIRID_INF 17 +#define DIRID_HELP 18 +#define DIRID_FONTS 20 +#define DIRID_VIEWERS 21 +#define DIRID_COLOR 23 +#define DIRID_APPS 24 +#define DIRID_SHARED 25 +#define DIRID_BOOT 30 + +#define DIRID_SYSTEM16 50 +#define DIRID_SPOOL 51 +#define DIRID_SPOOLDRIVERS 52 +#define DIRID_USERPROFILE 53 +#define DIRID_LOADER 54 +#define DIRID_PRINTPROCESSOR 55 + +#define DIRID_DEFAULT DIRID_SYSTEM + +// +// The following DIRIDs are for commonly-used shell "special folders". The +// complete list of such folders is contained in shlobj.h. In that headerfile, +// each folder is assigned a CSIDL_* value. The DIRID values below are created +// by taking the CSIDL value in shlobj.h and OR'ing it with 0x4000. Thus, if +// an INF needs to reference other special folders not defined below, it may +// generate one using the above mechanism, and setupapi will automatically deal +// with it and use the corresponding shell's path where appropriate. (Remember +// that DIRIDs must be specified in decimal, not hex, in an INF when used for +// string substitution.) +// +#define DIRID_COMMON_STARTMENU 16406 // All Users\Start Menu +#define DIRID_COMMON_PROGRAMS 16407 // All Users\Start Menu\Programs +#define DIRID_COMMON_STARTUP 16408 // All Users\Start Menu\Programs\Startup +#define DIRID_COMMON_DESKTOPDIRECTORY 16409 // All Users\Desktop +#define DIRID_COMMON_FAVORITES 16415 // All Users\Favorites +#define DIRID_COMMON_APPDATA 16419 // All Users\Application Data + +#define DIRID_PROGRAM_FILES 16422 // Program Files +#define DIRID_SYSTEM_X86 16425 // system32 for WOW +#define DIRID_PROGRAM_FILES_X86 16426 // Program Files for WOW +#define DIRID_PROGRAM_FILES_COMMON 16427 // Program Files\Common +#define DIRID_PROGRAM_FILES_COMMONX86 16428 // x86 Program Files\Common for WOW + +#define DIRID_COMMON_TEMPLATES 16429 // All Users\Templates +#define DIRID_COMMON_DOCUMENTS 16430 // All Users\Documents + + +// +// First user-definable dirid. See SetupSetDirectoryId(). +// +#define DIRID_USER 0x8000 + + +// +// Setup callback notification routine type +// +typedef UINT (CALLBACK* PSP_FILE_CALLBACK_A)( + IN PVOID Context, + IN UINT Notification, + IN UINT_PTR Param1, + IN UINT_PTR Param2 + ); + +typedef UINT (CALLBACK* PSP_FILE_CALLBACK_W)( + IN PVOID Context, + IN UINT Notification, + IN UINT_PTR Param1, + IN UINT_PTR Param2 + ); + +#ifdef UNICODE +#define PSP_FILE_CALLBACK PSP_FILE_CALLBACK_W +#else +#define PSP_FILE_CALLBACK PSP_FILE_CALLBACK_A +#endif + + +// +// Operation/queue start/end notification. These are ordinal values. +// +#define SPFILENOTIFY_STARTQUEUE 0x00000001 +#define SPFILENOTIFY_ENDQUEUE 0x00000002 +#define SPFILENOTIFY_STARTSUBQUEUE 0x00000003 +#define SPFILENOTIFY_ENDSUBQUEUE 0x00000004 +#define SPFILENOTIFY_STARTDELETE 0x00000005 +#define SPFILENOTIFY_ENDDELETE 0x00000006 +#define SPFILENOTIFY_DELETEERROR 0x00000007 +#define SPFILENOTIFY_STARTRENAME 0x00000008 +#define SPFILENOTIFY_ENDRENAME 0x00000009 +#define SPFILENOTIFY_RENAMEERROR 0x0000000a +#define SPFILENOTIFY_STARTCOPY 0x0000000b +#define SPFILENOTIFY_ENDCOPY 0x0000000c +#define SPFILENOTIFY_COPYERROR 0x0000000d +#define SPFILENOTIFY_NEEDMEDIA 0x0000000e +#define SPFILENOTIFY_QUEUESCAN 0x0000000f +// +// These are used with SetupIterateCabinet(). +// +#define SPFILENOTIFY_CABINETINFO 0x00000010 +#define SPFILENOTIFY_FILEINCABINET 0x00000011 +#define SPFILENOTIFY_NEEDNEWCABINET 0x00000012 +#define SPFILENOTIFY_FILEEXTRACTED 0x00000013 +#define SPFILENOTIFY_FILEOPDELAYED 0x00000014 +// +// These are used for backup operations +// +#define SPFILENOTIFY_STARTBACKUP 0x00000015 +#define SPFILENOTIFY_BACKUPERROR 0x00000016 +#define SPFILENOTIFY_ENDBACKUP 0x00000017 +// +// Extended notification for SetupScanFileQueue(Flags=SPQ_SCAN_USE_CALLBACKEX) +// +#define SPFILENOTIFY_QUEUESCAN_EX 0x00000018 + +#define SPFILENOTIFY_STARTREGISTRATION 0x00000019 +#define SPFILENOTIFY_ENDREGISTRATION 0x00000020 + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +// +// Extended notification for SetupScanFileQueue(Flags=SPQ_SCAN_USE_CALLBACK_SIGNERINFO) +// +#define SPFILENOTIFY_QUEUESCAN_SIGNERINFO 0x00000040 + +#endif + +// +// Copy notification. These are bit flags that may be combined. +// +#define SPFILENOTIFY_LANGMISMATCH 0x00010000 +#define SPFILENOTIFY_TARGETEXISTS 0x00020000 +#define SPFILENOTIFY_TARGETNEWER 0x00040000 + +// +// File operation codes and callback outcomes. +// +#define FILEOP_COPY 0 +#define FILEOP_RENAME 1 +#define FILEOP_DELETE 2 +#define FILEOP_BACKUP 3 + +#define FILEOP_ABORT 0 +#define FILEOP_DOIT 1 +#define FILEOP_SKIP 2 +#define FILEOP_RETRY FILEOP_DOIT +#define FILEOP_NEWPATH 4 + +// +// Flags in inf copy sections +// +#define COPYFLG_WARN_IF_SKIP 0x00000001 // warn if user tries to skip file +#define COPYFLG_NOSKIP 0x00000002 // disallow skipping this file +#define COPYFLG_NOVERSIONCHECK 0x00000004 // ignore versions and overwrite target +#define COPYFLG_FORCE_FILE_IN_USE 0x00000008 // force file-in-use behavior +#define COPYFLG_NO_OVERWRITE 0x00000010 // do not copy if file exists on target +#define COPYFLG_NO_VERSION_DIALOG 0x00000020 // do not copy if target is newer +#define COPYFLG_OVERWRITE_OLDER_ONLY 0x00000040 // leave target alone if version same as source +#define COPYFLG_PROTECTED_WINDOWS_DRIVER_FILE 0x00000100 // a Windows driver file to be + // protected as other Windows system files + +#define COPYFLG_REPLACEONLY 0x00000400 // copy only if file exists on target +#define COPYFLG_NODECOMP 0x00000800 // don't attempt to decompress file; copy as-is +#define COPYFLG_REPLACE_BOOT_FILE 0x00001000 // file must be present upon reboot (i.e., it's + // needed by the loader); this flag implies a reboot +#define COPYFLG_NOPRUNE 0x00002000 // never prune this file +#define COPYFLG_IN_USE_TRY_RENAME 0x00004000 // If file in use, try to rename the target first + +// +// Flags in inf delete sections +// New flags go in high word +// +#define DELFLG_IN_USE 0x00000001 // queue in-use file for delete +#define DELFLG_IN_USE1 0x00010000 // high-word version of DELFLG_IN_USE + +// +// Source and file paths. Used when notifying queue callback +// of SPFILENOTIFY_STARTxxx, SPFILENOTIFY_ENDxxx, and SPFILENOTIFY_xxxERROR. +// +typedef struct _FILEPATHS_A { + PCSTR Target; + PCSTR Source; // not used for delete operations + UINT Win32Error; + DWORD Flags; // such as SP_COPY_NOSKIP for copy errors +} FILEPATHS_A, *PFILEPATHS_A; + +typedef struct _FILEPATHS_W { + PCWSTR Target; + PCWSTR Source; // not used for delete operations + UINT Win32Error; + DWORD Flags; // such as SP_COPY_NOSKIP for copy errors +} FILEPATHS_W, *PFILEPATHS_W; + +#ifdef UNICODE +typedef FILEPATHS_W FILEPATHS; +typedef PFILEPATHS_W PFILEPATHS; +#else +typedef FILEPATHS_A FILEPATHS; +typedef PFILEPATHS_A PFILEPATHS; +#endif + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +typedef struct _FILEPATHS_SIGNERINFO_A { + PCSTR Target; + PCSTR Source; // not used for delete operations + UINT Win32Error; + DWORD Flags; // such as SP_COPY_NOSKIP for copy errors + PCSTR DigitalSigner; + PCSTR Version; + PCSTR CatalogFile; +} FILEPATHS_SIGNERINFO_A, *PFILEPATHS_SIGNERINFO_A; + +typedef struct _FILEPATHS_SIGNERINFO_W { + PCWSTR Target; + PCWSTR Source; // not used for delete operations + UINT Win32Error; + DWORD Flags; // such as SP_COPY_NOSKIP for copy errors + PCWSTR DigitalSigner; + PCWSTR Version; + PCWSTR CatalogFile; +} FILEPATHS_SIGNERINFO_W, *PFILEPATHS_SIGNERINFO_W; + +#ifdef UNICODE +typedef FILEPATHS_SIGNERINFO_W FILEPATHS_SIGNERINFO; +typedef PFILEPATHS_SIGNERINFO_W PFILEPATHS_SIGNERINFO; +#else +typedef FILEPATHS_SIGNERINFO_A FILEPATHS_SIGNERINFO; +typedef PFILEPATHS_SIGNERINFO_A PFILEPATHS_SIGNERINFO; +#endif + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +// +// Structure used with SPFILENOTIFY_NEEDMEDIA +// +typedef struct _SOURCE_MEDIA_A { + PCSTR Reserved; + PCSTR Tagfile; // may be NULL + PCSTR Description; + // + // Pathname part and filename part of source file + // that caused us to need the media. + // + PCSTR SourcePath; + PCSTR SourceFile; + DWORD Flags; // subset of SP_COPY_xxx +} SOURCE_MEDIA_A, *PSOURCE_MEDIA_A; + +typedef struct _SOURCE_MEDIA_W { + PCWSTR Reserved; + PCWSTR Tagfile; // may be NULL + PCWSTR Description; + // + // Pathname part and filename part of source file + // that caused us to need the media. + // + PCWSTR SourcePath; + PCWSTR SourceFile; + DWORD Flags; // subset of SP_COPY_xxx +} SOURCE_MEDIA_W, *PSOURCE_MEDIA_W; + +#ifdef UNICODE +typedef SOURCE_MEDIA_W SOURCE_MEDIA; +typedef PSOURCE_MEDIA_W PSOURCE_MEDIA; +#else +typedef SOURCE_MEDIA_A SOURCE_MEDIA; +typedef PSOURCE_MEDIA_A PSOURCE_MEDIA; +#endif + +// +// Structure used with SPFILENOTIFY_CABINETINFO and +// SPFILENOTIFY_NEEDNEWCABINET +// +typedef struct _CABINET_INFO_A { + PCSTR CabinetPath; + PCSTR CabinetFile; + PCSTR DiskName; + USHORT SetId; + USHORT CabinetNumber; +} CABINET_INFO_A, *PCABINET_INFO_A; + +typedef struct _CABINET_INFO_W { + PCWSTR CabinetPath; + PCWSTR CabinetFile; + PCWSTR DiskName; + USHORT SetId; + USHORT CabinetNumber; +} CABINET_INFO_W, *PCABINET_INFO_W; + +#ifdef UNICODE +typedef CABINET_INFO_W CABINET_INFO; +typedef PCABINET_INFO_W PCABINET_INFO; +#else +typedef CABINET_INFO_A CABINET_INFO; +typedef PCABINET_INFO_A PCABINET_INFO; +#endif + +// +// Structure used with SPFILENOTIFY_FILEINCABINET +// +typedef struct _FILE_IN_CABINET_INFO_A { + PCSTR NameInCabinet; + DWORD FileSize; + DWORD Win32Error; + WORD DosDate; + WORD DosTime; + WORD DosAttribs; + CHAR FullTargetName[MAX_PATH]; +} FILE_IN_CABINET_INFO_A, *PFILE_IN_CABINET_INFO_A; + +typedef struct _FILE_IN_CABINET_INFO_W { + PCWSTR NameInCabinet; + DWORD FileSize; + DWORD Win32Error; + WORD DosDate; + WORD DosTime; + WORD DosAttribs; + WCHAR FullTargetName[MAX_PATH]; +} FILE_IN_CABINET_INFO_W, *PFILE_IN_CABINET_INFO_W; + +#ifdef UNICODE +typedef FILE_IN_CABINET_INFO_W FILE_IN_CABINET_INFO; +typedef PFILE_IN_CABINET_INFO_W PFILE_IN_CABINET_INFO; +#else +typedef FILE_IN_CABINET_INFO_A FILE_IN_CABINET_INFO; +typedef PFILE_IN_CABINET_INFO_A PFILE_IN_CABINET_INFO; +#endif + +// +// Structure used for SPFILENOTIFY_***REGISTRATION +// callback +// + +typedef struct _SP_REGISTER_CONTROL_STATUSA { + DWORD cbSize; + PCSTR FileName; + DWORD Win32Error; + DWORD FailureCode; +} SP_REGISTER_CONTROL_STATUSA, *PSP_REGISTER_CONTROL_STATUSA; + +typedef struct _SP_REGISTER_CONTROL_STATUSW { + DWORD cbSize; + PCWSTR FileName; + DWORD Win32Error; + DWORD FailureCode; +} SP_REGISTER_CONTROL_STATUSW, *PSP_REGISTER_CONTROL_STATUSW; + +#ifdef UNICODE +typedef SP_REGISTER_CONTROL_STATUSW SP_REGISTER_CONTROL_STATUS; +typedef PSP_REGISTER_CONTROL_STATUSW PSP_REGISTER_CONTROL_STATUS; +#else +typedef SP_REGISTER_CONTROL_STATUSA SP_REGISTER_CONTROL_STATUS; +typedef PSP_REGISTER_CONTROL_STATUSA PSP_REGISTER_CONTROL_STATUS; +#endif + + +// +// valid values for SP_REGISTER_CONTROL_STATUS.FailureCode field +// + +#define SPREG_SUCCESS 0x00000000 +#define SPREG_LOADLIBRARY 0x00000001 +#define SPREG_GETPROCADDR 0x00000002 +#define SPREG_REGSVR 0x00000003 +#define SPREG_DLLINSTALL 0x00000004 +#define SPREG_TIMEOUT 0x00000005 +#define SPREG_UNKNOWN 0xFFFFFFFF + +// +// Define type for setup file queue +// +typedef PVOID HSPFILEQ; + +// +// Structure used with SetupQueueCopyIndirect +// +typedef struct _SP_FILE_COPY_PARAMS_A { + DWORD cbSize; + HSPFILEQ QueueHandle; + PCSTR SourceRootPath; OPTIONAL + PCSTR SourcePath; OPTIONAL + PCSTR SourceFilename; + PCSTR SourceDescription; OPTIONAL + PCSTR SourceTagfile; OPTIONAL + PCSTR TargetDirectory; + PCSTR TargetFilename; OPTIONAL + DWORD CopyStyle; + HINF LayoutInf; OPTIONAL + PCSTR SecurityDescriptor; OPTIONAL +} SP_FILE_COPY_PARAMS_A, *PSP_FILE_COPY_PARAMS_A; + +typedef struct _SP_FILE_COPY_PARAMS_W { + DWORD cbSize; + HSPFILEQ QueueHandle; + PCWSTR SourceRootPath; OPTIONAL + PCWSTR SourcePath; OPTIONAL + PCWSTR SourceFilename; + PCWSTR SourceDescription; OPTIONAL + PCWSTR SourceTagfile; OPTIONAL + PCWSTR TargetDirectory; + PCWSTR TargetFilename; OPTIONAL + DWORD CopyStyle; + HINF LayoutInf; OPTIONAL + PCWSTR SecurityDescriptor; OPTIONAL +} SP_FILE_COPY_PARAMS_W, *PSP_FILE_COPY_PARAMS_W; + +#ifdef UNICODE +typedef SP_FILE_COPY_PARAMS_W SP_FILE_COPY_PARAMS; +typedef PSP_FILE_COPY_PARAMS_W PSP_FILE_COPY_PARAMS; +#else +typedef SP_FILE_COPY_PARAMS_A SP_FILE_COPY_PARAMS; +typedef PSP_FILE_COPY_PARAMS_A PSP_FILE_COPY_PARAMS; +#endif + + +// +// Define type for setup disk space list +// +typedef PVOID HDSKSPC; + +// +// Define type for reference to device information set +// +typedef PVOID HDEVINFO; + +// +// Device information structure (references a device instance +// that is a member of a device information set) +// +typedef struct _SP_DEVINFO_DATA { + DWORD cbSize; + GUID ClassGuid; + DWORD DevInst; // DEVINST handle + ULONG_PTR Reserved; +} SP_DEVINFO_DATA, *PSP_DEVINFO_DATA; + +// +// Device interface information structure (references a device +// interface that is associated with the device information +// element that owns it). +// +typedef struct _SP_DEVICE_INTERFACE_DATA { + DWORD cbSize; + GUID InterfaceClassGuid; + DWORD Flags; + ULONG_PTR Reserved; +} SP_DEVICE_INTERFACE_DATA, *PSP_DEVICE_INTERFACE_DATA; + +// +// Flags for SP_DEVICE_INTERFACE_DATA.Flags field. +// +#define SPINT_ACTIVE 0x00000001 +#define SPINT_DEFAULT 0x00000002 +#define SPINT_REMOVED 0x00000004 + +// +// Backward compatibility--do not use. +// +typedef SP_DEVICE_INTERFACE_DATA SP_INTERFACE_DEVICE_DATA; +typedef PSP_DEVICE_INTERFACE_DATA PSP_INTERFACE_DEVICE_DATA; +#define SPID_ACTIVE SPINT_ACTIVE +#define SPID_DEFAULT SPINT_DEFAULT +#define SPID_REMOVED SPINT_REMOVED + + +typedef struct _SP_DEVICE_INTERFACE_DETAIL_DATA_A { + DWORD cbSize; + CHAR DevicePath[ANYSIZE_ARRAY]; +} SP_DEVICE_INTERFACE_DETAIL_DATA_A, *PSP_DEVICE_INTERFACE_DETAIL_DATA_A; + +typedef struct _SP_DEVICE_INTERFACE_DETAIL_DATA_W { + DWORD cbSize; + WCHAR DevicePath[ANYSIZE_ARRAY]; +} SP_DEVICE_INTERFACE_DETAIL_DATA_W, *PSP_DEVICE_INTERFACE_DETAIL_DATA_W; + +#ifdef UNICODE +typedef SP_DEVICE_INTERFACE_DETAIL_DATA_W SP_DEVICE_INTERFACE_DETAIL_DATA; +typedef PSP_DEVICE_INTERFACE_DETAIL_DATA_W PSP_DEVICE_INTERFACE_DETAIL_DATA; +#else +typedef SP_DEVICE_INTERFACE_DETAIL_DATA_A SP_DEVICE_INTERFACE_DETAIL_DATA; +typedef PSP_DEVICE_INTERFACE_DETAIL_DATA_A PSP_DEVICE_INTERFACE_DETAIL_DATA; +#endif + +// +// Backward compatibility--do not use. +// +typedef SP_DEVICE_INTERFACE_DETAIL_DATA_W SP_INTERFACE_DEVICE_DETAIL_DATA_W; +typedef PSP_DEVICE_INTERFACE_DETAIL_DATA_W PSP_INTERFACE_DEVICE_DETAIL_DATA_W; +typedef SP_DEVICE_INTERFACE_DETAIL_DATA_A SP_INTERFACE_DEVICE_DETAIL_DATA_A; +typedef PSP_DEVICE_INTERFACE_DETAIL_DATA_A PSP_INTERFACE_DEVICE_DETAIL_DATA_A; +#ifdef UNICODE +typedef SP_INTERFACE_DEVICE_DETAIL_DATA_W SP_INTERFACE_DEVICE_DETAIL_DATA; +typedef PSP_INTERFACE_DEVICE_DETAIL_DATA_W PSP_INTERFACE_DEVICE_DETAIL_DATA; +#else +typedef SP_INTERFACE_DEVICE_DETAIL_DATA_A SP_INTERFACE_DEVICE_DETAIL_DATA; +typedef PSP_INTERFACE_DEVICE_DETAIL_DATA_A PSP_INTERFACE_DEVICE_DETAIL_DATA; +#endif + + +// +// Structure for detailed information on a device information set (used for +// SetupDiGetDeviceInfoListDetail which supercedes the functionality of +// SetupDiGetDeviceInfoListClass). +// +typedef struct _SP_DEVINFO_LIST_DETAIL_DATA_A { + DWORD cbSize; + GUID ClassGuid; + HANDLE RemoteMachineHandle; + CHAR RemoteMachineName[SP_MAX_MACHINENAME_LENGTH]; +} SP_DEVINFO_LIST_DETAIL_DATA_A, *PSP_DEVINFO_LIST_DETAIL_DATA_A; + +typedef struct _SP_DEVINFO_LIST_DETAIL_DATA_W { + DWORD cbSize; + GUID ClassGuid; + HANDLE RemoteMachineHandle; + WCHAR RemoteMachineName[SP_MAX_MACHINENAME_LENGTH]; +} SP_DEVINFO_LIST_DETAIL_DATA_W, *PSP_DEVINFO_LIST_DETAIL_DATA_W; + +#ifdef UNICODE +typedef SP_DEVINFO_LIST_DETAIL_DATA_W SP_DEVINFO_LIST_DETAIL_DATA; +typedef PSP_DEVINFO_LIST_DETAIL_DATA_W PSP_DEVINFO_LIST_DETAIL_DATA; +#else +typedef SP_DEVINFO_LIST_DETAIL_DATA_A SP_DEVINFO_LIST_DETAIL_DATA; +typedef PSP_DEVINFO_LIST_DETAIL_DATA_A PSP_DEVINFO_LIST_DETAIL_DATA; +#endif + +// +// Class installer function codes +// +#define DIF_SELECTDEVICE 0x00000001 +#define DIF_INSTALLDEVICE 0x00000002 +#define DIF_ASSIGNRESOURCES 0x00000003 +#define DIF_PROPERTIES 0x00000004 +#define DIF_REMOVE 0x00000005 +#define DIF_FIRSTTIMESETUP 0x00000006 +#define DIF_FOUNDDEVICE 0x00000007 +#define DIF_SELECTCLASSDRIVERS 0x00000008 +#define DIF_VALIDATECLASSDRIVERS 0x00000009 +#define DIF_INSTALLCLASSDRIVERS 0x0000000A +#define DIF_CALCDISKSPACE 0x0000000B +#define DIF_DESTROYPRIVATEDATA 0x0000000C +#define DIF_VALIDATEDRIVER 0x0000000D +#define DIF_DETECT 0x0000000F +#define DIF_INSTALLWIZARD 0x00000010 +#define DIF_DESTROYWIZARDDATA 0x00000011 +#define DIF_PROPERTYCHANGE 0x00000012 +#define DIF_ENABLECLASS 0x00000013 +#define DIF_DETECTVERIFY 0x00000014 +#define DIF_INSTALLDEVICEFILES 0x00000015 +#define DIF_UNREMOVE 0x00000016 +#define DIF_SELECTBESTCOMPATDRV 0x00000017 +#define DIF_ALLOW_INSTALL 0x00000018 +#define DIF_REGISTERDEVICE 0x00000019 +#define DIF_NEWDEVICEWIZARD_PRESELECT 0x0000001A +#define DIF_NEWDEVICEWIZARD_SELECT 0x0000001B +#define DIF_NEWDEVICEWIZARD_PREANALYZE 0x0000001C +#define DIF_NEWDEVICEWIZARD_POSTANALYZE 0x0000001D +#define DIF_NEWDEVICEWIZARD_FINISHINSTALL 0x0000001E +#define DIF_UNUSED1 0x0000001F +#define DIF_INSTALLINTERFACES 0x00000020 +#define DIF_DETECTCANCEL 0x00000021 +#define DIF_REGISTER_COINSTALLERS 0x00000022 +#define DIF_ADDPROPERTYPAGE_ADVANCED 0x00000023 +#define DIF_ADDPROPERTYPAGE_BASIC 0x00000024 +#define DIF_RESERVED1 0x00000025 +#define DIF_TROUBLESHOOTER 0x00000026 +#define DIF_POWERMESSAGEWAKE 0x00000027 +#define DIF_ADDREMOTEPROPERTYPAGE_ADVANCED 0x00000028 +#define DIF_UPDATEDRIVER_UI 0x00000029 +#define DIF_FINISHINSTALL_ACTION 0x0000002A +#define DIF_RESERVED2 0x00000030 + +// +// Obsoleted DIF codes (do not use) +// +#define DIF_MOVEDEVICE 0x0000000E + + +typedef UINT DI_FUNCTION; // Function type for device installer + + +// +// Device installation parameters structure (associated with a +// particular device information element, or globally with a device +// information set) +// +typedef struct _SP_DEVINSTALL_PARAMS_A { + DWORD cbSize; + DWORD Flags; + DWORD FlagsEx; + HWND hwndParent; + PSP_FILE_CALLBACK InstallMsgHandler; + PVOID InstallMsgHandlerContext; + HSPFILEQ FileQueue; + ULONG_PTR ClassInstallReserved; + DWORD Reserved; + CHAR DriverPath[MAX_PATH]; +} SP_DEVINSTALL_PARAMS_A, *PSP_DEVINSTALL_PARAMS_A; + +typedef struct _SP_DEVINSTALL_PARAMS_W { + DWORD cbSize; + DWORD Flags; + DWORD FlagsEx; + HWND hwndParent; + PSP_FILE_CALLBACK InstallMsgHandler; + PVOID InstallMsgHandlerContext; + HSPFILEQ FileQueue; + ULONG_PTR ClassInstallReserved; + DWORD Reserved; + WCHAR DriverPath[MAX_PATH]; +} SP_DEVINSTALL_PARAMS_W, *PSP_DEVINSTALL_PARAMS_W; + +#ifdef UNICODE +typedef SP_DEVINSTALL_PARAMS_W SP_DEVINSTALL_PARAMS; +typedef PSP_DEVINSTALL_PARAMS_W PSP_DEVINSTALL_PARAMS; +#else +typedef SP_DEVINSTALL_PARAMS_A SP_DEVINSTALL_PARAMS; +typedef PSP_DEVINSTALL_PARAMS_A PSP_DEVINSTALL_PARAMS; +#endif + + +// +// SP_DEVINSTALL_PARAMS.Flags values +// +// Flags for choosing a device +// +#define DI_SHOWOEM 0x00000001L // support Other... button +#define DI_SHOWCOMPAT 0x00000002L // show compatibility list +#define DI_SHOWCLASS 0x00000004L // show class list +#define DI_SHOWALL 0x00000007L // both class & compat list shown +#define DI_NOVCP 0x00000008L // don't create a new copy queue--use + // caller-supplied FileQueue +#define DI_DIDCOMPAT 0x00000010L // Searched for compatible devices +#define DI_DIDCLASS 0x00000020L // Searched for class devices +#define DI_AUTOASSIGNRES 0x00000040L // No UI for resources if possible + +// flags returned by DiInstallDevice to indicate need to reboot/restart +#define DI_NEEDRESTART 0x00000080L // Reboot required to take effect +#define DI_NEEDREBOOT 0x00000100L // "" + +// flags for device installation +#define DI_NOBROWSE 0x00000200L // no Browse... in InsertDisk + +// Flags set by DiBuildDriverInfoList +#define DI_MULTMFGS 0x00000400L // Set if multiple manufacturers in + // class driver list + +// Flag indicates that device is disabled +#define DI_DISABLED 0x00000800L // Set if device disabled + +// Flags for Device/Class Properties +#define DI_GENERALPAGE_ADDED 0x00001000L +#define DI_RESOURCEPAGE_ADDED 0x00002000L + +// Flag to indicate the setting properties for this Device (or class) caused a change +// so the Dev Mgr UI probably needs to be updatd. +#define DI_PROPERTIES_CHANGE 0x00004000L + +// Flag to indicate that the sorting from the INF file should be used. +#define DI_INF_IS_SORTED 0x00008000L + +// Flag to indicate that only the the INF specified by SP_DEVINSTALL_PARAMS.DriverPath +// should be searched. +#define DI_ENUMSINGLEINF 0x00010000L + +// Flag that prevents ConfigMgr from removing/re-enumerating devices during device +// registration, installation, and deletion. +#define DI_DONOTCALLCONFIGMG 0x00020000L + +// The following flag can be used to install a device disabled +#define DI_INSTALLDISABLED 0x00040000L + +// Flag that causes SetupDiBuildDriverInfoList to build a device's compatible driver +// list from its existing class driver list, instead of the normal INF search. +#define DI_COMPAT_FROM_CLASS 0x00080000L + +// This flag is set if the Class Install params should be used. +#define DI_CLASSINSTALLPARAMS 0x00100000L + +// This flag is set if the caller of DiCallClassInstaller does NOT +// want the internal default action performed if the Class installer +// returns ERROR_DI_DO_DEFAULT. +#define DI_NODI_DEFAULTACTION 0x00200000L + +// The setupx flag, DI_NOSYNCPROCESSING (0x00400000L) is not support in the Setup APIs. + +// flags for device installation +#define DI_QUIETINSTALL 0x00800000L // don't confuse the user with + // questions or excess info +#define DI_NOFILECOPY 0x01000000L // No file Copy necessary +#define DI_FORCECOPY 0x02000000L // Force files to be copied from install path +#define DI_DRIVERPAGE_ADDED 0x04000000L // Prop provider added Driver page. +#define DI_USECI_SELECTSTRINGS 0x08000000L // Use Class Installer Provided strings in the Select Device Dlg +#define DI_OVERRIDE_INFFLAGS 0x10000000L // Override INF flags +#define DI_PROPS_NOCHANGEUSAGE 0x20000000L // No Enable/Disable in General Props + +#define DI_NOSELECTICONS 0x40000000L // No small icons in select device dialogs + +#define DI_NOWRITE_IDS 0x80000000L // Don't write HW & Compat IDs on install + + +// +// SP_DEVINSTALL_PARAMS.FlagsEx values +// + +#define DI_FLAGSEX_RESERVED2 0x00000001L // DI_FLAGSEX_USEOLDINFSEARCH is obsolete +#define DI_FLAGSEX_RESERVED3 0x00000002L // DI_FLAGSEX_AUTOSELECTRANK0 is obsolete +#define DI_FLAGSEX_CI_FAILED 0x00000004L // Failed to Load/Call class installer + +#if _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN // + +#define DI_FLAGSEX_FINISHINSTALL_ACTION 0x00000008L // Class/co-installer wants to get a DIF_FINISH_INSTALL action in client context. + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + +#define DI_FLAGSEX_DIDINFOLIST 0x00000010L // Did the Class Info List +#define DI_FLAGSEX_DIDCOMPATINFO 0x00000020L // Did the Compat Info List + +#define DI_FLAGSEX_FILTERCLASSES 0x00000040L +#define DI_FLAGSEX_SETFAILEDINSTALL 0x00000080L +#define DI_FLAGSEX_DEVICECHANGE 0x00000100L +#define DI_FLAGSEX_ALWAYSWRITEIDS 0x00000200L +#define DI_FLAGSEX_PROPCHANGE_PENDING 0x00000400L // One or more device property sheets have had changes made + // to them, and need to have a DIF_PROPERTYCHANGE occur. +#define DI_FLAGSEX_ALLOWEXCLUDEDDRVS 0x00000800L +#define DI_FLAGSEX_NOUIONQUERYREMOVE 0x00001000L +#define DI_FLAGSEX_USECLASSFORCOMPAT 0x00002000L // Use the device's class when building compat drv list. + // (Ignored if DI_COMPAT_FROM_CLASS flag is specified.) + +#define DI_FLAGSEX_RESERVED4 0x00004000L // DI_FLAGSEX_OLDINF_IN_CLASSLIST is obsolete + +#define DI_FLAGSEX_NO_DRVREG_MODIFY 0x00008000L // Don't run AddReg and DelReg for device's software (driver) key. +#define DI_FLAGSEX_IN_SYSTEM_SETUP 0x00010000L // Installation is occurring during initial system setup. +#define DI_FLAGSEX_INET_DRIVER 0x00020000L // Driver came from Windows Update +#define DI_FLAGSEX_APPENDDRIVERLIST 0x00040000L // Cause SetupDiBuildDriverInfoList to append + // a new driver list to an existing list. +#define DI_FLAGSEX_PREINSTALLBACKUP 0x00080000L // not used +#define DI_FLAGSEX_BACKUPONREPLACE 0x00100000L // not used +#define DI_FLAGSEX_DRIVERLIST_FROM_URL 0x00200000L // build driver list from INF(s) retrieved from URL specified + // in SP_DEVINSTALL_PARAMS.DriverPath (empty string means + // Windows Update website) +#define DI_FLAGSEX_RESERVED1 0x00400000L +#define DI_FLAGSEX_EXCLUDE_OLD_INET_DRIVERS 0x00800000L // Don't include old Internet drivers when building + // a driver list. + // Ignored on Windows Vista and later. +#define DI_FLAGSEX_POWERPAGE_ADDED 0x01000000L // class installer added their own power page + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +#define DI_FLAGSEX_FILTERSIMILARDRIVERS 0x02000000L // only include similar drivers in class list +#define DI_FLAGSEX_INSTALLEDDRIVER 0x04000000L // only add the installed driver to the class or compat + // driver list. Used in calls to SetupDiBuildDriverInfoList +#define DI_FLAGSEX_NO_CLASSLIST_NODE_MERGE 0x08000000L // Don't remove identical driver nodes from the class list +#define DI_FLAGSEX_ALTPLATFORM_DRVSEARCH 0x10000000L // Build driver list based on alternate platform information + // specified in associated file queue +#define DI_FLAGSEX_RESTART_DEVICE_ONLY 0x20000000L // only restart the device drivers are being installed on as + // opposed to restarting all devices using those drivers. + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +#if _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + +#define DI_FLAGSEX_RECURSIVESEARCH 0x40000000L // Tell SetupDiBuildDriverInfoList to do a recursive search +#define DI_FLAGSEX_SEARCH_PUBLISHED_INFS 0x80000000L // Tell SetupDiBuildDriverInfoList to do a "published INF" search + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + +// +// Class installation parameters header. This must be the first field of any +// class install parameter structure. The InstallFunction field must be set to +// the function code corresponding to the structure, and the cbSize field must +// be set to the size of the header structure. E.g., +// +// SP_ENABLECLASS_PARAMS EnableClassParams; +// +// EnableClassParams.ClassInstallHeader.cbSize = sizeof(SP_CLASSINSTALL_HEADER); +// EnableClassParams.ClassInstallHeader.InstallFunction = DIF_ENABLECLASS; +// +typedef struct _SP_CLASSINSTALL_HEADER { + DWORD cbSize; + DI_FUNCTION InstallFunction; +} SP_CLASSINSTALL_HEADER, *PSP_CLASSINSTALL_HEADER; + + +// +// Structure corresponding to a DIF_ENABLECLASS install function. +// +typedef struct _SP_ENABLECLASS_PARAMS { + SP_CLASSINSTALL_HEADER ClassInstallHeader; + GUID ClassGuid; + DWORD EnableMessage; +} SP_ENABLECLASS_PARAMS, *PSP_ENABLECLASS_PARAMS; + +#define ENABLECLASS_QUERY 0 +#define ENABLECLASS_SUCCESS 1 +#define ENABLECLASS_FAILURE 2 + + +// +// Values indicating a change in a device's state +// +#define DICS_ENABLE 0x00000001 +#define DICS_DISABLE 0x00000002 +#define DICS_PROPCHANGE 0x00000003 +#define DICS_START 0x00000004 +#define DICS_STOP 0x00000005 +// +// Values specifying the scope of a device property change +// +#define DICS_FLAG_GLOBAL 0x00000001 // make change in all hardware profiles +#define DICS_FLAG_CONFIGSPECIFIC 0x00000002 // make change in specified profile only +#define DICS_FLAG_CONFIGGENERAL 0x00000004 // 1 or more hardware profile-specific + // changes to follow. +// +// Structure corresponding to a DIF_PROPERTYCHANGE install function. +// +typedef struct _SP_PROPCHANGE_PARAMS { + SP_CLASSINSTALL_HEADER ClassInstallHeader; + DWORD StateChange; + DWORD Scope; + DWORD HwProfile; +} SP_PROPCHANGE_PARAMS, *PSP_PROPCHANGE_PARAMS; + + +// +// Structure corresponding to a DIF_REMOVE install function. +// +typedef struct _SP_REMOVEDEVICE_PARAMS { + SP_CLASSINSTALL_HEADER ClassInstallHeader; + DWORD Scope; + DWORD HwProfile; +} SP_REMOVEDEVICE_PARAMS, *PSP_REMOVEDEVICE_PARAMS; + +#define DI_REMOVEDEVICE_GLOBAL 0x00000001 +#define DI_REMOVEDEVICE_CONFIGSPECIFIC 0x00000002 + + +// +// Structure corresponding to a DIF_UNREMOVE install function. +// +typedef struct _SP_UNREMOVEDEVICE_PARAMS { + SP_CLASSINSTALL_HEADER ClassInstallHeader; + DWORD Scope; + DWORD HwProfile; +} SP_UNREMOVEDEVICE_PARAMS, *PSP_UNREMOVEDEVICE_PARAMS; + +#define DI_UNREMOVEDEVICE_CONFIGSPECIFIC 0x00000002 + + +// +// Structure corresponding to a DIF_SELECTDEVICE install function. +// +typedef struct _SP_SELECTDEVICE_PARAMS_A { + SP_CLASSINSTALL_HEADER ClassInstallHeader; + CHAR Title[MAX_TITLE_LEN]; + CHAR Instructions[MAX_INSTRUCTION_LEN]; + CHAR ListLabel[MAX_LABEL_LEN]; + CHAR SubTitle[MAX_SUBTITLE_LEN]; + BYTE Reserved[2]; // DWORD size alignment +} SP_SELECTDEVICE_PARAMS_A, *PSP_SELECTDEVICE_PARAMS_A; + +typedef struct _SP_SELECTDEVICE_PARAMS_W { + SP_CLASSINSTALL_HEADER ClassInstallHeader; + WCHAR Title[MAX_TITLE_LEN]; + WCHAR Instructions[MAX_INSTRUCTION_LEN]; + WCHAR ListLabel[MAX_LABEL_LEN]; + WCHAR SubTitle[MAX_SUBTITLE_LEN]; +} SP_SELECTDEVICE_PARAMS_W, *PSP_SELECTDEVICE_PARAMS_W; + +#ifdef UNICODE +typedef SP_SELECTDEVICE_PARAMS_W SP_SELECTDEVICE_PARAMS; +typedef PSP_SELECTDEVICE_PARAMS_W PSP_SELECTDEVICE_PARAMS; +#else +typedef SP_SELECTDEVICE_PARAMS_A SP_SELECTDEVICE_PARAMS; +typedef PSP_SELECTDEVICE_PARAMS_A PSP_SELECTDEVICE_PARAMS; +#endif + + +// +// Callback routine for giving progress notification during detection +// +typedef BOOL (CALLBACK* PDETECT_PROGRESS_NOTIFY)( + IN PVOID ProgressNotifyParam, + IN DWORD DetectComplete + ); + +// where: +// ProgressNotifyParam - value supplied by caller requesting detection. +// DetectComplete - Percent completion, to be incremented by class +// installer, as it steps thru its detection. +// +// Return Value - If TRUE, then detection is cancelled. Allows caller +// requesting detection to stop detection asap. +// + +// +// Structure corresponding to a DIF_DETECT install function. +// +typedef struct _SP_DETECTDEVICE_PARAMS { + SP_CLASSINSTALL_HEADER ClassInstallHeader; + PDETECT_PROGRESS_NOTIFY DetectProgressNotify; + PVOID ProgressNotifyParam; +} SP_DETECTDEVICE_PARAMS, *PSP_DETECTDEVICE_PARAMS; + + +// +// 'Add New Device' installation wizard structure (backward-compatibility +// only--respond to DIF_NEWDEVICEWIZARD_* requests instead). +// +// Structure corresponding to a DIF_INSTALLWIZARD install function. +// (NOTE: This structure is also applicable for DIF_DESTROYWIZARDDATA, +// but DIF_INSTALLWIZARD is the associated function code in the class +// installation parameter structure in both cases.) +// +// Define maximum number of dynamic wizard pages that can be added to +// hardware install wizard. +// +#define MAX_INSTALLWIZARD_DYNAPAGES 20 + +typedef struct _SP_INSTALLWIZARD_DATA { + SP_CLASSINSTALL_HEADER ClassInstallHeader; + DWORD Flags; + HPROPSHEETPAGE DynamicPages[MAX_INSTALLWIZARD_DYNAPAGES]; + DWORD NumDynamicPages; + DWORD DynamicPageFlags; + DWORD PrivateFlags; + LPARAM PrivateData; + HWND hwndWizardDlg; +} SP_INSTALLWIZARD_DATA, *PSP_INSTALLWIZARD_DATA; + +// +// SP_INSTALLWIZARD_DATA.Flags values +// +#define NDW_INSTALLFLAG_DIDFACTDEFS 0x00000001 +#define NDW_INSTALLFLAG_HARDWAREALLREADYIN 0x00000002 +#define NDW_INSTALLFLAG_NEEDRESTART DI_NEEDRESTART +#define NDW_INSTALLFLAG_NEEDREBOOT DI_NEEDREBOOT +#define NDW_INSTALLFLAG_NEEDSHUTDOWN 0x00000200 +#define NDW_INSTALLFLAG_EXPRESSINTRO 0x00000400 +#define NDW_INSTALLFLAG_SKIPISDEVINSTALLED 0x00000800 +#define NDW_INSTALLFLAG_NODETECTEDDEVS 0x00001000 +#define NDW_INSTALLFLAG_INSTALLSPECIFIC 0x00002000 +#define NDW_INSTALLFLAG_SKIPCLASSLIST 0x00004000 +#define NDW_INSTALLFLAG_CI_PICKED_OEM 0x00008000 +#define NDW_INSTALLFLAG_PCMCIAMODE 0x00010000 +#define NDW_INSTALLFLAG_PCMCIADEVICE 0x00020000 +#define NDW_INSTALLFLAG_USERCANCEL 0x00040000 +#define NDW_INSTALLFLAG_KNOWNCLASS 0x00080000 + + +// +// SP_INSTALLWIZARD_DATA.DynamicPageFlags values +// +// This flag is set if a Class installer has added pages to the install wizard. +// +#define DYNAWIZ_FLAG_PAGESADDED 0x00000001 + +// +// Set this flag if you jump to the analyze page, and want it to +// handle conflicts for you. NOTE. You will not get control back +// in the event of a conflict if you set this flag. +// +#define DYNAWIZ_FLAG_ANALYZE_HANDLECONFLICT 0x00000008 + +// +// The following flags are not used by the Windows NT hardware wizard. +// +#define DYNAWIZ_FLAG_INSTALLDET_NEXT 0x00000002 +#define DYNAWIZ_FLAG_INSTALLDET_PREV 0x00000004 + + +// +// Reserve a range of wizard page resource IDs for internal use. Some of +// these IDs are for use by class installers that respond to the obsolete +// DIF_INSTALLWIZARD/DIF_DESTROYWIZARDDATA messages. These IDs are listed +// below. +// +#define MIN_IDD_DYNAWIZ_RESOURCE_ID 10000 +#define MAX_IDD_DYNAWIZ_RESOURCE_ID 11000 + +// +// Define wizard page resource IDs to be used when adding custom pages to the +// hardware install wizard via DIF_INSTALLWIZARD. Pages marked with +// (CLASS INSTALLER PROVIDED) _must_ be supplied by the class installer if it +// responds to the DIF_INSTALLWIZARD request. +// + +// +// Resource ID for the first page that the install wizard will go to after +// adding the class installer pages. (CLASS INSTALLER PROVIDED) +// +#define IDD_DYNAWIZ_FIRSTPAGE 10000 + +// +// Resource ID for the page that the Select Device page will go back to. +// (CLASS INSTALLER PROVIDED) +// +#define IDD_DYNAWIZ_SELECT_PREVPAGE 10001 + +// +// Resource ID for the page that the Select Device page will go forward to. +// (CLASS INSTALLER PROVIDED) +// +#define IDD_DYNAWIZ_SELECT_NEXTPAGE 10002 + +// +// Resource ID for the page that the Analyze dialog should go back to +// This will only be used in the event that there is a problem, and the user +// selects Back from the analyze proc. (CLASS INSTALLER PROVIDED) +// +#define IDD_DYNAWIZ_ANALYZE_PREVPAGE 10003 + +// +// Resource ID for the page that the Analyze dialog should go to if it +// continues from the analyze proc. (CLASS INSTALLER PROVIDED) +// +#define IDD_DYNAWIZ_ANALYZE_NEXTPAGE 10004 + +// +// Resource ID of the hardware install wizard's select device page. +// This ID can be used to go directly to the hardware install wizard's select +// device page. (This is the resource ID of the Select Device wizard page +// retrieved via SetupDiGetWizardPage when SPWPT_SELECTDEVICE is the requested +// PageType.) +// +#define IDD_DYNAWIZ_SELECTDEV_PAGE 10009 + +// +// Resource ID of the hardware install wizard's device analysis page. +// This ID can be use to go directly to the hardware install wizard's analysis +// page. +// +#define IDD_DYNAWIZ_ANALYZEDEV_PAGE 10010 + +// +// Resource ID of the hardware install wizard's install detected devices page. +// This ID can be use to go directly to the hardware install wizard's install +// detected devices page. +// +#define IDD_DYNAWIZ_INSTALLDETECTEDDEVS_PAGE 10011 + +// +// Resource ID of the hardware install wizard's select class page. +// This ID can be use to go directly to the hardware install wizard's select +// class page. +// +#define IDD_DYNAWIZ_SELECTCLASS_PAGE 10012 + +// +// The following class installer-provided wizard page resource IDs are not used +// by the Windows NT hardware wizard. +// +#define IDD_DYNAWIZ_INSTALLDETECTED_PREVPAGE 10006 +#define IDD_DYNAWIZ_INSTALLDETECTED_NEXTPAGE 10007 +#define IDD_DYNAWIZ_INSTALLDETECTED_NODEVS 10008 + + +// +// Structure corresponding to the following DIF_NEWDEVICEWIZARD_* install +// functions: +// +// DIF_NEWDEVICEWIZARD_PRESELECT +// DIF_NEWDEVICEWIZARD_SELECT +// DIF_NEWDEVICEWIZARD_PREANALYZE +// DIF_NEWDEVICEWIZARD_POSTANALYZE +// DIF_NEWDEVICEWIZARD_FINISHINSTALL +// +typedef struct _SP_NEWDEVICEWIZARD_DATA { + SP_CLASSINSTALL_HEADER ClassInstallHeader; + DWORD Flags; // presently unused--must be zero. + HPROPSHEETPAGE DynamicPages[MAX_INSTALLWIZARD_DYNAPAGES]; + DWORD NumDynamicPages; + HWND hwndWizardDlg; +} SP_NEWDEVICEWIZARD_DATA, *PSP_NEWDEVICEWIZARD_DATA; + +// +// The same structure is also used for retrieval of property pages via the +// following install functions: +// +// DIF_ADDPROPERTYPAGE_ADVANCED +// DIF_ADDPROPERTYPAGE_BASIC +// DIF_ADDREMOTEPROPERTYPAGE_ADVANCED +// +typedef SP_NEWDEVICEWIZARD_DATA SP_ADDPROPERTYPAGE_DATA; +typedef PSP_NEWDEVICEWIZARD_DATA PSP_ADDPROPERTYPAGE_DATA; + + +// +// Structure corresponding to the DIF_TROUBLESHOOTER install function +// +typedef struct _SP_TROUBLESHOOTER_PARAMS_A { + SP_CLASSINSTALL_HEADER ClassInstallHeader; + CHAR ChmFile[MAX_PATH]; + CHAR HtmlTroubleShooter[MAX_PATH]; +} SP_TROUBLESHOOTER_PARAMS_A, *PSP_TROUBLESHOOTER_PARAMS_A; + +typedef struct _SP_TROUBLESHOOTER_PARAMS_W { + SP_CLASSINSTALL_HEADER ClassInstallHeader; + WCHAR ChmFile[MAX_PATH]; + WCHAR HtmlTroubleShooter[MAX_PATH]; +} SP_TROUBLESHOOTER_PARAMS_W, *PSP_TROUBLESHOOTER_PARAMS_W; + +#ifdef UNICODE +typedef SP_TROUBLESHOOTER_PARAMS_W SP_TROUBLESHOOTER_PARAMS; +typedef PSP_TROUBLESHOOTER_PARAMS_W PSP_TROUBLESHOOTER_PARAMS; +#else +typedef SP_TROUBLESHOOTER_PARAMS_A SP_TROUBLESHOOTER_PARAMS; +typedef PSP_TROUBLESHOOTER_PARAMS_A PSP_TROUBLESHOOTER_PARAMS; +#endif + + +// +// Structure corresponding to the DIF_POWERMESSAGEWAKE install function +// +typedef struct _SP_POWERMESSAGEWAKE_PARAMS_A { + SP_CLASSINSTALL_HEADER ClassInstallHeader; + CHAR PowerMessageWake[LINE_LEN*2]; +} SP_POWERMESSAGEWAKE_PARAMS_A, *PSP_POWERMESSAGEWAKE_PARAMS_A; + +typedef struct _SP_POWERMESSAGEWAKE_PARAMS_W { + SP_CLASSINSTALL_HEADER ClassInstallHeader; + WCHAR PowerMessageWake[LINE_LEN*2]; +} SP_POWERMESSAGEWAKE_PARAMS_W, *PSP_POWERMESSAGEWAKE_PARAMS_W; + +#ifdef UNICODE +typedef SP_POWERMESSAGEWAKE_PARAMS_W SP_POWERMESSAGEWAKE_PARAMS; +typedef PSP_POWERMESSAGEWAKE_PARAMS_W PSP_POWERMESSAGEWAKE_PARAMS; +#else +typedef SP_POWERMESSAGEWAKE_PARAMS_A SP_POWERMESSAGEWAKE_PARAMS; +typedef PSP_POWERMESSAGEWAKE_PARAMS_A PSP_POWERMESSAGEWAKE_PARAMS; +#endif + +// +// Driver information structure (member of a driver info list that may be associated +// with a particular device instance, or (globally) with a device information set) +// +typedef struct _SP_DRVINFO_DATA_V2_A { + DWORD cbSize; + DWORD DriverType; + ULONG_PTR Reserved; + CHAR Description[LINE_LEN]; + CHAR MfgName[LINE_LEN]; + CHAR ProviderName[LINE_LEN]; + FILETIME DriverDate; + DWORDLONG DriverVersion; +} SP_DRVINFO_DATA_V2_A, *PSP_DRVINFO_DATA_V2_A; + +typedef struct _SP_DRVINFO_DATA_V2_W { + DWORD cbSize; + DWORD DriverType; + ULONG_PTR Reserved; + WCHAR Description[LINE_LEN]; + WCHAR MfgName[LINE_LEN]; + WCHAR ProviderName[LINE_LEN]; + FILETIME DriverDate; + DWORDLONG DriverVersion; +} SP_DRVINFO_DATA_V2_W, *PSP_DRVINFO_DATA_V2_W; + +// +// Version 1 of the SP_DRVINFO_DATA structures, used only for compatibility +// with Windows NT 4.0/Windows 95/98 SETUPAPI.DLL +// +typedef struct _SP_DRVINFO_DATA_V1_A { + DWORD cbSize; + DWORD DriverType; + ULONG_PTR Reserved; + CHAR Description[LINE_LEN]; + CHAR MfgName[LINE_LEN]; + CHAR ProviderName[LINE_LEN]; +} SP_DRVINFO_DATA_V1_A, *PSP_DRVINFO_DATA_V1_A; + +typedef struct _SP_DRVINFO_DATA_V1_W { + DWORD cbSize; + DWORD DriverType; + ULONG_PTR Reserved; + WCHAR Description[LINE_LEN]; + WCHAR MfgName[LINE_LEN]; + WCHAR ProviderName[LINE_LEN]; +} SP_DRVINFO_DATA_V1_W, *PSP_DRVINFO_DATA_V1_W; + +#ifdef UNICODE +typedef SP_DRVINFO_DATA_V1_W SP_DRVINFO_DATA_V1; +typedef PSP_DRVINFO_DATA_V1_W PSP_DRVINFO_DATA_V1; +typedef SP_DRVINFO_DATA_V2_W SP_DRVINFO_DATA_V2; +typedef PSP_DRVINFO_DATA_V2_W PSP_DRVINFO_DATA_V2; +#else +typedef SP_DRVINFO_DATA_V1_A SP_DRVINFO_DATA_V1; +typedef PSP_DRVINFO_DATA_V1_A PSP_DRVINFO_DATA_V1; +typedef SP_DRVINFO_DATA_V2_A SP_DRVINFO_DATA_V2; +typedef PSP_DRVINFO_DATA_V2_A PSP_DRVINFO_DATA_V2; +#endif + +#if USE_SP_DRVINFO_DATA_V1 || (_SETUPAPI_VER < _WIN32_WINNT_WIN2K) // use version 1 driver info data structure + +typedef SP_DRVINFO_DATA_V1_A SP_DRVINFO_DATA_A; +typedef PSP_DRVINFO_DATA_V1_A PSP_DRVINFO_DATA_A; +typedef SP_DRVINFO_DATA_V1_W SP_DRVINFO_DATA_W; +typedef PSP_DRVINFO_DATA_V1_W PSP_DRVINFO_DATA_W; +typedef SP_DRVINFO_DATA_V1 SP_DRVINFO_DATA; +typedef PSP_DRVINFO_DATA_V1 PSP_DRVINFO_DATA; + +#else // use version 2 driver info data structure + +typedef SP_DRVINFO_DATA_V2_A SP_DRVINFO_DATA_A; +typedef PSP_DRVINFO_DATA_V2_A PSP_DRVINFO_DATA_A; +typedef SP_DRVINFO_DATA_V2_W SP_DRVINFO_DATA_W; +typedef PSP_DRVINFO_DATA_V2_W PSP_DRVINFO_DATA_W; +typedef SP_DRVINFO_DATA_V2 SP_DRVINFO_DATA; +typedef PSP_DRVINFO_DATA_V2 PSP_DRVINFO_DATA; + +#endif // use current version of driver info data structure + +// +// Driver information details structure (provides detailed information about a +// particular driver information structure) +// +typedef struct _SP_DRVINFO_DETAIL_DATA_A { + DWORD cbSize; + FILETIME InfDate; + DWORD CompatIDsOffset; + DWORD CompatIDsLength; + ULONG_PTR Reserved; + CHAR SectionName[LINE_LEN]; + CHAR InfFileName[MAX_PATH]; + CHAR DrvDescription[LINE_LEN]; + CHAR HardwareID[ANYSIZE_ARRAY]; +} SP_DRVINFO_DETAIL_DATA_A, *PSP_DRVINFO_DETAIL_DATA_A; + +typedef struct _SP_DRVINFO_DETAIL_DATA_W { + DWORD cbSize; + FILETIME InfDate; + DWORD CompatIDsOffset; + DWORD CompatIDsLength; + ULONG_PTR Reserved; + WCHAR SectionName[LINE_LEN]; + WCHAR InfFileName[MAX_PATH]; + WCHAR DrvDescription[LINE_LEN]; + WCHAR HardwareID[ANYSIZE_ARRAY]; +} SP_DRVINFO_DETAIL_DATA_W, *PSP_DRVINFO_DETAIL_DATA_W; + +#ifdef UNICODE +typedef SP_DRVINFO_DETAIL_DATA_W SP_DRVINFO_DETAIL_DATA; +typedef PSP_DRVINFO_DETAIL_DATA_W PSP_DRVINFO_DETAIL_DATA; +#else +typedef SP_DRVINFO_DETAIL_DATA_A SP_DRVINFO_DETAIL_DATA; +typedef PSP_DRVINFO_DETAIL_DATA_A PSP_DRVINFO_DETAIL_DATA; +#endif + + +// +// Driver installation parameters (associated with a particular driver +// information element) +// +typedef struct _SP_DRVINSTALL_PARAMS { + DWORD cbSize; + DWORD Rank; + DWORD Flags; + DWORD_PTR PrivateData; + DWORD Reserved; +} SP_DRVINSTALL_PARAMS, *PSP_DRVINSTALL_PARAMS; + +// +// SP_DRVINSTALL_PARAMS.Flags values +// + +#define DNF_DUPDESC 0x00000001 // Multiple providers have same desc +#define DNF_OLDDRIVER 0x00000002 // Driver node specifies old/current driver +#define DNF_EXCLUDEFROMLIST 0x00000004 // If set, this driver node will not be + // displayed in any driver select dialogs. +#define DNF_NODRIVER 0x00000008 // if we want to install no driver + // (e.g no mouse drv) +#define DNF_LEGACYINF 0x00000010 // Driver node came from an old-style INF (obsolete) +#define DNF_CLASS_DRIVER 0x00000020 // Driver node represents a class driver +#define DNF_COMPATIBLE_DRIVER 0x00000040 // Driver node represents a compatible driver +#define DNF_INET_DRIVER 0x00000080 // Driver comes from an internet source +#define DNF_UNUSED1 0x00000100 +#define DNF_UNUSED2 0x00000200 +#define DNF_OLD_INET_DRIVER 0x00000400 // Driver came from the Internet, but we don't currently + // have access to it's source files. Never attempt to + // install a driver with this flag! + // Note used on Windows Vista and Later. +#define DNF_BAD_DRIVER 0x00000800 // Driver node should not be used at all +#define DNF_DUPPROVIDER 0x00001000 // Multiple drivers have the same provider and desc + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP +#define DNF_INF_IS_SIGNED 0x00002000 // If file is digitally signed +#define DNF_OEM_F6_INF 0x00004000 // INF specified from F6 during textmode setup. +#define DNF_DUPDRIVERVER 0x00008000 // Multipe drivers have the same desc, provider, and DriverVer values +#define DNF_BASIC_DRIVER 0x00010000 // Driver provides basic functionality, but should + // not be chosen if other signed drivers exist. +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +#if _SETUPAPI_VER >= _WIN32_WINNT_WS03 +#define DNF_AUTHENTICODE_SIGNED 0x00020000 // Inf file is signed by an Authenticode(tm) catalog. +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WS03 + +#if _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN +#define DNF_INSTALLEDDRIVER 0x00040000 // This driver node is currently installed on the device. +#define DNF_ALWAYSEXCLUDEFROMLIST 0x00080000 // If set, this driver is not even displayed in + // alternative platform either. +#define DNF_INBOX_DRIVER 0x00100000 // This driver node came from an INF that shipped with Windows. +#endif // _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + +#if _SETUPAPI_VER >= _WIN32_WINNT_WIN7 +#define DNF_REQUESTADDITIONALSOFTWARE 0x00200000 // This driver is only part of a software solution needed + // by this device +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WIN7 + +#define DNF_UNUSED_22 0x00400000 +#define DNF_UNUSED_23 0x00800000 +#define DNF_UNUSED_24 0x01000000 +#define DNF_UNUSED_25 0x02000000 +#define DNF_UNUSED_26 0x04000000 +#define DNF_UNUSED_27 0x08000000 +#define DNF_UNUSED_28 0x10000000 +#define DNF_UNUSED_29 0x20000000 +#define DNF_UNUSED_30 0x40000000 +#define DNF_UNUSED_31 0x80000000 + + +// +// Rank values (the lower the Rank number, the better the Rank) +// +#if _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN +#define DRIVER_HARDWAREID_RANK 0x00000FFF // Any rank less than or equal to + // this value is a gold + // HardwareID match + +#define DRIVER_HARDWAREID_MASK 0x80000FFF // If you mask these bits off (AND) + // from the Rank and the result is 0 + // then the Rank is a trusted HardwareID + // match + +#define DRIVER_UNTRUSTED_RANK 0x80000000 // Any rank with this bit set is an + // "untrusted" rank, meaning that + // the INF was unsigned. + +#define DRIVER_W9X_SUSPECT_RANK 0xC0000000 // Any rank that is greater than + // or equal to this value, and lesser + // than or equal to 0xFFFF is suspected + // to be a Win9x-only driver, because + // (a) it isn't signed, and (b) there + // is no NT-specific decoration to + // explicitly indicate that the INF + // supports Windows NT/2000/XP + +#else +#define DRIVER_HARDWAREID_RANK 0x00000FFF // Any rank less than or equal to + // this value is a trusted + // HardwareID match + +#define DRIVER_COMPATID_RANK 0x00003FFF // Any rank less than or equal to + // this (and greater than + // DRIVER_HARDWAREID_RANK) is a + // trusted CompatibleID match + +#define DRIVER_UNTRUSTED_RANK 0x00008000 // Any rank with this bit set is an + // "untrusted" rank, meaning that + // the INF was unsigned. + +#define DRIVER_UNTRUSTED_HARDWAREID_RANK 0x00008FFF // Any rank less than or equal to + // this value (and greater than + // or equal to DRIVER_UNTRUSTED_RANK) + // is an untrusted HardwareID match + +#define DRIVER_UNTRUSTED_COMPATID_RANK 0x0000BFFF // Any rank less than or equal to + // this value (and greater than + // DRIVER_UNTRUSTED_HARDWAREID_RANK) + // is an untrusted CompatibleID match + +#define DRIVER_W9X_SUSPECT_RANK 0x0000C000 // Any rank that is greater than + // or equal to this value, and lesser + // than or equal to 0xFFFF is suspected + // to be a Win9x-only driver, because + // (a) it isn't signed, and (b) there + // is no NT-specific decoration to + // explicitly indicate that the INF + // supports Windows NT/2000/XP + +#define DRIVER_W9X_SUSPECT_HARDWAREID_RANK 0x0000CFFF // Any rank less than or equal to this + // (and greater than or equal to + // DRIVER_W9X_SUSPECT_RANK) is a + // hardware ID match suspected of being + // only for Windows 9x platforms. + +#define DRIVER_W9X_SUSPECT_COMPATID_RANK 0x0000FFFF // Any rank less than or equal to + // this (and greater than + // DRIVER_W9X_SUSPECT_HARDWAREID_RANK) + // is a compatible ID match suspected + // of being only for Windows 9x + // platforms. +#endif // _SETUPAPI_VER < _WIN32_WINNT_LONGHORN + +// +// Setup callback routine for comparing detection signatures +// +typedef DWORD (CALLBACK* PSP_DETSIG_CMPPROC)( + IN HDEVINFO DeviceInfoSet, + IN PSP_DEVINFO_DATA NewDeviceData, + IN PSP_DEVINFO_DATA ExistingDeviceData, + IN PVOID CompareContext OPTIONAL + ); + + +// +// Define context structure handed to co-installers +// +typedef struct _COINSTALLER_CONTEXT_DATA { + BOOL PostProcessing; + DWORD InstallResult; + PVOID PrivateData; +} COINSTALLER_CONTEXT_DATA, *PCOINSTALLER_CONTEXT_DATA; + + +// +// Structure containing class image list information. +// +typedef struct _SP_CLASSIMAGELIST_DATA { + DWORD cbSize; + HIMAGELIST ImageList; + ULONG_PTR Reserved; +} SP_CLASSIMAGELIST_DATA, *PSP_CLASSIMAGELIST_DATA; + + +// +// Structure to be passed as first parameter (LPVOID lpv) to ExtensionPropSheetPageProc +// entry point in setupapi.dll or to "EnumPropPages32" or "BasicProperties32" entry +// points provided by class/device property page providers. Used to retrieve a handle +// (or, potentially, multiple handles) to property pages for a specified property page type. +// +typedef struct _SP_PROPSHEETPAGE_REQUEST { + DWORD cbSize; + DWORD PageRequested; + HDEVINFO DeviceInfoSet; + PSP_DEVINFO_DATA DeviceInfoData; +} SP_PROPSHEETPAGE_REQUEST, *PSP_PROPSHEETPAGE_REQUEST; + +// +// Property sheet codes used in SP_PROPSHEETPAGE_REQUEST.PageRequested +// +#define SPPSR_SELECT_DEVICE_RESOURCES 1 // supplied by setupapi.dll +#define SPPSR_ENUM_BASIC_DEVICE_PROPERTIES 2 // supplied by device's BasicProperties32 provider +#define SPPSR_ENUM_ADV_DEVICE_PROPERTIES 3 // supplied by class and/or device's EnumPropPages32 provider + + +// +// Structure used with SetupGetBackupInformation/SetupSetBackupInformation +// +typedef struct _SP_BACKUP_QUEUE_PARAMS_V2_A { + DWORD cbSize; // size of structure + CHAR FullInfPath[MAX_PATH]; // buffer to hold ANSI pathname of INF file + INT FilenameOffset; // offset in CHAR's of filename part (after '\') + CHAR ReinstallInstance[MAX_PATH]; // Instance ID (if present) +} SP_BACKUP_QUEUE_PARAMS_V2_A, *PSP_BACKUP_QUEUE_PARAMS_V2_A; + +typedef struct _SP_BACKUP_QUEUE_PARAMS_V2_W { + DWORD cbSize; // size of structure + WCHAR FullInfPath[MAX_PATH]; // buffer to hold UNICODE pathname of INF file + INT FilenameOffset; // offset in WCHAR's of filename part (after '\') + WCHAR ReinstallInstance[MAX_PATH]; // Instance ID (if present) +} SP_BACKUP_QUEUE_PARAMS_V2_W, *PSP_BACKUP_QUEUE_PARAMS_V2_W; + +// +// Version 1 of the SP_BACKUP_QUEUE_PARAMS structures, used only for compatibility +// with Windows 2000/Windows 95/98/ME SETUPAPI.DLL +// +typedef struct _SP_BACKUP_QUEUE_PARAMS_V1_A { + DWORD cbSize; // size of structure + CHAR FullInfPath[MAX_PATH]; // buffer to hold ANSI pathname of INF file + INT FilenameOffset; // offset in CHAR's of filename part (after '\') +} SP_BACKUP_QUEUE_PARAMS_V1_A, *PSP_BACKUP_QUEUE_PARAMS_V1_A; + +typedef struct _SP_BACKUP_QUEUE_PARAMS_V1_W { + DWORD cbSize; // size of structure + WCHAR FullInfPath[MAX_PATH]; // buffer to hold UNICODE pathname of INF file + INT FilenameOffset; // offset in WCHAR's of filename part (after '\') +} SP_BACKUP_QUEUE_PARAMS_V1_W, *PSP_BACKUP_QUEUE_PARAMS_V1_W; + +#ifdef UNICODE +typedef SP_BACKUP_QUEUE_PARAMS_V1_W SP_BACKUP_QUEUE_PARAMS_V1; +typedef PSP_BACKUP_QUEUE_PARAMS_V1_W PSP_BACKUP_QUEUE_PARAMS_V1; +typedef SP_BACKUP_QUEUE_PARAMS_V2_W SP_BACKUP_QUEUE_PARAMS_V2; +typedef PSP_BACKUP_QUEUE_PARAMS_V2_W PSP_BACKUP_QUEUE_PARAMS_V2; +#else +typedef SP_BACKUP_QUEUE_PARAMS_V1_A SP_BACKUP_QUEUE_PARAMS_V1; +typedef PSP_BACKUP_QUEUE_PARAMS_V1_A PSP_BACKUP_QUEUE_PARAMS_V1; +typedef SP_BACKUP_QUEUE_PARAMS_V2_A SP_BACKUP_QUEUE_PARAMS_V2; +typedef PSP_BACKUP_QUEUE_PARAMS_V2_A PSP_BACKUP_QUEUE_PARAMS_V2; +#endif + + +#if USE_SP_BACKUP_QUEUE_PARAMS_V1 || (_SETUPAPI_VER < _WIN32_WINNT_WINXP) // use version 1 driver info data structure + +typedef SP_BACKUP_QUEUE_PARAMS_V1_A SP_BACKUP_QUEUE_PARAMS_A; +typedef PSP_BACKUP_QUEUE_PARAMS_V1_A PSP_BACKUP_QUEUE_PARAMS_A; +typedef SP_BACKUP_QUEUE_PARAMS_V1_W SP_BACKUP_QUEUE_PARAMS_W; +typedef PSP_BACKUP_QUEUE_PARAMS_V1_W PSP_BACKUP_QUEUE_PARAMS_W; +typedef SP_BACKUP_QUEUE_PARAMS_V1 SP_BACKUP_QUEUE_PARAMS; +typedef PSP_BACKUP_QUEUE_PARAMS_V1 PSP_BACKUP_QUEUE_PARAMS; + +#else // use version 2 driver info data structure + +typedef SP_BACKUP_QUEUE_PARAMS_V2_A SP_BACKUP_QUEUE_PARAMS_A; +typedef PSP_BACKUP_QUEUE_PARAMS_V2_A PSP_BACKUP_QUEUE_PARAMS_A; +typedef SP_BACKUP_QUEUE_PARAMS_V2_W SP_BACKUP_QUEUE_PARAMS_W; +typedef PSP_BACKUP_QUEUE_PARAMS_V2_W PSP_BACKUP_QUEUE_PARAMS_W; +typedef SP_BACKUP_QUEUE_PARAMS_V2 SP_BACKUP_QUEUE_PARAMS; +typedef PSP_BACKUP_QUEUE_PARAMS_V2 PSP_BACKUP_QUEUE_PARAMS; + +#endif // use current version of driver info data structure + + + + + + + + +// +// Setupapi-specific error codes +// +// Inf parse outcomes +// +#define ERROR_EXPECTED_SECTION_NAME (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0) +#define ERROR_BAD_SECTION_NAME_LINE (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|1) +#define ERROR_SECTION_NAME_TOO_LONG (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|2) +#define ERROR_GENERAL_SYNTAX (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|3) +// +// Inf runtime errors +// +#define ERROR_WRONG_INF_STYLE (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x100) +#define ERROR_SECTION_NOT_FOUND (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x101) +#define ERROR_LINE_NOT_FOUND (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x102) +#define ERROR_NO_BACKUP (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x103) +// +// Device Installer/other errors +// +#define ERROR_NO_ASSOCIATED_CLASS (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x200) +#define ERROR_CLASS_MISMATCH (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x201) +#define ERROR_DUPLICATE_FOUND (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x202) +#define ERROR_NO_DRIVER_SELECTED (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x203) +#define ERROR_KEY_DOES_NOT_EXIST (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x204) +#define ERROR_INVALID_DEVINST_NAME (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x205) +#define ERROR_INVALID_CLASS (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x206) +#define ERROR_DEVINST_ALREADY_EXISTS (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x207) +#define ERROR_DEVINFO_NOT_REGISTERED (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x208) +#define ERROR_INVALID_REG_PROPERTY (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x209) +#define ERROR_NO_INF (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x20A) +#define ERROR_NO_SUCH_DEVINST (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x20B) +#define ERROR_CANT_LOAD_CLASS_ICON (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x20C) +#define ERROR_INVALID_CLASS_INSTALLER (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x20D) +#define ERROR_DI_DO_DEFAULT (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x20E) +#define ERROR_DI_NOFILECOPY (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x20F) +#define ERROR_INVALID_HWPROFILE (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x210) +#define ERROR_NO_DEVICE_SELECTED (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x211) +#define ERROR_DEVINFO_LIST_LOCKED (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x212) +#define ERROR_DEVINFO_DATA_LOCKED (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x213) +#define ERROR_DI_BAD_PATH (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x214) +#define ERROR_NO_CLASSINSTALL_PARAMS (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x215) +#define ERROR_FILEQUEUE_LOCKED (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x216) +#define ERROR_BAD_SERVICE_INSTALLSECT (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x217) +#define ERROR_NO_CLASS_DRIVER_LIST (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x218) +#define ERROR_NO_ASSOCIATED_SERVICE (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x219) +#define ERROR_NO_DEFAULT_DEVICE_INTERFACE (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x21A) +#define ERROR_DEVICE_INTERFACE_ACTIVE (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x21B) +#define ERROR_DEVICE_INTERFACE_REMOVED (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x21C) +#define ERROR_BAD_INTERFACE_INSTALLSECT (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x21D) +#define ERROR_NO_SUCH_INTERFACE_CLASS (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x21E) +#define ERROR_INVALID_REFERENCE_STRING (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x21F) +#define ERROR_INVALID_MACHINENAME (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x220) +#define ERROR_REMOTE_COMM_FAILURE (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x221) +#define ERROR_MACHINE_UNAVAILABLE (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x222) +#define ERROR_NO_CONFIGMGR_SERVICES (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x223) +#define ERROR_INVALID_PROPPAGE_PROVIDER (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x224) +#define ERROR_NO_SUCH_DEVICE_INTERFACE (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x225) +#define ERROR_DI_POSTPROCESSING_REQUIRED (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x226) +#define ERROR_INVALID_COINSTALLER (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x227) +#define ERROR_NO_COMPAT_DRIVERS (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x228) +#define ERROR_NO_DEVICE_ICON (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x229) +#define ERROR_INVALID_INF_LOGCONFIG (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x22A) +#define ERROR_DI_DONT_INSTALL (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x22B) +#define ERROR_INVALID_FILTER_DRIVER (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x22C) +#define ERROR_NON_WINDOWS_NT_DRIVER (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x22D) +#define ERROR_NON_WINDOWS_DRIVER (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x22E) +#define ERROR_NO_CATALOG_FOR_OEM_INF (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x22F) +#define ERROR_DEVINSTALL_QUEUE_NONNATIVE (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x230) +#define ERROR_NOT_DISABLEABLE (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x231) +#define ERROR_CANT_REMOVE_DEVINST (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x232) +#define ERROR_INVALID_TARGET (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x233) +#define ERROR_DRIVER_NONNATIVE (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x234) +#define ERROR_IN_WOW64 (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x235) +#define ERROR_SET_SYSTEM_RESTORE_POINT (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x236) + +#define ERROR_SCE_DISABLED (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x238) +#define ERROR_UNKNOWN_EXCEPTION (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x239) +#define ERROR_PNP_REGISTRY_ERROR (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x23A) +#define ERROR_REMOTE_REQUEST_UNSUPPORTED (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x23B) +#define ERROR_NOT_AN_INSTALLED_OEM_INF (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x23C) +#define ERROR_INF_IN_USE_BY_DEVICES (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x23D) +#define ERROR_DI_FUNCTION_OBSOLETE (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x23E) +#define ERROR_NO_AUTHENTICODE_CATALOG (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x23F) +#define ERROR_AUTHENTICODE_DISALLOWED (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x240) +#define ERROR_AUTHENTICODE_TRUSTED_PUBLISHER (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x241) +#define ERROR_AUTHENTICODE_TRUST_NOT_ESTABLISHED (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x242) +#define ERROR_AUTHENTICODE_PUBLISHER_NOT_TRUSTED (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x243) +#define ERROR_SIGNATURE_OSATTRIBUTE_MISMATCH (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x244) +#define ERROR_ONLY_VALIDATE_VIA_AUTHENTICODE (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x245) +#define ERROR_DEVICE_INSTALLER_NOT_READY (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x246) +#define ERROR_DRIVER_STORE_ADD_FAILED (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x247) +#define ERROR_DEVICE_INSTALL_BLOCKED (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x248) +#define ERROR_DRIVER_INSTALL_BLOCKED (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x249) +#define ERROR_WRONG_INF_TYPE (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x24A) +#define ERROR_FILE_HASH_NOT_IN_CATALOG (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x24B) +#define ERROR_DRIVER_STORE_DELETE_FAILED (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x24C) + +// +// Setupapi exception codes +// +#define ERROR_UNRECOVERABLE_STACK_OVERFLOW (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x300) +#define EXCEPTION_SPAPI_UNRECOVERABLE_STACK_OVERFLOW ERROR_UNRECOVERABLE_STACK_OVERFLOW + +// +// Backward compatibility--do not use. +// +#define ERROR_NO_DEFAULT_INTERFACE_DEVICE ERROR_NO_DEFAULT_DEVICE_INTERFACE +#define ERROR_INTERFACE_DEVICE_ACTIVE ERROR_DEVICE_INTERFACE_ACTIVE +#define ERROR_INTERFACE_DEVICE_REMOVED ERROR_DEVICE_INTERFACE_REMOVED +#define ERROR_NO_SUCH_INTERFACE_DEVICE ERROR_NO_SUCH_DEVICE_INTERFACE + + +// +// Win9x migration DLL error code +// +#define ERROR_NOT_INSTALLED (APPLICATION_ERROR_MASK|ERROR_SEVERITY_ERROR|0x1000) + + +WINSETUPAPI +BOOL +WINAPI +SetupGetInfInformationA( + __in LPCVOID InfSpec, + __in DWORD SearchControl, + __out_bcount_opt(ReturnBufferSize) PSP_INF_INFORMATION ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupGetInfInformationW( + __in LPCVOID InfSpec, + __in DWORD SearchControl, + __out_bcount_opt(ReturnBufferSize) PSP_INF_INFORMATION ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +// +// SearchControl flags for SetupGetInfInformation +// +#define INFINFO_INF_SPEC_IS_HINF 1 +#define INFINFO_INF_NAME_IS_ABSOLUTE 2 +#define INFINFO_DEFAULT_SEARCH 3 +#define INFINFO_REVERSE_DEFAULT_SEARCH 4 +#define INFINFO_INF_PATH_LIST_SEARCH 5 + +#ifdef UNICODE +#define SetupGetInfInformation SetupGetInfInformationW +#else +#define SetupGetInfInformation SetupGetInfInformationA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupQueryInfFileInformationA( + __in PSP_INF_INFORMATION InfInformation, + __in UINT InfIndex, + __out_ecount_opt(ReturnBufferSize) PSTR ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupQueryInfFileInformationW( + __in PSP_INF_INFORMATION InfInformation, + __in UINT InfIndex, + __out_ecount_opt(ReturnBufferSize) PWSTR ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +#ifdef UNICODE +#define SetupQueryInfFileInformation SetupQueryInfFileInformationW +#else +#define SetupQueryInfFileInformation SetupQueryInfFileInformationA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupQueryInfOriginalFileInformationA( + __in PSP_INF_INFORMATION InfInformation, + __in UINT InfIndex, + __in_opt PSP_ALTPLATFORM_INFO AlternatePlatformInfo, + __out PSP_ORIGINAL_FILE_INFO_A OriginalFileInfo + ); + +WINSETUPAPI +BOOL +WINAPI +SetupQueryInfOriginalFileInformationW( + __in PSP_INF_INFORMATION InfInformation, + __in UINT InfIndex, + __in_opt PSP_ALTPLATFORM_INFO AlternatePlatformInfo, + __out PSP_ORIGINAL_FILE_INFO_W OriginalFileInfo + ); + +#ifdef UNICODE +#define SetupQueryInfOriginalFileInformation SetupQueryInfOriginalFileInformationW +#else +#define SetupQueryInfOriginalFileInformation SetupQueryInfOriginalFileInformationA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupQueryInfVersionInformationA( + __in PSP_INF_INFORMATION InfInformation, + __in UINT InfIndex, + __in_opt PCSTR Key, + __out_ecount_opt(ReturnBufferSize) PSTR ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupQueryInfVersionInformationW( + __in PSP_INF_INFORMATION InfInformation, + __in UINT InfIndex, + __in_opt PCWSTR Key, + __out_ecount_opt(ReturnBufferSize) PWSTR ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +#ifdef UNICODE +#define SetupQueryInfVersionInformation SetupQueryInfVersionInformationW +#else +#define SetupQueryInfVersionInformation SetupQueryInfVersionInformationA +#endif + + +#if _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + +WINSETUPAPI +BOOL +WINAPI +SetupGetInfDriverStoreLocationA( + __in PCSTR FileName, + __in_opt PSP_ALTPLATFORM_INFO AlternatePlatformInfo, + __in_opt PCSTR LocaleName, + __out_ecount(ReturnBufferSize) PSTR ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupGetInfDriverStoreLocationW( + __in PCWSTR FileName, + __in_opt PSP_ALTPLATFORM_INFO AlternatePlatformInfo, + __in_opt PCWSTR LocaleName, + __out_ecount(ReturnBufferSize) PWSTR ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +#ifdef UNICODE +#define SetupGetInfDriverStoreLocation SetupGetInfDriverStoreLocationW +#else +#define SetupGetInfDriverStoreLocation SetupGetInfDriverStoreLocationA +#endif + +WINSETUPAPI +BOOL +WINAPI +SetupGetInfPublishedNameA( + __in PCSTR DriverStoreLocation, + __out_ecount(ReturnBufferSize) PSTR ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupGetInfPublishedNameW( + __in PCWSTR DriverStoreLocation, + __out_ecount(ReturnBufferSize) PWSTR ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +#ifdef UNICODE +#define SetupGetInfPublishedName SetupGetInfPublishedNameW +#else +#define SetupGetInfPublishedName SetupGetInfPublishedNameA +#endif + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + + +WINSETUPAPI +BOOL +WINAPI +SetupGetInfFileListA( + __in_opt PCSTR DirectoryPath, + __in DWORD InfStyle, + __out_ecount_opt(ReturnBufferSize) PSTR ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupGetInfFileListW( + __in_opt PCWSTR DirectoryPath, + __in DWORD InfStyle, + __out_ecount(ReturnBufferSize) PWSTR ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +#ifdef UNICODE +#define SetupGetInfFileList SetupGetInfFileListW +#else +#define SetupGetInfFileList SetupGetInfFileListA +#endif + + +WINSETUPAPI +HINF +WINAPI +SetupOpenInfFileW( + __in PCWSTR FileName, + __in_opt PCWSTR InfClass, + __in DWORD InfStyle, + __out_opt PUINT ErrorLine + ); + +WINSETUPAPI +HINF +WINAPI +SetupOpenInfFileA( + __in PCSTR FileName, + __in_opt PCSTR InfClass, + __in DWORD InfStyle, + __out_opt PUINT ErrorLine + ); + +#ifdef UNICODE +#define SetupOpenInfFile SetupOpenInfFileW +#else +#define SetupOpenInfFile SetupOpenInfFileA +#endif + + +WINSETUPAPI +HINF +WINAPI +SetupOpenMasterInf( + VOID + ); + + +WINSETUPAPI +BOOL +WINAPI +SetupOpenAppendInfFileW( + __in_opt PCWSTR FileName, + __in HINF InfHandle, + __out_opt PUINT ErrorLine + ); + +WINSETUPAPI +BOOL +WINAPI +SetupOpenAppendInfFileA( + __in_opt PCSTR FileName, + __in HINF InfHandle, + __out_opt PUINT ErrorLine + ); + +#ifdef UNICODE +#define SetupOpenAppendInfFile SetupOpenAppendInfFileW +#else +#define SetupOpenAppendInfFile SetupOpenAppendInfFileA +#endif + + +WINSETUPAPI +VOID +WINAPI +SetupCloseInfFile( + __in HINF InfHandle + ); + + +WINSETUPAPI +BOOL +WINAPI +SetupFindFirstLineA( + __in HINF InfHandle, + __in PCSTR Section, + __in_opt PCSTR Key, + __out PINFCONTEXT Context + ); + +WINSETUPAPI +BOOL +WINAPI +SetupFindFirstLineW( + __in HINF InfHandle, + __in PCWSTR Section, + __in_opt PCWSTR Key, + __out PINFCONTEXT Context + ); + +#ifdef UNICODE +#define SetupFindFirstLine SetupFindFirstLineW +#else +#define SetupFindFirstLine SetupFindFirstLineA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupFindNextLine( + __in PINFCONTEXT ContextIn, + __out PINFCONTEXT ContextOut + ); + + +WINSETUPAPI +BOOL +WINAPI +SetupFindNextMatchLineA( + __in PINFCONTEXT ContextIn, + __in_opt PCSTR Key, + __out PINFCONTEXT ContextOut + ); + +WINSETUPAPI +BOOL +WINAPI +SetupFindNextMatchLineW( + __in PINFCONTEXT ContextIn, + __in_opt PCWSTR Key, + __out PINFCONTEXT ContextOut + ); + +#ifdef UNICODE +#define SetupFindNextMatchLine SetupFindNextMatchLineW +#else +#define SetupFindNextMatchLine SetupFindNextMatchLineA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupGetLineByIndexA( + __in HINF InfHandle, + __in PCSTR Section, + __in DWORD Index, + __out PINFCONTEXT Context + ); + +WINSETUPAPI +BOOL +WINAPI +SetupGetLineByIndexW( + __in HINF InfHandle, + __in PCWSTR Section, + __in DWORD Index, + __out PINFCONTEXT Context + ); + +#ifdef UNICODE +#define SetupGetLineByIndex SetupGetLineByIndexW +#else +#define SetupGetLineByIndex SetupGetLineByIndexA +#endif + + +WINSETUPAPI +LONG +WINAPI +SetupGetLineCountA( + __in HINF InfHandle, + __in PCSTR Section + ); + +WINSETUPAPI +LONG +WINAPI +SetupGetLineCountW( + __in HINF InfHandle, + __in PCWSTR Section + ); + +#ifdef UNICODE +#define SetupGetLineCount SetupGetLineCountW +#else +#define SetupGetLineCount SetupGetLineCountA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupGetLineTextA( + __in_opt PINFCONTEXT Context, + __in_opt HINF InfHandle, + __in_opt PCSTR Section, + __in_opt PCSTR Key, + __out_ecount_opt(ReturnBufferSize) PSTR ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupGetLineTextW( + __in_opt PINFCONTEXT Context, + __in_opt HINF InfHandle, + __in_opt PCWSTR Section, + __in_opt PCWSTR Key, + __out_ecount_opt(ReturnBufferSize) PWSTR ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +#ifdef UNICODE +#define SetupGetLineText SetupGetLineTextW +#else +#define SetupGetLineText SetupGetLineTextA +#endif + + +WINSETUPAPI +DWORD +WINAPI +SetupGetFieldCount( + __in PINFCONTEXT Context + ); + + +WINSETUPAPI +BOOL +WINAPI +SetupGetStringFieldA( + __in PINFCONTEXT Context, + __in DWORD FieldIndex, + __out_ecount_opt(ReturnBufferSize) PSTR ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupGetStringFieldW( + __in PINFCONTEXT Context, + __in DWORD FieldIndex, + __out_ecount_opt(ReturnBufferSize) PWSTR ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +#ifdef UNICODE +#define SetupGetStringField SetupGetStringFieldW +#else +#define SetupGetStringField SetupGetStringFieldA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupGetIntField( + __in PINFCONTEXT Context, + __in DWORD FieldIndex, + __out PINT IntegerValue + ); + + +WINSETUPAPI +BOOL +WINAPI +SetupGetMultiSzFieldA( + __in PINFCONTEXT Context, + __in DWORD FieldIndex, + __out_ecount_opt(ReturnBufferSize) PSTR ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt LPDWORD RequiredSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupGetMultiSzFieldW( + __in PINFCONTEXT Context, + __in DWORD FieldIndex, + __out_ecount_opt(ReturnBufferSize) PWSTR ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt LPDWORD RequiredSize + ); + +#ifdef UNICODE +#define SetupGetMultiSzField SetupGetMultiSzFieldW +#else +#define SetupGetMultiSzField SetupGetMultiSzFieldA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupGetBinaryField( + __in PINFCONTEXT Context, + __in DWORD FieldIndex, + __out_bcount_opt(ReturnBufferSize) PBYTE ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt LPDWORD RequiredSize + ); + +// +// SetupGetFileCompressionInfo is depreciated +// use SetupGetFileCompressionInfoEx instead +// +// ActualSourceFileName returned by SetupGetFileCompressionInfo +// must be freed by the export setupapi!MyFree (NT4+ Win95+) +// or LocalFree (Win2k+) +// +WINSETUPAPI +DWORD +WINAPI +SetupGetFileCompressionInfoA( + __in PCSTR SourceFileName, + __out PSTR *ActualSourceFileName, + __out PDWORD SourceFileSize, + __out PDWORD TargetFileSize, + __out PUINT CompressionType + ); + +WINSETUPAPI +DWORD +WINAPI +SetupGetFileCompressionInfoW( + __in PCWSTR SourceFileName, + __out PWSTR *ActualSourceFileName, + __out PDWORD SourceFileSize, + __out PDWORD TargetFileSize, + __out PUINT CompressionType + ); + +#ifdef UNICODE +#define SetupGetFileCompressionInfo SetupGetFileCompressionInfoW +#else +#define SetupGetFileCompressionInfo SetupGetFileCompressionInfoA +#endif + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +// +// SetupGetFileCompressionInfoEx is the preferred API over +// SetupGetFileCompressionInfo. It follows the normal +// conventions of returning BOOL and writing to user-supplied +// buffer. +// + +WINSETUPAPI +BOOL +WINAPI +SetupGetFileCompressionInfoExA( + __in PCSTR SourceFileName, + __in_ecount_opt(ActualSourceFileNameBufferLen) PSTR ActualSourceFileNameBuffer, + __in DWORD ActualSourceFileNameBufferLen, + __out_opt PDWORD RequiredBufferLen, + __out PDWORD SourceFileSize, + __out PDWORD TargetFileSize, + __out PUINT CompressionType + ); + +WINSETUPAPI +BOOL +WINAPI +SetupGetFileCompressionInfoExW( + __in PCWSTR SourceFileName, + __in_ecount_opt(ActualSourceFileNameBufferLen) PWSTR ActualSourceFileNameBuffer, + __in DWORD ActualSourceFileNameBufferLen, + __out_opt PDWORD RequiredBufferLen, + __out PDWORD SourceFileSize, + __out PDWORD TargetFileSize, + __out PUINT CompressionType + ); + +#ifdef UNICODE +#define SetupGetFileCompressionInfoEx SetupGetFileCompressionInfoExW +#else +#define SetupGetFileCompressionInfoEx SetupGetFileCompressionInfoExA +#endif + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +// +// Compression types +// +#define FILE_COMPRESSION_NONE 0 +#define FILE_COMPRESSION_WINLZA 1 +#define FILE_COMPRESSION_MSZIP 2 +#define FILE_COMPRESSION_NTCAB 3 + + +WINSETUPAPI +DWORD +WINAPI +SetupDecompressOrCopyFileA( + __in PCSTR SourceFileName, + __in PCSTR TargetFileName, + __in_opt PUINT CompressionType + ); + +WINSETUPAPI +DWORD +WINAPI +SetupDecompressOrCopyFileW( + __in PCWSTR SourceFileName, + __in PCWSTR TargetFileName, + __in_opt PUINT CompressionType + ); + +#ifdef UNICODE +#define SetupDecompressOrCopyFile SetupDecompressOrCopyFileW +#else +#define SetupDecompressOrCopyFile SetupDecompressOrCopyFileA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupGetSourceFileLocationA( + __in HINF InfHandle, + __in_opt PINFCONTEXT InfContext, + __in_opt PCSTR FileName, + __out PUINT SourceId, + __out_ecount_opt(ReturnBufferSize) PSTR ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupGetSourceFileLocationW( + __in HINF InfHandle, + __in_opt PINFCONTEXT InfContext, + __in_opt PCWSTR FileName, + __out PUINT SourceId, + __out_ecount_opt(ReturnBufferSize) PWSTR ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +#ifdef UNICODE +#define SetupGetSourceFileLocation SetupGetSourceFileLocationW +#else +#define SetupGetSourceFileLocation SetupGetSourceFileLocationA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupGetSourceFileSizeA( + __in HINF InfHandle, + __in_opt PINFCONTEXT InfContext, + __in_opt PCSTR FileName, + __in_opt PCSTR Section, + __out PDWORD FileSize, + __in UINT RoundingFactor + ); + +WINSETUPAPI +BOOL +WINAPI +SetupGetSourceFileSizeW( + __in HINF InfHandle, + __in_opt PINFCONTEXT InfContext, + __in_opt PCWSTR FileName, + __in_opt PCWSTR Section, + __out PDWORD FileSize, + __in UINT RoundingFactor + ); + +#ifdef UNICODE +#define SetupGetSourceFileSize SetupGetSourceFileSizeW +#else +#define SetupGetSourceFileSize SetupGetSourceFileSizeA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupGetTargetPathA( + __in HINF InfHandle, + __in_opt PINFCONTEXT InfContext, + __in_opt PCSTR Section, + __out_ecount_opt(ReturnBufferSize) PSTR ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupGetTargetPathW( + __in HINF InfHandle, + __in_opt PINFCONTEXT InfContext, + __in_opt PCWSTR Section, + __out_ecount_opt(ReturnBufferSize) PWSTR ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +#ifdef UNICODE +#define SetupGetTargetPath SetupGetTargetPathW +#else +#define SetupGetTargetPath SetupGetTargetPathA +#endif + + +// +// Define flags for SourceList APIs. +// +#define SRCLIST_TEMPORARY 0x00000001 +#define SRCLIST_NOBROWSE 0x00000002 +#define SRCLIST_SYSTEM 0x00000010 +#define SRCLIST_USER 0x00000020 +#define SRCLIST_SYSIFADMIN 0x00000040 +#define SRCLIST_SUBDIRS 0x00000100 +#define SRCLIST_APPEND 0x00000200 +#define SRCLIST_NOSTRIPPLATFORM 0x00000400 + + +WINSETUPAPI +BOOL +WINAPI +SetupSetSourceListA( + __in DWORD Flags, + __in_ecount(SourceCount) PCSTR *SourceList, + __in UINT SourceCount + ); + +WINSETUPAPI +BOOL +WINAPI +SetupSetSourceListW( + __in DWORD Flags, + __in_ecount(SourceCount) PCWSTR *SourceList, + __in UINT SourceCount + ); + +#ifdef UNICODE +#define SetupSetSourceList SetupSetSourceListW +#else +#define SetupSetSourceList SetupSetSourceListA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupCancelTemporarySourceList( + VOID + ); + + +WINSETUPAPI +BOOL +WINAPI +SetupAddToSourceListA( + __in DWORD Flags, + __in PCSTR Source + ); + +WINSETUPAPI +BOOL +WINAPI +SetupAddToSourceListW( + __in DWORD Flags, + __in PCWSTR Source + ); + +#ifdef UNICODE +#define SetupAddToSourceList SetupAddToSourceListW +#else +#define SetupAddToSourceList SetupAddToSourceListA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupRemoveFromSourceListA( + __in DWORD Flags, + __in PCSTR Source + ); + +WINSETUPAPI +BOOL +WINAPI +SetupRemoveFromSourceListW( + __in DWORD Flags, + __in PCWSTR Source + ); + +#ifdef UNICODE +#define SetupRemoveFromSourceList SetupRemoveFromSourceListW +#else +#define SetupRemoveFromSourceList SetupRemoveFromSourceListA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupQuerySourceListA( + __in DWORD Flags, + __deref_out_ecount(*Count) PCSTR **List, + __out PUINT Count + ); + +WINSETUPAPI +BOOL +WINAPI +SetupQuerySourceListW( + __in DWORD Flags, + __deref_out_ecount(*Count) PCWSTR **List, + __out PUINT Count + ); + +#ifdef UNICODE +#define SetupQuerySourceList SetupQuerySourceListW +#else +#define SetupQuerySourceList SetupQuerySourceListA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupFreeSourceListA( + __deref_inout_ecount(Count) PCSTR **List, + __in UINT Count + ); + +WINSETUPAPI +BOOL +WINAPI +SetupFreeSourceListW( + __deref_inout_ecount(Count) PCWSTR **List, + __in UINT Count + ); + +#ifdef UNICODE +#define SetupFreeSourceList SetupFreeSourceListW +#else +#define SetupFreeSourceList SetupFreeSourceListA +#endif + + +WINSETUPAPI +UINT +WINAPI +SetupPromptForDiskA( + __in HWND hwndParent, + __in_opt PCSTR DialogTitle, + __in_opt PCSTR DiskName, + __in_opt PCSTR PathToSource, + __in PCSTR FileSought, + __in_opt PCSTR TagFile, + __in DWORD DiskPromptStyle, + __out_ecount_opt(PathBufferSize) PSTR PathBuffer, + __in DWORD PathBufferSize, + __out_opt PDWORD PathRequiredSize + ); + +WINSETUPAPI +UINT +WINAPI +SetupPromptForDiskW( + __in HWND hwndParent, + __in_opt PCWSTR DialogTitle, + __in_opt PCWSTR DiskName, + __in_opt PCWSTR PathToSource, + __in PCWSTR FileSought, + __in_opt PCWSTR TagFile, + __in DWORD DiskPromptStyle, + __out_ecount_opt(PathBufferSize) PWSTR PathBuffer, + __in DWORD PathBufferSize, + __out_opt PDWORD PathRequiredSize + ); + +#ifdef UNICODE +#define SetupPromptForDisk SetupPromptForDiskW +#else +#define SetupPromptForDisk SetupPromptForDiskA +#endif + + +WINSETUPAPI +UINT +WINAPI +SetupCopyErrorA( + __in HWND hwndParent, + __in_opt PCSTR DialogTitle, + __in_opt PCSTR DiskName, + __in PCSTR PathToSource, + __in PCSTR SourceFile, + __in_opt PCSTR TargetPathFile, + __in UINT Win32ErrorCode, + __in DWORD Style, + __out_ecount_opt(PathBufferSize) PSTR PathBuffer, + __in DWORD PathBufferSize, + __out_opt PDWORD PathRequiredSize + ); + +WINSETUPAPI +UINT +WINAPI +SetupCopyErrorW( + __in HWND hwndParent, + __in_opt PCWSTR DialogTitle, + __in_opt PCWSTR DiskName, + __in PCWSTR PathToSource, + __in PCWSTR SourceFile, + __in_opt PCWSTR TargetPathFile, + __in UINT Win32ErrorCode, + __in DWORD Style, + __out_ecount_opt(PathBufferSize) PWSTR PathBuffer, + __in DWORD PathBufferSize, + __out_opt PDWORD PathRequiredSize + ); + +#ifdef UNICODE +#define SetupCopyError SetupCopyErrorW +#else +#define SetupCopyError SetupCopyErrorA +#endif + + +WINSETUPAPI +UINT +WINAPI +SetupRenameErrorA( + __in HWND hwndParent, + __in_opt PCSTR DialogTitle, + __in PCSTR SourceFile, + __in PCSTR TargetFile, + __in UINT Win32ErrorCode, + __in DWORD Style + ); + +WINSETUPAPI +UINT +WINAPI +SetupRenameErrorW( + __in HWND hwndParent, + __in_opt PCWSTR DialogTitle, + __in PCWSTR SourceFile, + __in PCWSTR TargetFile, + __in UINT Win32ErrorCode, + __in DWORD Style + ); + +#ifdef UNICODE +#define SetupRenameError SetupRenameErrorW +#else +#define SetupRenameError SetupRenameErrorA +#endif + + +WINSETUPAPI +UINT +WINAPI +SetupDeleteErrorA( + __in HWND hwndParent, + __in_opt PCSTR DialogTitle, + __in PCSTR File, + __in UINT Win32ErrorCode, + __in DWORD Style + ); + +WINSETUPAPI +UINT +WINAPI +SetupDeleteErrorW( + __in HWND hwndParent, + __in_opt PCWSTR DialogTitle, + __in PCWSTR File, + __in UINT Win32ErrorCode, + __in DWORD Style + ); + +#ifdef UNICODE +#define SetupDeleteError SetupDeleteErrorW +#else +#define SetupDeleteError SetupDeleteErrorA +#endif + +WINSETUPAPI +UINT +WINAPI +SetupBackupErrorA( + __in HWND hwndParent, + __in_opt PCSTR DialogTitle, + __in PCSTR SourceFile, + __in_opt PCSTR TargetFile, + __in UINT Win32ErrorCode, + __in DWORD Style + ); + +WINSETUPAPI +UINT +WINAPI +SetupBackupErrorW( + __in HWND hwndParent, + __in_opt PCWSTR DialogTitle, + __in PCWSTR SourceFile, + __in_opt PCWSTR TargetFile, + __in UINT Win32ErrorCode, + __in DWORD Style + ); + +#ifdef UNICODE +#define SetupBackupError SetupBackupErrorW +#else +#define SetupBackupError SetupBackupErrorA +#endif + + +// +// Styles for SetupPromptForDisk, SetupCopyError, +// SetupRenameError, SetupDeleteError +// +#define IDF_NOBROWSE 0x00000001 +#define IDF_NOSKIP 0x00000002 +#define IDF_NODETAILS 0x00000004 +#define IDF_NOCOMPRESSED 0x00000008 +#define IDF_CHECKFIRST 0x00000100 +#define IDF_NOBEEP 0x00000200 +#define IDF_NOFOREGROUND 0x00000400 +#define IDF_WARNIFSKIP 0x00000800 + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +#define IDF_NOREMOVABLEMEDIAPROMPT 0x00001000 +#define IDF_USEDISKNAMEASPROMPT 0x00002000 +#define IDF_OEMDISK 0x80000000 + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +// +// Return values for SetupPromptForDisk, SetupCopyError, +// SetupRenameError, SetupDeleteError, SetupBackupError +// +#define DPROMPT_SUCCESS 0 +#define DPROMPT_CANCEL 1 +#define DPROMPT_SKIPFILE 2 +#define DPROMPT_BUFFERTOOSMALL 3 +#define DPROMPT_OUTOFMEMORY 4 + + +WINSETUPAPI +BOOL +WINAPI +SetupSetDirectoryIdA( + __in HINF InfHandle, + __in DWORD Id, + __in_opt PCSTR Directory + ); + +WINSETUPAPI +BOOL +WINAPI +SetupSetDirectoryIdW( + __in HINF InfHandle, + __in DWORD Id, + __in_opt PCWSTR Directory + ); + +#ifdef UNICODE +#define SetupSetDirectoryId SetupSetDirectoryIdW +#else +#define SetupSetDirectoryId SetupSetDirectoryIdA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupSetDirectoryIdExA( + __in HINF InfHandle, + __in DWORD Id, + __in_opt PCSTR Directory, + __in DWORD Flags, + __reserved DWORD Reserved1, + __reserved PVOID Reserved2 + ); + +WINSETUPAPI +BOOL +WINAPI +SetupSetDirectoryIdExW( + __in HINF InfHandle, + __in DWORD Id, + __in_opt PCWSTR Directory, + __in DWORD Flags, + __reserved DWORD Reserved1, + __reserved PVOID Reserved2 + ); + +#ifdef UNICODE +#define SetupSetDirectoryIdEx SetupSetDirectoryIdExW +#else +#define SetupSetDirectoryIdEx SetupSetDirectoryIdExA +#endif + +// +// Flags for SetupSetDirectoryIdEx +// +#define SETDIRID_NOT_FULL_PATH 0x00000001 + + +WINSETUPAPI +BOOL +WINAPI +SetupGetSourceInfoA( + __in HINF InfHandle, + __in UINT SourceId, + __in UINT InfoDesired, + __out_ecount_opt(ReturnBufferSize) PSTR ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupGetSourceInfoW( + __in HINF InfHandle, + __in UINT SourceId, + __in UINT InfoDesired, + __out_ecount_opt(ReturnBufferSize) PWSTR ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +#ifdef UNICODE +#define SetupGetSourceInfo SetupGetSourceInfoW +#else +#define SetupGetSourceInfo SetupGetSourceInfoA +#endif + +// +// InfoDesired values for SetupGetSourceInfo +// + +#define SRCINFO_PATH 1 +#define SRCINFO_TAGFILE 2 +#define SRCINFO_DESCRIPTION 3 +#define SRCINFO_FLAGS 4 + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP +// +// SRC_FLAGS allow special treatment of source +// lower 4 bits are reserved for OS use +// the flags may determine what other parameters exist +// +#define SRCINFO_TAGFILE2 5 // alternate tagfile, when SRCINFO_TAGFILE is a cabfile + +#define SRC_FLAGS_CABFILE (0x0010) // if set, treat SRCINFO_TAGFILE as a cabfile and specify alternate tagfile + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +WINSETUPAPI +BOOL +WINAPI +SetupInstallFileA( + __in_opt HINF InfHandle, + __in_opt PINFCONTEXT InfContext, + __in_opt PCSTR SourceFile, + __in_opt PCSTR SourcePathRoot, + __in_opt PCSTR DestinationName, + __in DWORD CopyStyle, + __in_opt PSP_FILE_CALLBACK_A CopyMsgHandler, + __in_opt PVOID Context + ); + +WINSETUPAPI +BOOL +WINAPI +SetupInstallFileW( + __in_opt HINF InfHandle, + __in_opt PINFCONTEXT InfContext, + __in_opt PCWSTR SourceFile, + __in_opt PCWSTR SourcePathRoot, + __in_opt PCWSTR DestinationName, + __in DWORD CopyStyle, + __in_opt PSP_FILE_CALLBACK_W CopyMsgHandler, + __in_opt PVOID Context + ); + +#ifdef UNICODE +#define SetupInstallFile SetupInstallFileW +#else +#define SetupInstallFile SetupInstallFileA +#endif + +WINSETUPAPI +BOOL +WINAPI +SetupInstallFileExA( + __in_opt HINF InfHandle, + __in_opt PINFCONTEXT InfContext, + __in_opt PCSTR SourceFile, + __in_opt PCSTR SourcePathRoot, + __in_opt PCSTR DestinationName, + __in DWORD CopyStyle, + __in_opt PSP_FILE_CALLBACK_A CopyMsgHandler, + __in_opt PVOID Context, + __out PBOOL FileWasInUse + ); + +WINSETUPAPI +BOOL +WINAPI +SetupInstallFileExW( + __in_opt HINF InfHandle, + __in_opt PINFCONTEXT InfContext, + __in_opt PCWSTR SourceFile, + __in_opt PCWSTR SourcePathRoot, + __in_opt PCWSTR DestinationName, + __in DWORD CopyStyle, + __in_opt PSP_FILE_CALLBACK_W CopyMsgHandler, + __in_opt PVOID Context, + __out PBOOL FileWasInUse + ); + +#ifdef UNICODE +#define SetupInstallFileEx SetupInstallFileExW +#else +#define SetupInstallFileEx SetupInstallFileExA +#endif + +// +// CopyStyle values for copy and queue-related APIs +// +#define SP_COPY_DELETESOURCE 0x0000001 // delete source file on successful copy +#define SP_COPY_REPLACEONLY 0x0000002 // copy only if target file already present +#define SP_COPY_NEWER 0x0000004 // copy only if source newer than or same as target +#define SP_COPY_NEWER_OR_SAME SP_COPY_NEWER +#define SP_COPY_NOOVERWRITE 0x0000008 // copy only if target doesn't exist +#define SP_COPY_NODECOMP 0x0000010 // don't decompress source file while copying +#define SP_COPY_LANGUAGEAWARE 0x0000020 // don't overwrite file of different language +#define SP_COPY_SOURCE_ABSOLUTE 0x0000040 // SourceFile is a full source path +#define SP_COPY_SOURCEPATH_ABSOLUTE 0x0000080 // SourcePathRoot is the full path +#define SP_COPY_IN_USE_NEEDS_REBOOT 0x0000100 // System needs reboot if file in use +#define SP_COPY_FORCE_IN_USE 0x0000200 // Force target-in-use behavior +#define SP_COPY_NOSKIP 0x0000400 // Skip is disallowed for this file or section +#define SP_FLAG_CABINETCONTINUATION 0x0000800 // Used with need media notification +#define SP_COPY_FORCE_NOOVERWRITE 0x0001000 // like NOOVERWRITE but no callback nofitication +#define SP_COPY_FORCE_NEWER 0x0002000 // like NEWER but no callback nofitication +#define SP_COPY_WARNIFSKIP 0x0004000 // system critical file: warn if user tries to skip +#define SP_COPY_NOBROWSE 0x0008000 // Browsing is disallowed for this file or section +#define SP_COPY_NEWER_ONLY 0x0010000 // copy only if source file newer than target +#define SP_COPY_RESERVED 0x0020000 // was: SP_COPY_SOURCE_SIS_MASTER (deprecated) +#define SP_COPY_OEMINF_CATALOG_ONLY 0x0040000 // (SetupCopyOEMInf only) don't copy INF--just catalog +#define SP_COPY_REPLACE_BOOT_FILE 0x0080000 // file must be present upon reboot (i.e., it's + // needed by the loader); this flag implies a reboot +#define SP_COPY_NOPRUNE 0x0100000 // never prune this file + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +#define SP_COPY_OEM_F6_INF 0x0200000 // Used when calling SetupCopyOemInf + +#endif //_SETUPAPI_VER >= _WIN32_WINNT_WINXP + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +#define SP_COPY_ALREADYDECOMP 0x0400000 // similar to SP_COPY_NODECOMP + +#endif //_SETUPAPI_VER >= _WIN32_WINNT_WINXP + +#if _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + +#define SP_COPY_WINDOWS_SIGNED 0x1000000 // BuildLab or WinSE signed +#define SP_COPY_PNPLOCKED 0x2000000 // Used with the signature flag +#define SP_COPY_IN_USE_TRY_RENAME 0x4000000 // If file in use, try to rename the target first +#define SP_COPY_INBOX_INF 0x8000000 // Referred by CopyFiles of inbox inf + +#endif //_SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + +#if _SETUPAPI_VER >= _WIN32_WINNT_WIN7 + +#define SP_COPY_HARDLINK 0x10000000 // Copy using hardlink, if possible + +#endif + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +// +// Flags passed to Backup notification +// +#define SP_BACKUP_BACKUPPASS 0x00000001 // file backed up during backup pass +#define SP_BACKUP_DEMANDPASS 0x00000002 // file backed up on demand +#define SP_BACKUP_SPECIAL 0x00000004 // if set, special type of backup +#define SP_BACKUP_BOOTFILE 0x00000008 // file marked with COPYFLG_REPLACE_BOOT_FILE + + +#endif //_SETUPAPI_VER >= _WIN32_WINNT_WINXP + + +WINSETUPAPI +HSPFILEQ +WINAPI +SetupOpenFileQueue( + VOID + ); + +WINSETUPAPI +BOOL +WINAPI +SetupCloseFileQueue( + __in HSPFILEQ QueueHandle + ); + +WINSETUPAPI +BOOL +WINAPI +SetupSetFileQueueAlternatePlatformA( + __in HSPFILEQ QueueHandle, + __in_opt PSP_ALTPLATFORM_INFO AlternatePlatformInfo, + __in_opt PCSTR AlternateDefaultCatalogFile + ); + +WINSETUPAPI +BOOL +WINAPI +SetupSetFileQueueAlternatePlatformW( + __in HSPFILEQ QueueHandle, + __in_opt PSP_ALTPLATFORM_INFO AlternatePlatformInfo, + __in_opt PCWSTR AlternateDefaultCatalogFile + ); + +#ifdef UNICODE +#define SetupSetFileQueueAlternatePlatform SetupSetFileQueueAlternatePlatformW +#else +#define SetupSetFileQueueAlternatePlatform SetupSetFileQueueAlternatePlatformA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupSetPlatformPathOverrideA( + __in_opt PCSTR Override + ); + +WINSETUPAPI +BOOL +WINAPI +SetupSetPlatformPathOverrideW( + __in_opt PCWSTR Override + ); + +#ifdef UNICODE +#define SetupSetPlatformPathOverride SetupSetPlatformPathOverrideW +#else +#define SetupSetPlatformPathOverride SetupSetPlatformPathOverrideA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupQueueCopyA( + __in HSPFILEQ QueueHandle, + __in_opt PCSTR SourceRootPath, + __in_opt PCSTR SourcePath, + __in PCSTR SourceFilename, + __in_opt PCSTR SourceDescription, + __in_opt PCSTR SourceTagfile, + __in PCSTR TargetDirectory, + __in_opt PCSTR TargetFilename, + __in DWORD CopyStyle + ); + +WINSETUPAPI +BOOL +WINAPI +SetupQueueCopyW( + __in HSPFILEQ QueueHandle, + __in_opt PCWSTR SourceRootPath, + __in_opt PCWSTR SourcePath, + __in PCWSTR SourceFilename, + __in_opt PCWSTR SourceDescription, + __in_opt PCWSTR SourceTagfile, + __in PCWSTR TargetDirectory, + __in_opt PCWSTR TargetFilename, + __in DWORD CopyStyle + ); + +#ifdef UNICODE +#define SetupQueueCopy SetupQueueCopyW +#else +#define SetupQueueCopy SetupQueueCopyA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupQueueCopyIndirectA( + __in PSP_FILE_COPY_PARAMS_A CopyParams + ); + +WINSETUPAPI +BOOL +WINAPI +SetupQueueCopyIndirectW( + __in PSP_FILE_COPY_PARAMS_W CopyParams + ); + +#ifdef UNICODE +#define SetupQueueCopyIndirect SetupQueueCopyIndirectW +#else +#define SetupQueueCopyIndirect SetupQueueCopyIndirectA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupQueueDefaultCopyA( + __in HSPFILEQ QueueHandle, + __in HINF InfHandle, + __in_opt PCSTR SourceRootPath, + __in PCSTR SourceFilename, + __in_opt PCSTR TargetFilename, + __in DWORD CopyStyle + ); + +WINSETUPAPI +BOOL +WINAPI +SetupQueueDefaultCopyW( + __in HSPFILEQ QueueHandle, + __in HINF InfHandle, + __in_opt PCWSTR SourceRootPath, + __in PCWSTR SourceFilename, + __in_opt PCWSTR TargetFilename, + __in DWORD CopyStyle + ); + +#ifdef UNICODE +#define SetupQueueDefaultCopy SetupQueueDefaultCopyW +#else +#define SetupQueueDefaultCopy SetupQueueDefaultCopyA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupQueueCopySectionA( + __in HSPFILEQ QueueHandle, + __in_opt PCSTR SourceRootPath, + __in HINF InfHandle, + __in_opt HINF ListInfHandle, + __in PCSTR Section, + __in DWORD CopyStyle + ); + +WINSETUPAPI +BOOL +WINAPI +SetupQueueCopySectionW( + __in HSPFILEQ QueueHandle, + __in_opt PCWSTR SourceRootPath, + __in HINF InfHandle, + __in_opt HINF ListInfHandle, + __in PCWSTR Section, + __in DWORD CopyStyle + ); + +#ifdef UNICODE +#define SetupQueueCopySection SetupQueueCopySectionW +#else +#define SetupQueueCopySection SetupQueueCopySectionA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupQueueDeleteA( + __in HSPFILEQ QueueHandle, + __in PCSTR PathPart1, + __in_opt PCSTR PathPart2 + ); + +WINSETUPAPI +BOOL +WINAPI +SetupQueueDeleteW( + __in HSPFILEQ QueueHandle, + __in PCWSTR PathPart1, + __in_opt PCWSTR PathPart2 + ); + +#ifdef UNICODE +#define SetupQueueDelete SetupQueueDeleteW +#else +#define SetupQueueDelete SetupQueueDeleteA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupQueueDeleteSectionA( + __in HSPFILEQ QueueHandle, + __in HINF InfHandle, + __in_opt HINF ListInfHandle, + __in PCSTR Section + ); + +WINSETUPAPI +BOOL +WINAPI +SetupQueueDeleteSectionW( + __in HSPFILEQ QueueHandle, + __in HINF InfHandle, + __in_opt HINF ListInfHandle, + __in PCWSTR Section + ); + +#ifdef UNICODE +#define SetupQueueDeleteSection SetupQueueDeleteSectionW +#else +#define SetupQueueDeleteSection SetupQueueDeleteSectionA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupQueueRenameA( + __in HSPFILEQ QueueHandle, + __in PCSTR SourcePath, + __in_opt PCSTR SourceFilename, + __in_opt PCSTR TargetPath, + __in PCSTR TargetFilename + ); + +WINSETUPAPI +BOOL +WINAPI +SetupQueueRenameW( + __in HSPFILEQ QueueHandle, + __in PCWSTR SourcePath, + __in_opt PCWSTR SourceFilename, + __in_opt PCWSTR TargetPath, + __in PCWSTR TargetFilename + ); + +#ifdef UNICODE +#define SetupQueueRename SetupQueueRenameW +#else +#define SetupQueueRename SetupQueueRenameA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupQueueRenameSectionA( + __in HSPFILEQ QueueHandle, + __in HINF InfHandle, + __in_opt HINF ListInfHandle, + __in PCSTR Section + ); + +WINSETUPAPI +BOOL +WINAPI +SetupQueueRenameSectionW( + __in HSPFILEQ QueueHandle, + __in HINF InfHandle, + __in_opt HINF ListInfHandle, + __in PCWSTR Section + ); + +#ifdef UNICODE +#define SetupQueueRenameSection SetupQueueRenameSectionW +#else +#define SetupQueueRenameSection SetupQueueRenameSectionA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupCommitFileQueueA( + __in_opt HWND Owner, + __in HSPFILEQ QueueHandle, + __in PSP_FILE_CALLBACK_A MsgHandler, + __in PVOID Context + ); + +WINSETUPAPI +BOOL +WINAPI +SetupCommitFileQueueW( + __in_opt HWND Owner, + __in HSPFILEQ QueueHandle, + __in PSP_FILE_CALLBACK_W MsgHandler, + __in PVOID Context + ); + +#ifdef UNICODE +#define SetupCommitFileQueue SetupCommitFileQueueW +#else +#define SetupCommitFileQueue SetupCommitFileQueueA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupScanFileQueueA( + __in HSPFILEQ FileQueue, + __in DWORD Flags, + __in_opt HWND Window, + __in_opt PSP_FILE_CALLBACK_A CallbackRoutine, + __in_opt PVOID CallbackContext, + __out PDWORD Result + ); + +WINSETUPAPI +BOOL +WINAPI +SetupScanFileQueueW( + __in HSPFILEQ FileQueue, + __in DWORD Flags, + __in_opt HWND Window, + __in_opt PSP_FILE_CALLBACK_W CallbackRoutine, + __in_opt PVOID CallbackContext, + __out PDWORD Result + ); + +#ifdef UNICODE +#define SetupScanFileQueue SetupScanFileQueueW +#else +#define SetupScanFileQueue SetupScanFileQueueA +#endif + +// +// Define flags for SetupScanFileQueue. +// +#define SPQ_SCAN_FILE_PRESENCE 0x00000001 +#define SPQ_SCAN_FILE_VALIDITY 0x00000002 +#define SPQ_SCAN_USE_CALLBACK 0x00000004 +#define SPQ_SCAN_USE_CALLBACKEX 0x00000008 +#define SPQ_SCAN_INFORM_USER 0x00000010 +#define SPQ_SCAN_PRUNE_COPY_QUEUE 0x00000020 + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +#define SPQ_SCAN_USE_CALLBACK_SIGNERINFO 0x00000040 +#define SPQ_SCAN_PRUNE_DELREN 0x00000080 // remote Delete/Rename queue + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + + +#if _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + +#define SPQ_SCAN_FILE_PRESENCE_WITHOUT_SOURCE 0x00000100 +#define SPQ_SCAN_FILE_COMPARISON 0x00000200 +#define SPQ_SCAN_ACTIVATE_DRP 0x00000400 + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + + +// +// Define flags used with Param2 for SPFILENOTIFY_QUEUESCAN +// +#define SPQ_DELAYED_COPY 0x00000001 // file was in use; registered for delayed copy + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +WINSETUPAPI +BOOL +WINAPI +SetupGetFileQueueCount( + __in HSPFILEQ FileQueue, + __in UINT SubQueueFileOp, + __out PUINT NumOperations + ); + +WINSETUPAPI +BOOL +WINAPI +SetupGetFileQueueFlags( + __in HSPFILEQ FileQueue, + __out PDWORD Flags + ); + +WINSETUPAPI +BOOL +WINAPI +SetupSetFileQueueFlags( + __in HSPFILEQ FileQueue, + __in DWORD FlagMask, + __in DWORD Flags + ); + +// +// Flags/FlagMask for use with SetupSetFileQueueFlags and returned by SetupGetFileQueueFlags +// +#define SPQ_FLAG_BACKUP_AWARE 0x00000001 // If set, SetupCommitFileQueue will + // issue backup notifications. + +#define SPQ_FLAG_ABORT_IF_UNSIGNED 0x00000002 // If set, SetupCommitFileQueue will + // fail with ERROR_SET_SYSTEM_RESTORE_POINT + // if the user elects to proceed with an + // unsigned queue committal. This allows + // the caller to set a system restore point, + // then re-commit the file queue. + +#define SPQ_FLAG_FILES_MODIFIED 0x00000004 // If set, at least one file was + // replaced by a different version + +#define SPQ_FLAG_DO_SHUFFLEMOVE 0x00000008 // If set then always do a shuffle move. A shuffle + // move will first try to copy the source over the + // destination file, but if the destination file is + // in use it will rename the destination file to a + // temp name and queue the temp name for deletion. + // It will then be free to copy the source to the + // destination name. It is considered an error if + // the destination file can't be renamed for some + // reason. + +#define SPQ_FLAG_VALID 0x0000000F // mask of valid flags (can be passed as FlagMask) + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +// +// Define OEM Source Type values for use in SetupCopyOEMInf. +// +#define SPOST_NONE 0 +#define SPOST_PATH 1 +#define SPOST_URL 2 +#define SPOST_MAX 3 + +WINSETUPAPI +BOOL +WINAPI +SetupCopyOEMInfA( + __in PCSTR SourceInfFileName, + __in_opt PCSTR OEMSourceMediaLocation, + __in DWORD OEMSourceMediaType, + __in DWORD CopyStyle, + __out_ecount_opt(DestinationInfFileNameSize) PSTR DestinationInfFileName, + __in DWORD DestinationInfFileNameSize, + __out_opt PDWORD RequiredSize, + __out_opt PSTR *DestinationInfFileNameComponent + ); + +WINSETUPAPI +BOOL +WINAPI +SetupCopyOEMInfW( + __in PCWSTR SourceInfFileName, + __in_opt PCWSTR OEMSourceMediaLocation, + __in DWORD OEMSourceMediaType, + __in DWORD CopyStyle, + __out_ecount_opt(DestinationInfFileNameSize) PWSTR DestinationInfFileName, + __in DWORD DestinationInfFileNameSize, + __out_opt PDWORD RequiredSize, + __out_opt PWSTR *DestinationInfFileNameComponent + ); + +#ifdef UNICODE +#define SetupCopyOEMInf SetupCopyOEMInfW +#else +#define SetupCopyOEMInf SetupCopyOEMInfA +#endif + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +// +// Flags used by SetupUninstallOEMInf +// +#define SUOI_FORCEDELETE 0x00000001 + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +#if _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + +#define SUOI_INTERNAL1 0x00000002 + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP +WINSETUPAPI +BOOL +WINAPI +SetupUninstallOEMInfA( + __in PCSTR InfFileName, + __in DWORD Flags, + __reserved PVOID Reserved + ); + +WINSETUPAPI +BOOL +WINAPI +SetupUninstallOEMInfW( + __in PCWSTR InfFileName, + __in DWORD Flags, + __reserved PVOID Reserved + ); + +#ifdef UNICODE +#define SetupUninstallOEMInf SetupUninstallOEMInfW +#else +#define SetupUninstallOEMInf SetupUninstallOEMInfA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupUninstallNewlyCopiedInfs( + __in HSPFILEQ FileQueue, + __in DWORD Flags, + __reserved PVOID Reserved + ); + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + + +// +// Disk space list APIs +// +WINSETUPAPI +HDSKSPC +WINAPI +SetupCreateDiskSpaceListA( + __reserved PVOID Reserved1, + __reserved DWORD Reserved2, + __in UINT Flags + ); + +WINSETUPAPI +HDSKSPC +WINAPI +SetupCreateDiskSpaceListW( + __reserved PVOID Reserved1, + __reserved DWORD Reserved2, + __in UINT Flags + ); + +#ifdef UNICODE +#define SetupCreateDiskSpaceList SetupCreateDiskSpaceListW +#else +#define SetupCreateDiskSpaceList SetupCreateDiskSpaceListA +#endif + +// +// Flags for SetupCreateDiskSpaceList +// +#define SPDSL_IGNORE_DISK 0x00000001 // ignore deletes and on-disk files in copies +#define SPDSL_DISALLOW_NEGATIVE_ADJUST 0x00000002 + + +WINSETUPAPI +HDSKSPC +WINAPI +SetupDuplicateDiskSpaceListA( + __in HDSKSPC DiskSpace, + __reserved PVOID Reserved1, + __reserved DWORD Reserved2, + __in UINT Flags + ); + +WINSETUPAPI +HDSKSPC +WINAPI +SetupDuplicateDiskSpaceListW( + __in HDSKSPC DiskSpace, + __reserved PVOID Reserved1, + __reserved DWORD Reserved2, + __in UINT Flags + ); + +#ifdef UNICODE +#define SetupDuplicateDiskSpaceList SetupDuplicateDiskSpaceListW +#else +#define SetupDuplicateDiskSpaceList SetupDuplicateDiskSpaceListA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDestroyDiskSpaceList( + __inout HDSKSPC DiskSpace + ); + + +WINSETUPAPI +BOOL +WINAPI +SetupQueryDrivesInDiskSpaceListA( + __in HDSKSPC DiskSpace, + __out_ecount_opt(ReturnBufferSize) PSTR ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupQueryDrivesInDiskSpaceListW( + __in HDSKSPC DiskSpace, + __out_ecount_opt(ReturnBufferSize) PWSTR ReturnBuffer, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +#ifdef UNICODE +#define SetupQueryDrivesInDiskSpaceList SetupQueryDrivesInDiskSpaceListW +#else +#define SetupQueryDrivesInDiskSpaceList SetupQueryDrivesInDiskSpaceListA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupQuerySpaceRequiredOnDriveA( + __in HDSKSPC DiskSpace, + __in PCSTR DriveSpec, + __out LONGLONG *SpaceRequired, + __reserved PVOID Reserved1, + __reserved UINT Reserved2 + ); + +WINSETUPAPI +BOOL +WINAPI +SetupQuerySpaceRequiredOnDriveW( + __in HDSKSPC DiskSpace, + __in PCWSTR DriveSpec, + __out LONGLONG *SpaceRequired, + __reserved PVOID Reserved1, + __reserved UINT Reserved2 + ); + +#ifdef UNICODE +#define SetupQuerySpaceRequiredOnDrive SetupQuerySpaceRequiredOnDriveW +#else +#define SetupQuerySpaceRequiredOnDrive SetupQuerySpaceRequiredOnDriveA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupAdjustDiskSpaceListA( + __in HDSKSPC DiskSpace, + __in LPCSTR DriveRoot, + __in LONGLONG Amount, + __reserved PVOID Reserved1, + __reserved UINT Reserved2 + ); + +WINSETUPAPI +BOOL +WINAPI +SetupAdjustDiskSpaceListW( + __in HDSKSPC DiskSpace, + __in LPCWSTR DriveRoot, + __in LONGLONG Amount, + __reserved PVOID Reserved1, + __reserved UINT Reserved2 + ); + +#ifdef UNICODE +#define SetupAdjustDiskSpaceList SetupAdjustDiskSpaceListW +#else +#define SetupAdjustDiskSpaceList SetupAdjustDiskSpaceListA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupAddToDiskSpaceListA( + __in HDSKSPC DiskSpace, + __in PCSTR TargetFilespec, + __in LONGLONG FileSize, + __in UINT Operation, + __reserved PVOID Reserved1, + __reserved UINT Reserved2 + ); + +WINSETUPAPI +BOOL +WINAPI +SetupAddToDiskSpaceListW( + __in HDSKSPC DiskSpace, + __in PCWSTR TargetFilespec, + __in LONGLONG FileSize, + __in UINT Operation, + __reserved PVOID Reserved1, + __reserved UINT Reserved2 + ); + +#ifdef UNICODE +#define SetupAddToDiskSpaceList SetupAddToDiskSpaceListW +#else +#define SetupAddToDiskSpaceList SetupAddToDiskSpaceListA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupAddSectionToDiskSpaceListA( + __in HDSKSPC DiskSpace, + __in HINF InfHandle, + __in_opt HINF ListInfHandle, + __in PCSTR SectionName, + __in UINT Operation, + __reserved PVOID Reserved1, + __reserved UINT Reserved2 + ); + +WINSETUPAPI +BOOL +WINAPI +SetupAddSectionToDiskSpaceListW( + __in HDSKSPC DiskSpace, + __in HINF InfHandle, + __in_opt HINF ListInfHandle, + __in PCWSTR SectionName, + __in UINT Operation, + __reserved PVOID Reserved1, + __reserved UINT Reserved2 + ); + +#ifdef UNICODE +#define SetupAddSectionToDiskSpaceList SetupAddSectionToDiskSpaceListW +#else +#define SetupAddSectionToDiskSpaceList SetupAddSectionToDiskSpaceListA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupAddInstallSectionToDiskSpaceListA( + __in HDSKSPC DiskSpace, + __in HINF InfHandle, + __in_opt HINF LayoutInfHandle, + __in PCSTR SectionName, + __reserved PVOID Reserved1, + __reserved UINT Reserved2 + ); + +WINSETUPAPI +BOOL +WINAPI +SetupAddInstallSectionToDiskSpaceListW( + __in HDSKSPC DiskSpace, + __in HINF InfHandle, + __in_opt HINF LayoutInfHandle, + __in PCWSTR SectionName, + __reserved PVOID Reserved1, + __reserved UINT Reserved2 + ); + +#ifdef UNICODE +#define SetupAddInstallSectionToDiskSpaceList SetupAddInstallSectionToDiskSpaceListW +#else +#define SetupAddInstallSectionToDiskSpaceList SetupAddInstallSectionToDiskSpaceListA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupRemoveFromDiskSpaceListA( + __in HDSKSPC DiskSpace, + __in PCSTR TargetFilespec, + __in UINT Operation, + __reserved PVOID Reserved1, + __reserved UINT Reserved2 + ); + +WINSETUPAPI +BOOL +WINAPI +SetupRemoveFromDiskSpaceListW( + __in HDSKSPC DiskSpace, + __in PCWSTR TargetFilespec, + __in UINT Operation, + __reserved PVOID Reserved1, + __reserved UINT Reserved2 + ); + +#ifdef UNICODE +#define SetupRemoveFromDiskSpaceList SetupRemoveFromDiskSpaceListW +#else +#define SetupRemoveFromDiskSpaceList SetupRemoveFromDiskSpaceListA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupRemoveSectionFromDiskSpaceListA( + __in HDSKSPC DiskSpace, + __in HINF InfHandle, + __in_opt HINF ListInfHandle, + __in PCSTR SectionName, + __in UINT Operation, + __reserved PVOID Reserved1, + __reserved UINT Reserved2 + ); + +WINSETUPAPI +BOOL +WINAPI +SetupRemoveSectionFromDiskSpaceListW( + __in HDSKSPC DiskSpace, + __in HINF InfHandle, + __in_opt HINF ListInfHandle, + __in PCWSTR SectionName, + __in UINT Operation, + __reserved PVOID Reserved1, + __reserved UINT Reserved2 + ); + +#ifdef UNICODE +#define SetupRemoveSectionFromDiskSpaceList SetupRemoveSectionFromDiskSpaceListW +#else +#define SetupRemoveSectionFromDiskSpaceList SetupRemoveSectionFromDiskSpaceListA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupRemoveInstallSectionFromDiskSpaceListA( + __in HDSKSPC DiskSpace, + __in HINF InfHandle, + __in_opt HINF LayoutInfHandle, + __in PCSTR SectionName, + __reserved PVOID Reserved1, + __reserved UINT Reserved2 + ); + +WINSETUPAPI +BOOL +WINAPI +SetupRemoveInstallSectionFromDiskSpaceListW( + __in HDSKSPC DiskSpace, + __in HINF InfHandle, + __in_opt HINF LayoutInfHandle, + __in PCWSTR SectionName, + __reserved PVOID Reserved1, + __reserved UINT Reserved2 + ); + +#ifdef UNICODE +#define SetupRemoveInstallSectionFromDiskSpaceList SetupRemoveInstallSectionFromDiskSpaceListW +#else +#define SetupRemoveInstallSectionFromDiskSpaceList SetupRemoveInstallSectionFromDiskSpaceListA +#endif + + +// +// Cabinet APIs +// + +WINSETUPAPI +BOOL +WINAPI +SetupIterateCabinetA( + __in PCSTR CabinetFile, + __reserved DWORD Reserved, + __in PSP_FILE_CALLBACK_A MsgHandler, + __in PVOID Context + ); + +WINSETUPAPI +BOOL +WINAPI +SetupIterateCabinetW( + __in PCWSTR CabinetFile, + __reserved DWORD Reserved, + __in PSP_FILE_CALLBACK_W MsgHandler, + __in PVOID Context + ); + +#ifdef UNICODE +#define SetupIterateCabinet SetupIterateCabinetW +#else +#define SetupIterateCabinet SetupIterateCabinetA +#endif + + +WINSETUPAPI +INT +WINAPI +SetupPromptReboot( + __in_opt HSPFILEQ FileQueue, + __in_opt HWND Owner, + __in BOOL ScanOnly + ); + +// +// Define flags that are returned by SetupPromptReboot +// +#define SPFILEQ_FILE_IN_USE 0x00000001 +#define SPFILEQ_REBOOT_RECOMMENDED 0x00000002 +#define SPFILEQ_REBOOT_IN_PROGRESS 0x00000004 + + +WINSETUPAPI +PVOID +WINAPI +SetupInitDefaultQueueCallback( + __in_opt HWND OwnerWindow + ); + +WINSETUPAPI +PVOID +WINAPI +SetupInitDefaultQueueCallbackEx( + __in_opt HWND OwnerWindow, + __in_opt HWND AlternateProgressWindow, + __in UINT ProgressMessage, + __reserved DWORD Reserved1, + __reserved PVOID Reserved2 + ); + +WINSETUPAPI +VOID +WINAPI +SetupTermDefaultQueueCallback( + __in PVOID Context + ); + +WINSETUPAPI +UINT +WINAPI +SetupDefaultQueueCallbackA( + __in PVOID Context, + __in UINT Notification, + __in UINT_PTR Param1, + __in UINT_PTR Param2 + ); + +WINSETUPAPI +UINT +WINAPI +SetupDefaultQueueCallbackW( + __in PVOID Context, + __in UINT Notification, + __in UINT_PTR Param1, + __in UINT_PTR Param2 + ); + +#ifdef UNICODE +#define SetupDefaultQueueCallback SetupDefaultQueueCallbackW +#else +#define SetupDefaultQueueCallback SetupDefaultQueueCallbackA +#endif + + +// +// Flags for AddReg section lines in INF. The corresponding value +// is in the AddReg line format given below: +// +// ,,,,... +// +// The low word contains basic flags concerning the general data type +// and AddReg action. The high word contains values that more specifically +// identify the data type of the registry value. The high word is ignored +// by the 16-bit Windows 95 SETUPX APIs. +// +// If has FLG_ADDREG_DELREG_BIT set, it will be ignored by AddReg +// (not supported by SetupX). +// + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +#define FLG_ADDREG_DELREG_BIT ( 0x00008000 ) // if set, interpret as DELREG, see below + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +#define FLG_ADDREG_BINVALUETYPE ( 0x00000001 ) +#define FLG_ADDREG_NOCLOBBER ( 0x00000002 ) +#define FLG_ADDREG_DELVAL ( 0x00000004 ) +#define FLG_ADDREG_APPEND ( 0x00000008 ) // Currently supported only + // for REG_MULTI_SZ values. +#define FLG_ADDREG_KEYONLY ( 0x00000010 ) // Just create the key, ignore value +#define FLG_ADDREG_OVERWRITEONLY ( 0x00000020 ) // Set only if value already exists + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +#define FLG_ADDREG_64BITKEY ( 0x00001000 ) // make this change in the 64 bit registry. +#define FLG_ADDREG_KEYONLY_COMMON ( 0x00002000 ) // same as FLG_ADDREG_KEYONLY but also works for DELREG +#define FLG_ADDREG_32BITKEY ( 0x00004000 ) // make this change in the 32 bit registry. + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +// +// The INF may supply any arbitrary data type ordinal in the highword except +// for the following: REG_NONE, REG_SZ, REG_EXPAND_SZ, REG_MULTI_SZ. If this +// technique is used, then the data is given in binary format, one byte per +// field. +// +#define FLG_ADDREG_TYPE_MASK ( 0xFFFF0000 | FLG_ADDREG_BINVALUETYPE ) +#define FLG_ADDREG_TYPE_SZ ( 0x00000000 ) +#define FLG_ADDREG_TYPE_MULTI_SZ ( 0x00010000 ) +#define FLG_ADDREG_TYPE_EXPAND_SZ ( 0x00020000 ) +#define FLG_ADDREG_TYPE_BINARY ( 0x00000000 | FLG_ADDREG_BINVALUETYPE ) +#define FLG_ADDREG_TYPE_DWORD ( 0x00010000 | FLG_ADDREG_BINVALUETYPE ) +#define FLG_ADDREG_TYPE_NONE ( 0x00020000 | FLG_ADDREG_BINVALUETYPE ) + +// +// Flags for DelReg section lines in INF. The corresponding value +// is in the extended DelReg line format given below: +// +// ,,,[,...] +// +// In SetupX and some versions of SetupAPI, will be ignored and will +// be deleted. Use with care. +// +// The bits determined by mask FLG_DELREG_TYPE_MASK indicates type of data expected. +// must have FLG_ADDREG_DELREG_BIT set, otherwise it is ignored and specified +// value will be deleted (allowing an AddReg section to also be used as a DelReg section) +// if is not specified, will be deleted (if specified) otherwise +// will be deleted. +// +// the compatability flag +// +#define FLG_DELREG_VALUE (0x00000000) + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +#define FLG_DELREG_TYPE_MASK FLG_ADDREG_TYPE_MASK // 0xFFFF0001 +#define FLG_DELREG_TYPE_SZ FLG_ADDREG_TYPE_SZ // 0x00000000 +#define FLG_DELREG_TYPE_MULTI_SZ FLG_ADDREG_TYPE_MULTI_SZ // 0x00010000 +#define FLG_DELREG_TYPE_EXPAND_SZ FLG_ADDREG_TYPE_EXPAND_SZ // 0x00020000 +#define FLG_DELREG_TYPE_BINARY FLG_ADDREG_TYPE_BINARY // 0x00000001 +#define FLG_DELREG_TYPE_DWORD FLG_ADDREG_TYPE_DWORD // 0x00010001 +#define FLG_DELREG_TYPE_NONE FLG_ADDREG_TYPE_NONE // 0x00020001 +#define FLG_DELREG_64BITKEY FLG_ADDREG_64BITKEY // 0x00001000 +#define FLG_DELREG_KEYONLY_COMMON FLG_ADDREG_KEYONLY_COMMON // 0x00002000 +#define FLG_DELREG_32BITKEY FLG_ADDREG_32BITKEY // 0x00004000 + +// +// = FLG_DELREG_MULTI_SZ_DELSTRING +// ,,,0x00018002, +// removes all entries matching (case ignored) from multi-sz registry value +// + +#define FLG_DELREG_OPERATION_MASK (0x000000FE) +#define FLG_DELREG_MULTI_SZ_DELSTRING ( FLG_DELREG_TYPE_MULTI_SZ | FLG_ADDREG_DELREG_BIT | 0x00000002 ) // 0x00018002 + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +// +// Flags for BitReg section lines in INF. +// +#define FLG_BITREG_CLEARBITS ( 0x00000000 ) +#define FLG_BITREG_SETBITS ( 0x00000001 ) + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +#define FLG_BITREG_64BITKEY ( 0x00001000 ) +#define FLG_BITREG_32BITKEY ( 0x00004000 ) + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +// +// Flags for Ini2Reg section lines in INF. +// +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +#define FLG_INI2REG_64BITKEY ( 0x00001000 ) +#define FLG_INI2REG_32BITKEY ( 0x00004000 ) + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +// +// Flags for RegSvr section lines in INF +// +#define FLG_REGSVR_DLLREGISTER ( 0x00000001 ) +#define FLG_REGSVR_DLLINSTALL ( 0x00000002 ) + +// Flags for RegSvr section lines in INF +// + +#define FLG_PROFITEM_CURRENTUSER ( 0x00000001 ) +#define FLG_PROFITEM_DELETE ( 0x00000002 ) +#define FLG_PROFITEM_GROUP ( 0x00000004 ) +#define FLG_PROFITEM_CSIDL ( 0x00000008 ) + +// +// Flags for AddProperty section lines in the INF +// + +#define FLG_ADDPROPERTY_NOCLOBBER ( 0x00000001 ) +#define FLG_ADDPROPERTY_OVERWRITEONLY ( 0x00000002 ) +#define FLG_ADDPROPERTY_APPEND ( 0x00000004 ) +#define FLG_ADDPROPERTY_OR ( 0x00000008 ) +#define FLG_ADDPROPERTY_AND ( 0x00000010 ) + +// +// Flags for DelProperty section lines in the INF +// + +#define FLG_DELPROPERTY_MULTI_SZ_DELSTRING ( 0x00000001 ) + + +WINSETUPAPI +BOOL +WINAPI +SetupInstallFromInfSectionA( + __in_opt HWND Owner, + __in HINF InfHandle, + __in PCSTR SectionName, + __in UINT Flags, + __in_opt HKEY RelativeKeyRoot, + __in_opt PCSTR SourceRootPath, + __in UINT CopyFlags, + __in_opt PSP_FILE_CALLBACK_A MsgHandler, + __in_opt PVOID Context, + __in_opt HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData + ); + +WINSETUPAPI +BOOL +WINAPI +SetupInstallFromInfSectionW( + __in_opt HWND Owner, + __in HINF InfHandle, + __in PCWSTR SectionName, + __in UINT Flags, + __in_opt HKEY RelativeKeyRoot, + __in_opt PCWSTR SourceRootPath, + __in UINT CopyFlags, + __in_opt PSP_FILE_CALLBACK_W MsgHandler, + __in_opt PVOID Context, + __in_opt HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData + ); + +#ifdef UNICODE +#define SetupInstallFromInfSection SetupInstallFromInfSectionW +#else +#define SetupInstallFromInfSection SetupInstallFromInfSectionA +#endif + +// +// Flags for SetupInstallFromInfSection +// +#define SPINST_LOGCONFIG 0x00000001 +#define SPINST_INIFILES 0x00000002 +#define SPINST_REGISTRY 0x00000004 +#define SPINST_INI2REG 0x00000008 +#define SPINST_FILES 0x00000010 +#define SPINST_BITREG 0x00000020 +#define SPINST_REGSVR 0x00000040 +#define SPINST_UNREGSVR 0x00000080 +#define SPINST_PROFILEITEMS 0x00000100 + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +#define SPINST_COPYINF 0x00000200 + +#if _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + +#define SPINST_PROPERTIES 0x00000400 +#define SPINST_ALL 0x000007ff + +#else + +#define SPINST_ALL 0x000003ff + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + +#else + +#define SPINST_ALL 0x000001ff + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +#define SPINST_SINGLESECTION 0x00010000 +#define SPINST_LOGCONFIG_IS_FORCED 0x00020000 +#define SPINST_LOGCONFIGS_ARE_OVERRIDES 0x00040000 + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +#define SPINST_REGISTERCALLBACKAWARE 0x00080000 + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +#if _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + +#define SPINST_DEVICEINSTALL 0x00100000 + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + +WINSETUPAPI +BOOL +WINAPI +SetupInstallFilesFromInfSectionA( + __in HINF InfHandle, + __in_opt HINF LayoutInfHandle, + __in HSPFILEQ FileQueue, + __in PCSTR SectionName, + __in_opt PCSTR SourceRootPath, + __in UINT CopyFlags + ); + +WINSETUPAPI +BOOL +WINAPI +SetupInstallFilesFromInfSectionW( + __in HINF InfHandle, + __in_opt HINF LayoutInfHandle, + __in HSPFILEQ FileQueue, + __in PCWSTR SectionName, + __in_opt PCWSTR SourceRootPath, + __in UINT CopyFlags + ); + +#ifdef UNICODE +#define SetupInstallFilesFromInfSection SetupInstallFilesFromInfSectionW +#else +#define SetupInstallFilesFromInfSection SetupInstallFilesFromInfSectionA +#endif + + +// +// Flags for SetupInstallServicesFromInfSection(Ex). These flags are also used +// in the flags field of AddService or DelService lines in a device INF. Some +// of these flags are not permitted in the non-Ex API. These flags are marked +// as such below. +// + +// +// (AddService) move service's tag to front of its group order list +// +#define SPSVCINST_TAGTOFRONT (0x00000001) + +// +// (AddService) **Ex API only** mark this service as the function driver for the +// device being installed +// +#define SPSVCINST_ASSOCSERVICE (0x00000002) + +// +// (DelService) delete the associated event log entry for a service specified in +// a DelService entry +// +#define SPSVCINST_DELETEEVENTLOGENTRY (0x00000004) + +// +// (AddService) don't overwrite display name if it already exists +// +#define SPSVCINST_NOCLOBBER_DISPLAYNAME (0x00000008) + +// +// (AddService) don't overwrite start type value if service already exists +// +#define SPSVCINST_NOCLOBBER_STARTTYPE (0x00000010) + +// +// (AddService) don't overwrite error control value if service already exists +// +#define SPSVCINST_NOCLOBBER_ERRORCONTROL (0x00000020) + +// +// (AddService) don't overwrite load order group if it already exists +// +#define SPSVCINST_NOCLOBBER_LOADORDERGROUP (0x00000040) + +// +// (AddService) don't overwrite dependencies list if it already exists +// +#define SPSVCINST_NOCLOBBER_DEPENDENCIES (0x00000080) + +// +// (AddService) don't overwrite description if it already exists +// +#define SPSVCINST_NOCLOBBER_DESCRIPTION (0x00000100) +// +// (DelService) stop the associated service specified in +// a DelService entry before deleting the service +// +#define SPSVCINST_STOPSERVICE (0x00000200) + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP +// +// (AddService) force overwrite of security settings +// +#define SPSVCINST_CLOBBER_SECURITY (0x00000400) + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +#if _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN +// +// (Start Service) start a service manually after install +// +#define SPSVCINST_STARTSERVICE (0x00000800) + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + +#if _SETUPAPI_VER >= _WIN32_WINNT_WIN7 +// +// (AddService) don't overwrite required privileges list if it already exists +// +#define SPSVCINST_NOCLOBBER_REQUIREDPRIVILEGES (0x00001000) + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WIN7 + + + +WINSETUPAPI +BOOL +WINAPI +SetupInstallServicesFromInfSectionA( + __in HINF InfHandle, + __in PCSTR SectionName, + __in DWORD Flags + ); + +WINSETUPAPI +BOOL +WINAPI +SetupInstallServicesFromInfSectionW( + __in HINF InfHandle, + __in PCWSTR SectionName, + __in DWORD Flags + ); + +#ifdef UNICODE +#define SetupInstallServicesFromInfSection SetupInstallServicesFromInfSectionW +#else +#define SetupInstallServicesFromInfSection SetupInstallServicesFromInfSectionA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupInstallServicesFromInfSectionExA( + __in HINF InfHandle, + __in PCSTR SectionName, + __in DWORD Flags, + __in_opt HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData, + __reserved PVOID Reserved1, + __reserved PVOID Reserved2 + ); + +WINSETUPAPI +BOOL +WINAPI +SetupInstallServicesFromInfSectionExW( + __in HINF InfHandle, + __in PCWSTR SectionName, + __in DWORD Flags, + __in_opt HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData, + __reserved PVOID Reserved1, + __reserved PVOID Reserved2 + ); + +#ifdef UNICODE +#define SetupInstallServicesFromInfSectionEx SetupInstallServicesFromInfSectionExW +#else +#define SetupInstallServicesFromInfSectionEx SetupInstallServicesFromInfSectionExA +#endif + + + +// +// High level routine, usually used via rundll32.dll +// to perform right-click install action on INFs +// May be called directly: +// +// wsprintf(CmdLineBuffer,TEXT("DefaultInstall 132 %s"),InfPath); +// InstallHinfSection(NULL,NULL,CmdLineBuffer,0); +// +VOID +WINAPI +InstallHinfSectionA( + __in HWND Window, + __in HINSTANCE ModuleHandle, + __in PCSTR CommandLine, + __in INT ShowCommand + ); + +VOID +WINAPI +InstallHinfSectionW( + __in HWND Window, + __in HINSTANCE ModuleHandle, + __in PCWSTR CommandLine, + __in INT ShowCommand + ); + +#ifdef UNICODE +#define InstallHinfSection InstallHinfSectionW +#else +#define InstallHinfSection InstallHinfSectionA +#endif + + + + + +// +// Define handle type for Setup file log. +// +typedef PVOID HSPFILELOG; + +WINSETUPAPI +HSPFILELOG +WINAPI +SetupInitializeFileLogA( + __in_opt PCSTR LogFileName, + __in DWORD Flags + ); + +WINSETUPAPI +HSPFILELOG +WINAPI +SetupInitializeFileLogW( + __in_opt PCWSTR LogFileName, + __in DWORD Flags + ); + +#ifdef UNICODE +#define SetupInitializeFileLog SetupInitializeFileLogW +#else +#define SetupInitializeFileLog SetupInitializeFileLogA +#endif + +// +// Flags for SetupInitializeFileLog +// +#define SPFILELOG_SYSTEMLOG 0x00000001 // use system log -- must be Administrator +#define SPFILELOG_FORCENEW 0x00000002 // not valid with SPFILELOG_SYSTEMLOG +#define SPFILELOG_QUERYONLY 0x00000004 // allows non-administrators to read system log + + +WINSETUPAPI +BOOL +WINAPI +SetupTerminateFileLog( + __in HSPFILELOG FileLogHandle + ); + + +WINSETUPAPI +BOOL +WINAPI +SetupLogFileA( + __in HSPFILELOG FileLogHandle, + __in_opt PCSTR LogSectionName, + __in PCSTR SourceFilename, + __in PCSTR TargetFilename, + __in DWORD Checksum, + __in_opt PCSTR DiskTagfile, + __in_opt PCSTR DiskDescription, + __in_opt PCSTR OtherInfo, + __in DWORD Flags + ); + +WINSETUPAPI +BOOL +WINAPI +SetupLogFileW( + __in HSPFILELOG FileLogHandle, + __in_opt PCWSTR LogSectionName, + __in PCWSTR SourceFilename, + __in PCWSTR TargetFilename, + __in DWORD Checksum, + __in_opt PCWSTR DiskTagfile, + __in_opt PCWSTR DiskDescription, + __in_opt PCWSTR OtherInfo, + __in DWORD Flags + ); + +#ifdef UNICODE +#define SetupLogFile SetupLogFileW +#else +#define SetupLogFile SetupLogFileA +#endif + +// +// Flags for SetupLogFile +// +#define SPFILELOG_OEMFILE 0x00000001 + + +WINSETUPAPI +BOOL +WINAPI +SetupRemoveFileLogEntryA( + __in HSPFILELOG FileLogHandle, + __in_opt PCSTR LogSectionName, + __in_opt PCSTR TargetFilename + ); + +WINSETUPAPI +BOOL +WINAPI +SetupRemoveFileLogEntryW( + __in HSPFILELOG FileLogHandle, + __in_opt PCWSTR LogSectionName, + __in_opt PCWSTR TargetFilename + ); + +#ifdef UNICODE +#define SetupRemoveFileLogEntry SetupRemoveFileLogEntryW +#else +#define SetupRemoveFileLogEntry SetupRemoveFileLogEntryA +#endif + + +// +// Items retrievable from SetupQueryFileLog() +// +typedef enum { + SetupFileLogSourceFilename, + SetupFileLogChecksum, + SetupFileLogDiskTagfile, + SetupFileLogDiskDescription, + SetupFileLogOtherInfo, + SetupFileLogMax +} SetupFileLogInfo; + +WINSETUPAPI +BOOL +WINAPI +SetupQueryFileLogA( + __in HSPFILELOG FileLogHandle, + __in_opt PCSTR LogSectionName, + __in PCSTR TargetFilename, + __in SetupFileLogInfo DesiredInfo, + __out_ecount_opt(ReturnBufferSize) PSTR DataOut, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupQueryFileLogW( + __in HSPFILELOG FileLogHandle, + __in_opt PCWSTR LogSectionName, + __in PCWSTR TargetFilename, + __in SetupFileLogInfo DesiredInfo, + __out_ecount_opt(ReturnBufferSize) PWSTR DataOut, + __in DWORD ReturnBufferSize, + __out_opt PDWORD RequiredSize + ); + +#ifdef UNICODE +#define SetupQueryFileLog SetupQueryFileLogW +#else +#define SetupQueryFileLog SetupQueryFileLogA +#endif + +// +// Text logging APIs +// +#define LogSeverity DWORD +#define LogSevInformation 0x00000000 +#define LogSevWarning 0x00000001 +#define LogSevError 0x00000002 +#define LogSevFatalError 0x00000003 +#define LogSevMaximum 0x00000004 + +WINSETUPAPI +BOOL +WINAPI +SetupOpenLog ( + __in BOOL Erase + ); + +WINSETUPAPI +BOOL +WINAPI +SetupLogErrorA ( + __in LPCSTR MessageString, + __in LogSeverity Severity + ); + +WINSETUPAPI +BOOL +WINAPI +SetupLogErrorW ( + __in LPCWSTR MessageString, + __in LogSeverity Severity + ); + +#ifdef UNICODE +#define SetupLogError SetupLogErrorW +#else +#define SetupLogError SetupLogErrorA +#endif + +WINSETUPAPI +VOID +WINAPI +SetupCloseLog ( + VOID + ); + +// +// Text log for INF debugging +// + +#if _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + + +WINSETUPAPI +SP_LOG_TOKEN +WINAPI +SetupGetThreadLogToken( + VOID + ); + +WINSETUPAPI +VOID +WINAPI +SetupSetThreadLogToken( + __in SP_LOG_TOKEN LogToken + ); + +WINSETUPAPI +VOID +WINAPI +SetupWriteTextLog( + __in SP_LOG_TOKEN LogToken, + __in DWORD Category, + __in DWORD Flags, + __in PCSTR MessageStr, + ... + ); + +WINSETUPAPI +VOID +WINAPI +SetupWriteTextLogError( + __in SP_LOG_TOKEN LogToken, + __in DWORD Category, + __in DWORD LogFlags, + __in DWORD Error, + __in PCSTR MessageStr, + ... + ); + +WINSETUPAPI +VOID +WINAPI +SetupWriteTextLogInfLine( + __in SP_LOG_TOKEN LogToken, + __in DWORD Flags, + __in HINF InfHandle, + __in PINFCONTEXT Context + ); + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + + +// +// Backup Information API's +// + +WINSETUPAPI +BOOL +WINAPI +SetupGetBackupInformationA( + __in HSPFILEQ QueueHandle, + __inout PSP_BACKUP_QUEUE_PARAMS_A BackupParams + ); + +WINSETUPAPI +BOOL +WINAPI +SetupGetBackupInformationW( + __in HSPFILEQ QueueHandle, + __inout PSP_BACKUP_QUEUE_PARAMS_W BackupParams + ); + +#ifdef UNICODE +#define SetupGetBackupInformation SetupGetBackupInformationW +#else +#define SetupGetBackupInformation SetupGetBackupInformationA +#endif + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +WINSETUPAPI +BOOL +WINAPI +SetupPrepareQueueForRestoreA( + __in HSPFILEQ QueueHandle, + __in PCSTR BackupPath, + __in DWORD RestoreFlags + ); + +WINSETUPAPI +BOOL +WINAPI +SetupPrepareQueueForRestoreW( + __in HSPFILEQ QueueHandle, + __in PCWSTR BackupPath, + __in DWORD RestoreFlags + ); + +#ifdef UNICODE +#define SetupPrepareQueueForRestore SetupPrepareQueueForRestoreW +#else +#define SetupPrepareQueueForRestore SetupPrepareQueueForRestoreA +#endif + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +// +// Control forcing of Non-Interactive Mode +// Overriden if SetupAPI is run in non-interactive window session +// + +WINSETUPAPI +BOOL +WINAPI +SetupSetNonInteractiveMode( + __in BOOL NonInteractiveFlag + ); + +WINSETUPAPI +BOOL +WINAPI +SetupGetNonInteractiveMode( + VOID + ); + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +// +// Device Installer APIs +// + +__checkReturn +WINSETUPAPI +HDEVINFO +WINAPI +SetupDiCreateDeviceInfoList( + __in_opt CONST GUID *ClassGuid, + __in_opt HWND hwndParent + ); + + +__checkReturn +WINSETUPAPI +HDEVINFO +WINAPI +SetupDiCreateDeviceInfoListExA( + __in_opt CONST GUID *ClassGuid, + __in_opt HWND hwndParent, + __in_opt PCSTR MachineName, + __reserved PVOID Reserved + ); + +__checkReturn +WINSETUPAPI +HDEVINFO +WINAPI +SetupDiCreateDeviceInfoListExW( + __in_opt CONST GUID *ClassGuid, + __in_opt HWND hwndParent, + __in_opt PCWSTR MachineName, + __reserved PVOID Reserved + ); + +#ifdef UNICODE +#define SetupDiCreateDeviceInfoListEx SetupDiCreateDeviceInfoListExW +#else +#define SetupDiCreateDeviceInfoListEx SetupDiCreateDeviceInfoListExA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetDeviceInfoListClass( + __in HDEVINFO DeviceInfoSet, + __out LPGUID ClassGuid + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetDeviceInfoListDetailA( + __in HDEVINFO DeviceInfoSet, + __out PSP_DEVINFO_LIST_DETAIL_DATA_A DeviceInfoSetDetailData + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetDeviceInfoListDetailW( + __in HDEVINFO DeviceInfoSet, + __out PSP_DEVINFO_LIST_DETAIL_DATA_W DeviceInfoSetDetailData + ); + +#ifdef UNICODE +#define SetupDiGetDeviceInfoListDetail SetupDiGetDeviceInfoListDetailW +#else +#define SetupDiGetDeviceInfoListDetail SetupDiGetDeviceInfoListDetailA +#endif + + +// +// Flags for SetupDiCreateDeviceInfo +// +#define DICD_GENERATE_ID 0x00000001 +#define DICD_INHERIT_CLASSDRVS 0x00000002 + +WINSETUPAPI +BOOL +WINAPI +SetupDiCreateDeviceInfoA( + __in HDEVINFO DeviceInfoSet, + __in PCSTR DeviceName, + __in CONST GUID *ClassGuid, + __in_opt PCSTR DeviceDescription, + __in_opt HWND hwndParent, + __in DWORD CreationFlags, + __out_opt PSP_DEVINFO_DATA DeviceInfoData + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiCreateDeviceInfoW( + __in HDEVINFO DeviceInfoSet, + __in PCWSTR DeviceName, + __in CONST GUID *ClassGuid, + __in_opt PCWSTR DeviceDescription, + __in_opt HWND hwndParent, + __in DWORD CreationFlags, + __out_opt PSP_DEVINFO_DATA DeviceInfoData + ); + +#ifdef UNICODE +#define SetupDiCreateDeviceInfo SetupDiCreateDeviceInfoW +#else +#define SetupDiCreateDeviceInfo SetupDiCreateDeviceInfoA +#endif + + +// +// Flags for SetupDiOpenDeviceInfo +// +#define DIOD_INHERIT_CLASSDRVS 0x00000002 +#define DIOD_CANCEL_REMOVE 0x00000004 + +WINSETUPAPI +BOOL +WINAPI +SetupDiOpenDeviceInfoA( + __in HDEVINFO DeviceInfoSet, + __in PCSTR DeviceInstanceId, + __in_opt HWND hwndParent, + __in DWORD OpenFlags, + __out_opt PSP_DEVINFO_DATA DeviceInfoData + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiOpenDeviceInfoW( + __in HDEVINFO DeviceInfoSet, + __in PCWSTR DeviceInstanceId, + __in_opt HWND hwndParent, + __in DWORD OpenFlags, + __out_opt PSP_DEVINFO_DATA DeviceInfoData + ); + +#ifdef UNICODE +#define SetupDiOpenDeviceInfo SetupDiOpenDeviceInfoW +#else +#define SetupDiOpenDeviceInfo SetupDiOpenDeviceInfoA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetDeviceInstanceIdA( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVINFO_DATA DeviceInfoData, + __out_ecount_opt(DeviceInstanceIdSize) PSTR DeviceInstanceId, + __in DWORD DeviceInstanceIdSize, + __out_opt PDWORD RequiredSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetDeviceInstanceIdW( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVINFO_DATA DeviceInfoData, + __out_ecount_opt(DeviceInstanceIdSize) PWSTR DeviceInstanceId, + __in DWORD DeviceInstanceIdSize, + __out_opt PDWORD RequiredSize + ); + +#ifdef UNICODE +#define SetupDiGetDeviceInstanceId SetupDiGetDeviceInstanceIdW +#else +#define SetupDiGetDeviceInstanceId SetupDiGetDeviceInstanceIdA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDiDeleteDeviceInfo( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVINFO_DATA DeviceInfoData + ); + + +WINSETUPAPI +BOOL +WINAPI +SetupDiEnumDeviceInfo( + __in HDEVINFO DeviceInfoSet, + __in DWORD MemberIndex, + __out PSP_DEVINFO_DATA DeviceInfoData + ); + + +WINSETUPAPI +BOOL +WINAPI +SetupDiDestroyDeviceInfoList( + __in HDEVINFO DeviceInfoSet + ); + + +WINSETUPAPI +BOOL +WINAPI +SetupDiEnumDeviceInterfaces( + __in HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData, + __in CONST GUID *InterfaceClassGuid, + __in DWORD MemberIndex, + __out PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData + ); + +// +// Backward compatibility--do not use +// +#define SetupDiEnumInterfaceDevice SetupDiEnumDeviceInterfaces + + +WINSETUPAPI +BOOL +WINAPI +SetupDiCreateDeviceInterfaceA( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVINFO_DATA DeviceInfoData, + __in CONST GUID *InterfaceClassGuid, + __in_opt PCSTR ReferenceString, + __in DWORD CreationFlags, + __out_opt PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiCreateDeviceInterfaceW( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVINFO_DATA DeviceInfoData, + __in CONST GUID *InterfaceClassGuid, + __in_opt PCWSTR ReferenceString, + __in DWORD CreationFlags, + __out_opt PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData + ); + +#ifdef UNICODE +#define SetupDiCreateDeviceInterface SetupDiCreateDeviceInterfaceW +#else +#define SetupDiCreateDeviceInterface SetupDiCreateDeviceInterfaceA +#endif + +// +// Backward compatibility--do not use. +// +#define SetupDiCreateInterfaceDeviceW SetupDiCreateDeviceInterfaceW +#define SetupDiCreateInterfaceDeviceA SetupDiCreateDeviceInterfaceA +#ifdef UNICODE +#define SetupDiCreateInterfaceDevice SetupDiCreateDeviceInterfaceW +#else +#define SetupDiCreateInterfaceDevice SetupDiCreateDeviceInterfaceA +#endif + + +// +// Flags for SetupDiOpenDeviceInterface +// +#define DIODI_NO_ADD 0x00000001 + +WINSETUPAPI +BOOL +WINAPI +SetupDiOpenDeviceInterfaceA( + __in HDEVINFO DeviceInfoSet, + __in PCSTR DevicePath, + __in DWORD OpenFlags, + __out_opt PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiOpenDeviceInterfaceW( + __in HDEVINFO DeviceInfoSet, + __in PCWSTR DevicePath, + __in DWORD OpenFlags, + __out_opt PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData + ); + +#ifdef UNICODE +#define SetupDiOpenDeviceInterface SetupDiOpenDeviceInterfaceW +#else +#define SetupDiOpenDeviceInterface SetupDiOpenDeviceInterfaceA +#endif + +// +// Backward compatibility--do not use +// +#define SetupDiOpenInterfaceDeviceW SetupDiOpenDeviceInterfaceW +#define SetupDiOpenInterfaceDeviceA SetupDiOpenDeviceInterfaceA +#ifdef UNICODE +#define SetupDiOpenInterfaceDevice SetupDiOpenDeviceInterfaceW +#else +#define SetupDiOpenInterfaceDevice SetupDiOpenDeviceInterfaceA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetDeviceInterfaceAlias( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, + __in CONST GUID *AliasInterfaceClassGuid, + __out PSP_DEVICE_INTERFACE_DATA AliasDeviceInterfaceData + ); + +// +// Backward compatibility--do not use. +// +#define SetupDiGetInterfaceDeviceAlias SetupDiGetDeviceInterfaceAlias + + +WINSETUPAPI +BOOL +WINAPI +SetupDiDeleteDeviceInterfaceData( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData + ); + +// +// Backward compatibility--do not use. +// +#define SetupDiDeleteInterfaceDeviceData SetupDiDeleteDeviceInterfaceData + + +WINSETUPAPI +BOOL +WINAPI +SetupDiRemoveDeviceInterface( + __in HDEVINFO DeviceInfoSet, + __inout PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData + ); + +// +// Backward compatibility--do not use. +// +#define SetupDiRemoveInterfaceDevice SetupDiRemoveDeviceInterface + + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetDeviceInterfaceDetailA( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, + __inout_bcount_opt(DeviceInterfaceDetailDataSize) PSP_DEVICE_INTERFACE_DETAIL_DATA_A DeviceInterfaceDetailData, + __in DWORD DeviceInterfaceDetailDataSize, + __out_opt PDWORD RequiredSize, + __out_opt PSP_DEVINFO_DATA DeviceInfoData + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetDeviceInterfaceDetailW( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, + __out_bcount_opt(DeviceInterfaceDetailDataSize) PSP_DEVICE_INTERFACE_DETAIL_DATA_W DeviceInterfaceDetailData, + __in DWORD DeviceInterfaceDetailDataSize, + __out_opt PDWORD RequiredSize, + __out_opt PSP_DEVINFO_DATA DeviceInfoData + ); + +#ifdef UNICODE +#define SetupDiGetDeviceInterfaceDetail SetupDiGetDeviceInterfaceDetailW +#else +#define SetupDiGetDeviceInterfaceDetail SetupDiGetDeviceInterfaceDetailA +#endif + +// +// Backward compatibility--do not use. +// +#define SetupDiGetInterfaceDeviceDetailW SetupDiGetDeviceInterfaceDetailW +#define SetupDiGetInterfaceDeviceDetailA SetupDiGetDeviceInterfaceDetailA +#ifdef UNICODE +#define SetupDiGetInterfaceDeviceDetail SetupDiGetDeviceInterfaceDetailW +#else +#define SetupDiGetInterfaceDeviceDetail SetupDiGetDeviceInterfaceDetailA +#endif + + +// +// Default install handler for DIF_INSTALLINTERFACES. +// +WINSETUPAPI +BOOL +WINAPI +SetupDiInstallDeviceInterfaces( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVINFO_DATA DeviceInfoData + ); + +// +// Backward compatibility--do not use. +// +#define SetupDiInstallInterfaceDevices SetupDiInstallDeviceInterfaces + + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +WINSETUPAPI +BOOL +WINAPI +SetupDiSetDeviceInterfaceDefault( + __in HDEVINFO DeviceInfoSet, + __inout PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, + __in DWORD Flags, + __reserved PVOID Reserved + ); + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + + +// +// Default install handler for DIF_REGISTERDEVICE +// + +// +// Flags for SetupDiRegisterDeviceInfo +// +#define SPRDI_FIND_DUPS 0x00000001 + +WINSETUPAPI +BOOL +WINAPI +SetupDiRegisterDeviceInfo( + __in HDEVINFO DeviceInfoSet, + __inout PSP_DEVINFO_DATA DeviceInfoData, + __in DWORD Flags, + __in_opt PSP_DETSIG_CMPPROC CompareProc, + __in_opt PVOID CompareContext, + __out_opt PSP_DEVINFO_DATA DupDeviceInfoData + ); + + +// +// Ordinal values distinguishing between class drivers and +// device drivers. +// (Passed in 'DriverType' parameter of driver information list APIs) +// +#define SPDIT_NODRIVER 0x00000000 +#define SPDIT_CLASSDRIVER 0x00000001 +#define SPDIT_COMPATDRIVER 0x00000002 + +WINSETUPAPI +BOOL +WINAPI +SetupDiBuildDriverInfoList( + __in HDEVINFO DeviceInfoSet, + __inout_opt PSP_DEVINFO_DATA DeviceInfoData, + __in DWORD DriverType + ); + + +WINSETUPAPI +BOOL +WINAPI +SetupDiCancelDriverInfoSearch( + __in HDEVINFO DeviceInfoSet + ); + + +WINSETUPAPI +BOOL +WINAPI +SetupDiEnumDriverInfoA( + __in HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData, + __in DWORD DriverType, + __in DWORD MemberIndex, + __out PSP_DRVINFO_DATA_A DriverInfoData + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiEnumDriverInfoW( + __in HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData, + __in DWORD DriverType, + __in DWORD MemberIndex, + __out PSP_DRVINFO_DATA_W DriverInfoData + ); + +#ifdef UNICODE +#define SetupDiEnumDriverInfo SetupDiEnumDriverInfoW +#else +#define SetupDiEnumDriverInfo SetupDiEnumDriverInfoA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetSelectedDriverA( + __in HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData, + __out PSP_DRVINFO_DATA_A DriverInfoData + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetSelectedDriverW( + __in HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData, + __out PSP_DRVINFO_DATA_W DriverInfoData + ); + +#ifdef UNICODE +#define SetupDiGetSelectedDriver SetupDiGetSelectedDriverW +#else +#define SetupDiGetSelectedDriver SetupDiGetSelectedDriverA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDiSetSelectedDriverA( + __in HDEVINFO DeviceInfoSet, + __inout_opt PSP_DEVINFO_DATA DeviceInfoData, + __inout_opt PSP_DRVINFO_DATA_A DriverInfoData + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiSetSelectedDriverW( + __in HDEVINFO DeviceInfoSet, + __inout_opt PSP_DEVINFO_DATA DeviceInfoData, + __inout_opt PSP_DRVINFO_DATA_W DriverInfoData + ); + +#ifdef UNICODE +#define SetupDiSetSelectedDriver SetupDiSetSelectedDriverW +#else +#define SetupDiSetSelectedDriver SetupDiSetSelectedDriverA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetDriverInfoDetailA( + __in HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData, + __in PSP_DRVINFO_DATA_A DriverInfoData, + __inout_bcount_opt(DriverInfoDetailDataSize) PSP_DRVINFO_DETAIL_DATA_A DriverInfoDetailData, + __in DWORD DriverInfoDetailDataSize, + __out_opt PDWORD RequiredSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetDriverInfoDetailW( + __in HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData, + __in PSP_DRVINFO_DATA_W DriverInfoData, + __inout_bcount_opt(DriverInfoDetailDataSize) PSP_DRVINFO_DETAIL_DATA_W DriverInfoDetailData, + __in DWORD DriverInfoDetailDataSize, + __out_opt PDWORD RequiredSize + ); + +#ifdef UNICODE +#define SetupDiGetDriverInfoDetail SetupDiGetDriverInfoDetailW +#else +#define SetupDiGetDriverInfoDetail SetupDiGetDriverInfoDetailA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDiDestroyDriverInfoList( + __in HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData, + __in DWORD DriverType + ); + + +// +// Flags controlling what is included in the device information set built +// by SetupDiGetClassDevs +// +#define DIGCF_DEFAULT 0x00000001 // only valid with DIGCF_DEVICEINTERFACE +#define DIGCF_PRESENT 0x00000002 +#define DIGCF_ALLCLASSES 0x00000004 +#define DIGCF_PROFILE 0x00000008 +#define DIGCF_DEVICEINTERFACE 0x00000010 + +// +// Backward compatibility--do not use. +// +#define DIGCF_INTERFACEDEVICE DIGCF_DEVICEINTERFACE + + +__checkReturn +WINSETUPAPI +HDEVINFO +WINAPI +SetupDiGetClassDevsA( + __in_opt CONST GUID *ClassGuid, + __in_opt PCSTR Enumerator, + __in_opt HWND hwndParent, + __in DWORD Flags + ); + +__checkReturn +WINSETUPAPI +HDEVINFO +WINAPI +SetupDiGetClassDevsW( + __in_opt CONST GUID *ClassGuid, + __in_opt PCWSTR Enumerator, + __in_opt HWND hwndParent, + __in DWORD Flags + ); + +#ifdef UNICODE +#define SetupDiGetClassDevs SetupDiGetClassDevsW +#else +#define SetupDiGetClassDevs SetupDiGetClassDevsA +#endif + + +__checkReturn +WINSETUPAPI +HDEVINFO +WINAPI +SetupDiGetClassDevsExA( + __in_opt CONST GUID *ClassGuid, + __in_opt PCSTR Enumerator, + __in_opt HWND hwndParent, + __in DWORD Flags, + __in_opt HDEVINFO DeviceInfoSet, + __in_opt PCSTR MachineName, + __reserved PVOID Reserved + ); + +__checkReturn +WINSETUPAPI +HDEVINFO +WINAPI +SetupDiGetClassDevsExW( + __in_opt CONST GUID *ClassGuid, + __in_opt PCWSTR Enumerator, + __in_opt HWND hwndParent, + __in DWORD Flags, + __in_opt HDEVINFO DeviceInfoSet, + __in_opt PCWSTR MachineName, + __reserved PVOID Reserved + ); + +#ifdef UNICODE +#define SetupDiGetClassDevsEx SetupDiGetClassDevsExW +#else +#define SetupDiGetClassDevsEx SetupDiGetClassDevsExA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetINFClassA( + __in PCSTR InfName, + __out LPGUID ClassGuid, + __out_ecount(ClassNameSize) PSTR ClassName, + __in DWORD ClassNameSize, + __out_opt PDWORD RequiredSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetINFClassW( + __in PCWSTR InfName, + __out LPGUID ClassGuid, + __out_ecount(ClassNameSize) PWSTR ClassName, + __in DWORD ClassNameSize, + __out_opt PDWORD RequiredSize + ); + +#ifdef UNICODE +#define SetupDiGetINFClass SetupDiGetINFClassW +#else +#define SetupDiGetINFClass SetupDiGetINFClassA +#endif + + +// +// Flags controlling exclusion from the class information list built +// by SetupDiBuildClassInfoList(Ex) +// +#define DIBCI_NOINSTALLCLASS 0x00000001 +#define DIBCI_NODISPLAYCLASS 0x00000002 + +WINSETUPAPI +BOOL +WINAPI +SetupDiBuildClassInfoList( + __in DWORD Flags, + __out_ecount_opt(ClassGuidListSize) LPGUID ClassGuidList, + __in DWORD ClassGuidListSize, + __out PDWORD RequiredSize + ); + + +WINSETUPAPI +BOOL +WINAPI +SetupDiBuildClassInfoListExA( + __in DWORD Flags, + __out_ecount_opt(ClassGuidListSize) LPGUID ClassGuidList, + __in DWORD ClassGuidListSize, + __out PDWORD RequiredSize, + __in_opt PCSTR MachineName, + __reserved PVOID Reserved + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiBuildClassInfoListExW( + __in DWORD Flags, + __out_ecount_opt(ClassGuidListSize) LPGUID ClassGuidList, + __in DWORD ClassGuidListSize, + __out PDWORD RequiredSize, + __in_opt PCWSTR MachineName, + __reserved PVOID Reserved + ); + +#ifdef UNICODE +#define SetupDiBuildClassInfoListEx SetupDiBuildClassInfoListExW +#else +#define SetupDiBuildClassInfoListEx SetupDiBuildClassInfoListExA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetClassDescriptionA( + __in CONST GUID *ClassGuid, + __out_ecount(ClassDescriptionSize) PSTR ClassDescription, + __in DWORD ClassDescriptionSize, + __out_opt PDWORD RequiredSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetClassDescriptionW( + __in CONST GUID *ClassGuid, + __out_ecount(ClassDescriptionSize) PWSTR ClassDescription, + __in DWORD ClassDescriptionSize, + __out_opt PDWORD RequiredSize + ); + +#ifdef UNICODE +#define SetupDiGetClassDescription SetupDiGetClassDescriptionW +#else +#define SetupDiGetClassDescription SetupDiGetClassDescriptionA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetClassDescriptionExA( + __in CONST GUID *ClassGuid, + __out_ecount(ClassDescriptionSize) PSTR ClassDescription, + __in DWORD ClassDescriptionSize, + __out_opt PDWORD RequiredSize, + __in_opt PCSTR MachineName, + __reserved PVOID Reserved + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetClassDescriptionExW( + __in CONST GUID *ClassGuid, + __out_ecount(ClassDescriptionSize) PWSTR ClassDescription, + __in DWORD ClassDescriptionSize, + __out_opt PDWORD RequiredSize, + __in_opt PCWSTR MachineName, + __reserved PVOID Reserved + ); + +#ifdef UNICODE +#define SetupDiGetClassDescriptionEx SetupDiGetClassDescriptionExW +#else +#define SetupDiGetClassDescriptionEx SetupDiGetClassDescriptionExA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDiCallClassInstaller( + __in DI_FUNCTION InstallFunction, + __in HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData + ); + + +// +// Default install handler for DIF_SELECTDEVICE +// +WINSETUPAPI +BOOL +WINAPI +SetupDiSelectDevice( + __in HDEVINFO DeviceInfoSet, + __inout_opt PSP_DEVINFO_DATA DeviceInfoData + ); + + +// +// Default install handler for DIF_SELECTBESTCOMPATDRV +// +WINSETUPAPI +BOOL +WINAPI +SetupDiSelectBestCompatDrv( + __in HDEVINFO DeviceInfoSet, + __inout_opt PSP_DEVINFO_DATA DeviceInfoData + ); + + +// +// Default install handler for DIF_INSTALLDEVICE +// +WINSETUPAPI +BOOL +WINAPI +SetupDiInstallDevice( + __in HDEVINFO DeviceInfoSet, + __inout PSP_DEVINFO_DATA DeviceInfoData + ); + + +// +// Default install handler for DIF_INSTALLDEVICEFILES +// +WINSETUPAPI +BOOL +WINAPI +SetupDiInstallDriverFiles( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVINFO_DATA DeviceInfoData + ); + + +// +// Default install handler for DIF_REGISTER_COINSTALLERS +// +WINSETUPAPI +BOOL +WINAPI +SetupDiRegisterCoDeviceInstallers( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVINFO_DATA DeviceInfoData + ); + + +// +// Default install handler for DIF_REMOVE +// +WINSETUPAPI +BOOL +WINAPI +SetupDiRemoveDevice( + __in HDEVINFO DeviceInfoSet, + __inout PSP_DEVINFO_DATA DeviceInfoData + ); + + +// +// Default install handler for DIF_UNREMOVE +// +WINSETUPAPI +BOOL +WINAPI +SetupDiUnremoveDevice( + __in HDEVINFO DeviceInfoSet, + __inout PSP_DEVINFO_DATA DeviceInfoData + ); + +#if _SETUPAPI_VER >= _WIN32_WINNT_WS03 + +WINSETUPAPI +BOOL +WINAPI +SetupDiRestartDevices( + __in HDEVINFO DeviceInfoSet, + __inout PSP_DEVINFO_DATA DeviceInfoData + ); + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WS03 + +// +// Default install handler for DIF_PROPERTYCHANGE +// +WINSETUPAPI +BOOL +WINAPI +SetupDiChangeState( + __in HDEVINFO DeviceInfoSet, + __inout PSP_DEVINFO_DATA DeviceInfoData + ); + + +#if _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + +// +// Default install handler for DIF_FINISHINSTALL_ACTION +// +WINSETUPAPI +BOOL +WINAPI +SetupDiFinishInstallAction( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVINFO_DATA DeviceInfoData + ); + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + + +WINSETUPAPI +BOOL +WINAPI +SetupDiInstallClassA( + __in_opt HWND hwndParent, + __in PCSTR InfFileName, + __in DWORD Flags, + __in_opt HSPFILEQ FileQueue + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiInstallClassW( + __in_opt HWND hwndParent, + __in PCWSTR InfFileName, + __in DWORD Flags, + __in_opt HSPFILEQ FileQueue + ); + +#ifdef UNICODE +#define SetupDiInstallClass SetupDiInstallClassW +#else +#define SetupDiInstallClass SetupDiInstallClassA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDiInstallClassExA( + __in_opt HWND hwndParent, + __in_opt PCSTR InfFileName, + __in DWORD Flags, + __in_opt HSPFILEQ FileQueue, + __in_opt CONST GUID *InterfaceClassGuid, + __reserved PVOID Reserved1, + __reserved PVOID Reserved2 + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiInstallClassExW( + __in_opt HWND hwndParent, + __in_opt PCWSTR InfFileName, + __in DWORD Flags, + __in_opt HSPFILEQ FileQueue, + __in_opt CONST GUID *InterfaceClassGuid, + __reserved PVOID Reserved1, + __reserved PVOID Reserved2 + ); + +#ifdef UNICODE +#define SetupDiInstallClassEx SetupDiInstallClassExW +#else +#define SetupDiInstallClassEx SetupDiInstallClassExA +#endif + + +__checkReturn +WINSETUPAPI +HKEY +WINAPI +SetupDiOpenClassRegKey( + __in_opt CONST GUID *ClassGuid, + __in REGSAM samDesired + ); + + +// +// Flags for SetupDiOpenClassRegKeyEx +// +#define DIOCR_INSTALLER 0x00000001 // class installer registry branch +#define DIOCR_INTERFACE 0x00000002 // interface class registry branch + +__checkReturn +WINSETUPAPI +HKEY +WINAPI +SetupDiOpenClassRegKeyExA( + __in_opt CONST GUID *ClassGuid, + __in REGSAM samDesired, + __in DWORD Flags, + __in_opt PCSTR MachineName, + __reserved PVOID Reserved + ); + +__checkReturn +WINSETUPAPI +HKEY +WINAPI +SetupDiOpenClassRegKeyExW( + __in_opt CONST GUID *ClassGuid, + __in REGSAM samDesired, + __in DWORD Flags, + __in_opt PCWSTR MachineName, + __reserved PVOID Reserved + ); + +#ifdef UNICODE +#define SetupDiOpenClassRegKeyEx SetupDiOpenClassRegKeyExW +#else +#define SetupDiOpenClassRegKeyEx SetupDiOpenClassRegKeyExA +#endif + + +__checkReturn +WINSETUPAPI +HKEY +WINAPI +SetupDiCreateDeviceInterfaceRegKeyA( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, + __reserved DWORD Reserved, + __in REGSAM samDesired, + __in_opt HINF InfHandle, + __in_opt PCSTR InfSectionName + ); + +__checkReturn +WINSETUPAPI +HKEY +WINAPI +SetupDiCreateDeviceInterfaceRegKeyW( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, + __reserved DWORD Reserved, + __in REGSAM samDesired, + __in_opt HINF InfHandle, + __in_opt PCWSTR InfSectionName + ); + +#ifdef UNICODE +#define SetupDiCreateDeviceInterfaceRegKey SetupDiCreateDeviceInterfaceRegKeyW +#else +#define SetupDiCreateDeviceInterfaceRegKey SetupDiCreateDeviceInterfaceRegKeyA +#endif + +// +// Backward compatibility--do not use. +// +#define SetupDiCreateInterfaceDeviceRegKeyW SetupDiCreateDeviceInterfaceRegKeyW +#define SetupDiCreateInterfaceDeviceRegKeyA SetupDiCreateDeviceInterfaceRegKeyA +#ifdef UNICODE +#define SetupDiCreateInterfaceDeviceRegKey SetupDiCreateDeviceInterfaceRegKeyW +#else +#define SetupDiCreateInterfaceDeviceRegKey SetupDiCreateDeviceInterfaceRegKeyA +#endif + + +__checkReturn +WINSETUPAPI +HKEY +WINAPI +SetupDiOpenDeviceInterfaceRegKey( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, + __reserved DWORD Reserved, + __in REGSAM samDesired + ); + +// +// Backward compatibility--do not use. +// +#define SetupDiOpenInterfaceDeviceRegKey SetupDiOpenDeviceInterfaceRegKey + + +WINSETUPAPI +BOOL +WINAPI +SetupDiDeleteDeviceInterfaceRegKey( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, + __reserved DWORD Reserved + ); + +// +// Backward compatibility--do not use. +// +#define SetupDiDeleteInterfaceDeviceRegKey SetupDiDeleteDeviceInterfaceRegKey + + +// +// KeyType values for SetupDiCreateDevRegKey, SetupDiOpenDevRegKey, and +// SetupDiDeleteDevRegKey. +// +#define DIREG_DEV 0x00000001 // Open/Create/Delete device key +#define DIREG_DRV 0x00000002 // Open/Create/Delete driver key +#define DIREG_BOTH 0x00000004 // Delete both driver and Device key + +__checkReturn +WINSETUPAPI +HKEY +WINAPI +SetupDiCreateDevRegKeyA( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVINFO_DATA DeviceInfoData, + __in DWORD Scope, + __in DWORD HwProfile, + __in DWORD KeyType, + __in_opt HINF InfHandle, + __in_opt PCSTR InfSectionName + ); + +__checkReturn +WINSETUPAPI +HKEY +WINAPI +SetupDiCreateDevRegKeyW( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVINFO_DATA DeviceInfoData, + __in DWORD Scope, + __in DWORD HwProfile, + __in DWORD KeyType, + __in_opt HINF InfHandle, + __in_opt PCWSTR InfSectionName + ); + +#ifdef UNICODE +#define SetupDiCreateDevRegKey SetupDiCreateDevRegKeyW +#else +#define SetupDiCreateDevRegKey SetupDiCreateDevRegKeyA +#endif + + +__checkReturn +WINSETUPAPI +HKEY +WINAPI +SetupDiOpenDevRegKey( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVINFO_DATA DeviceInfoData, + __in DWORD Scope, + __in DWORD HwProfile, + __in DWORD KeyType, + __in REGSAM samDesired + ); + + +WINSETUPAPI +BOOL +WINAPI +SetupDiDeleteDevRegKey( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVINFO_DATA DeviceInfoData, + __in DWORD Scope, + __in DWORD HwProfile, + __in DWORD KeyType + ); + + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetHwProfileList( + __out_ecount(HwProfileListSize) PDWORD HwProfileList, + __in DWORD HwProfileListSize, + __out PDWORD RequiredSize, + __out_opt PDWORD CurrentlyActiveIndex + ); + + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetHwProfileListExA( + __out_ecount(HwProfileListSize) PDWORD HwProfileList, + __in DWORD HwProfileListSize, + __out PDWORD RequiredSize, + __out_opt PDWORD CurrentlyActiveIndex, + __in_opt PCSTR MachineName, + __reserved PVOID Reserved + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetHwProfileListExW( + __out_ecount(HwProfileListSize) PDWORD HwProfileList, + __in DWORD HwProfileListSize, + __out PDWORD RequiredSize, + __out_opt PDWORD CurrentlyActiveIndex, + __in_opt PCWSTR MachineName, + __reserved PVOID Reserved + ); + +#ifdef UNICODE +#define SetupDiGetHwProfileListEx SetupDiGetHwProfileListExW +#else +#define SetupDiGetHwProfileListEx SetupDiGetHwProfileListExA +#endif + +#if _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetDevicePropertyKeys( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVINFO_DATA DeviceInfoData, + __out_ecount_opt(PropertyKeyCount) DEVPROPKEY *PropertyKeyArray, + __in DWORD PropertyKeyCount, + __out_opt PDWORD RequiredPropertyKeyCount, + __in DWORD Flags + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetDevicePropertyW( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVINFO_DATA DeviceInfoData, + __in CONST DEVPROPKEY *PropertyKey, + __out DEVPROPTYPE *PropertyType, + __out_bcount_opt(PropertyBufferSize) PBYTE PropertyBuffer, + __in DWORD PropertyBufferSize, + __out_opt PDWORD RequiredSize, + __in DWORD Flags + ); + +#ifdef UNICODE +#define SetupDiGetDeviceProperty SetupDiGetDevicePropertyW +#endif + +WINSETUPAPI +BOOL +WINAPI +SetupDiSetDevicePropertyW( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVINFO_DATA DeviceInfoData, + __in CONST DEVPROPKEY *PropertyKey, + __in DEVPROPTYPE PropertyType, + __in_bcount_opt(PropertyBufferSize) CONST PBYTE PropertyBuffer, + __in DWORD PropertyBufferSize, + __in DWORD Flags + ); + +#ifdef UNICODE +#define SetupDiSetDeviceProperty SetupDiSetDevicePropertyW +#endif + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetDeviceInterfacePropertyKeys( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, + __out_ecount_opt(PropertyKeyCount) DEVPROPKEY *PropertyKeyArray, + __in DWORD PropertyKeyCount, + __out_opt PDWORD RequiredPropertyKeyCount, + __in DWORD Flags + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetDeviceInterfacePropertyW( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, + __in CONST DEVPROPKEY *PropertyKey, + __out DEVPROPTYPE *PropertyType, + __out_bcount_opt(PropertyBufferSize) PBYTE PropertyBuffer, + __in DWORD PropertyBufferSize, + __out_opt PDWORD RequiredSize, + __in DWORD Flags + ); + +#ifdef UNICODE +#define SetupDiGetDeviceInterfaceProperty SetupDiGetDeviceInterfacePropertyW +#endif + +WINSETUPAPI +BOOL +WINAPI +SetupDiSetDeviceInterfacePropertyW( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, + __in CONST DEVPROPKEY *PropertyKey, + __in DEVPROPTYPE PropertyType, + __in_bcount_opt(PropertyBufferSize) CONST PBYTE PropertyBuffer, + __in DWORD PropertyBufferSize, + __in DWORD Flags + ); + +#ifdef UNICODE +#define SetupDiSetDeviceInterfaceProperty SetupDiSetDeviceInterfacePropertyW +#endif + +// +// Flags for SetupDiGetClassPropertyKeys, SetupDiGetClassProperty, and +// SetupDiSetClassProperty. +// +#define DICLASSPROP_INSTALLER 0x00000001 // device setup class property +#define DICLASSPROP_INTERFACE 0x00000002 // device interface class property + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetClassPropertyKeys( + __in CONST GUID *ClassGuid, + __out_ecount_opt(PropertyKeyCount) DEVPROPKEY *PropertyKeyArray, + __in DWORD PropertyKeyCount, + __out_opt PDWORD RequiredPropertyKeyCount, + __in DWORD Flags + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetClassPropertyKeysExW( + __in CONST GUID *ClassGuid, + __out_ecount_opt(PropertyKeyCount) DEVPROPKEY *PropertyKeyArray, + __in DWORD PropertyKeyCount, + __out_opt PDWORD RequiredPropertyKeyCount, + __in DWORD Flags, + __in_opt PCWSTR MachineName, + __reserved PVOID Reserved + ); + +#ifdef UNICODE +#define SetupDiGetClassPropertyKeysEx SetupDiGetClassPropertyKeysExW +#endif + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetClassPropertyW( + __in CONST GUID *ClassGuid, + __in CONST DEVPROPKEY *PropertyKey, + __out DEVPROPTYPE *PropertyType, + __out_bcount_opt(PropertyBufferSize) PBYTE PropertyBuffer, + __in DWORD PropertyBufferSize, + __out_opt PDWORD RequiredSize, + __in DWORD Flags + ); + +#ifdef UNICODE +#define SetupDiGetClassProperty SetupDiGetClassPropertyW +#endif + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetClassPropertyExW( + __in CONST GUID *ClassGuid, + __in CONST DEVPROPKEY *PropertyKey, + __out DEVPROPTYPE *PropertyType, + __out_bcount_opt(PropertyBufferSize) PBYTE PropertyBuffer, + __in DWORD PropertyBufferSize, + __out_opt PDWORD RequiredSize, + __in DWORD Flags, + __in_opt PCWSTR MachineName, + __reserved PVOID Reserved + ); + +#ifdef UNICODE +#define SetupDiGetClassPropertyEx SetupDiGetClassPropertyExW +#endif + +WINSETUPAPI +BOOL +WINAPI +SetupDiSetClassPropertyW( + __in CONST GUID *ClassGuid, + __in CONST DEVPROPKEY *PropertyKey, + __in DEVPROPTYPE PropertyType, + __in_bcount_opt(PropertyBufferSize) CONST PBYTE PropertyBuffer, + __in DWORD PropertyBufferSize, + __in DWORD Flags + ); + +#ifdef UNICODE +#define SetupDiSetClassProperty SetupDiSetClassPropertyW +#endif + +WINSETUPAPI +BOOL +WINAPI +SetupDiSetClassPropertyExW( + __in CONST GUID *ClassGuid, + __in CONST DEVPROPKEY *PropertyKey, + __in DEVPROPTYPE PropertyType, + __in_bcount_opt(PropertyBufferSize) CONST PBYTE PropertyBuffer, + __in DWORD PropertyBufferSize, + __in DWORD Flags, + __in_opt PCWSTR MachineName, + __reserved PVOID Reserved + ); + +#ifdef UNICODE +#define SetupDiSetClassPropertyEx SetupDiSetClassPropertyExW +#endif + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + + +// +// Device registry property codes +// (Codes marked as read-only (R) may only be used for +// SetupDiGetDeviceRegistryProperty) +// +// These values should cover the same set of registry properties +// as defined by the CM_DRP codes in cfgmgr32.h. +// +// Note that SPDRP codes are zero based while CM_DRP codes are one based! +// +#define SPDRP_DEVICEDESC (0x00000000) // DeviceDesc (R/W) +#define SPDRP_HARDWAREID (0x00000001) // HardwareID (R/W) +#define SPDRP_COMPATIBLEIDS (0x00000002) // CompatibleIDs (R/W) +#define SPDRP_UNUSED0 (0x00000003) // unused +#define SPDRP_SERVICE (0x00000004) // Service (R/W) +#define SPDRP_UNUSED1 (0x00000005) // unused +#define SPDRP_UNUSED2 (0x00000006) // unused +#define SPDRP_CLASS (0x00000007) // Class (R--tied to ClassGUID) +#define SPDRP_CLASSGUID (0x00000008) // ClassGUID (R/W) +#define SPDRP_DRIVER (0x00000009) // Driver (R/W) +#define SPDRP_CONFIGFLAGS (0x0000000A) // ConfigFlags (R/W) +#define SPDRP_MFG (0x0000000B) // Mfg (R/W) +#define SPDRP_FRIENDLYNAME (0x0000000C) // FriendlyName (R/W) +#define SPDRP_LOCATION_INFORMATION (0x0000000D) // LocationInformation (R/W) +#define SPDRP_PHYSICAL_DEVICE_OBJECT_NAME (0x0000000E) // PhysicalDeviceObjectName (R) +#define SPDRP_CAPABILITIES (0x0000000F) // Capabilities (R) +#define SPDRP_UI_NUMBER (0x00000010) // UiNumber (R) +#define SPDRP_UPPERFILTERS (0x00000011) // UpperFilters (R/W) +#define SPDRP_LOWERFILTERS (0x00000012) // LowerFilters (R/W) +#define SPDRP_BUSTYPEGUID (0x00000013) // BusTypeGUID (R) +#define SPDRP_LEGACYBUSTYPE (0x00000014) // LegacyBusType (R) +#define SPDRP_BUSNUMBER (0x00000015) // BusNumber (R) +#define SPDRP_ENUMERATOR_NAME (0x00000016) // Enumerator Name (R) +#define SPDRP_SECURITY (0x00000017) // Security (R/W, binary form) +#define SPDRP_SECURITY_SDS (0x00000018) // Security (W, SDS form) +#define SPDRP_DEVTYPE (0x00000019) // Device Type (R/W) +#define SPDRP_EXCLUSIVE (0x0000001A) // Device is exclusive-access (R/W) +#define SPDRP_CHARACTERISTICS (0x0000001B) // Device Characteristics (R/W) +#define SPDRP_ADDRESS (0x0000001C) // Device Address (R) +#define SPDRP_UI_NUMBER_DESC_FORMAT (0X0000001D) // UiNumberDescFormat (R/W) +#define SPDRP_DEVICE_POWER_DATA (0x0000001E) // Device Power Data (R) +#define SPDRP_REMOVAL_POLICY (0x0000001F) // Removal Policy (R) +#define SPDRP_REMOVAL_POLICY_HW_DEFAULT (0x00000020) // Hardware Removal Policy (R) +#define SPDRP_REMOVAL_POLICY_OVERRIDE (0x00000021) // Removal Policy Override (RW) +#define SPDRP_INSTALL_STATE (0x00000022) // Device Install State (R) +#define SPDRP_LOCATION_PATHS (0x00000023) // Device Location Paths (R) +#define SPDRP_BASE_CONTAINERID (0x00000024) // Base ContainerID (R) + +#define SPDRP_MAXIMUM_PROPERTY (0x00000025) // Upper bound on ordinals + +// +// Class registry property codes +// (Codes marked as read-only (R) may only be used for +// SetupDiGetClassRegistryProperty) +// +// These values should cover the same set of registry properties +// as defined by the CM_CRP codes in cfgmgr32.h. +// they should also have a 1:1 correspondence with Device registers, where applicable +// but no overlap otherwise +// +#define SPCRP_UPPERFILTERS (0x00000011) // UpperFilters (R/W) +#define SPCRP_LOWERFILTERS (0x00000012) // LowerFilters (R/W) +#define SPCRP_SECURITY (0x00000017) // Security (R/W, binary form) +#define SPCRP_SECURITY_SDS (0x00000018) // Security (W, SDS form) +#define SPCRP_DEVTYPE (0x00000019) // Device Type (R/W) +#define SPCRP_EXCLUSIVE (0x0000001A) // Device is exclusive-access (R/W) +#define SPCRP_CHARACTERISTICS (0x0000001B) // Device Characteristics (R/W) +#define SPCRP_MAXIMUM_PROPERTY (0x0000001C) // Upper bound on ordinals + + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetDeviceRegistryPropertyA( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVINFO_DATA DeviceInfoData, + __in DWORD Property, + __out_opt PDWORD PropertyRegDataType, + __out_bcount_opt(PropertyBufferSize) PBYTE PropertyBuffer, + __in DWORD PropertyBufferSize, + __out_opt PDWORD RequiredSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetDeviceRegistryPropertyW( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVINFO_DATA DeviceInfoData, + __in DWORD Property, + __out_opt PDWORD PropertyRegDataType, + __out_bcount_opt(PropertyBufferSize) PBYTE PropertyBuffer, + __in DWORD PropertyBufferSize, + __out_opt PDWORD RequiredSize + ); + +#ifdef UNICODE +#define SetupDiGetDeviceRegistryProperty SetupDiGetDeviceRegistryPropertyW +#else +#define SetupDiGetDeviceRegistryProperty SetupDiGetDeviceRegistryPropertyA +#endif + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetClassRegistryPropertyA( + __in CONST GUID *ClassGuid, + __in DWORD Property, + __out_opt PDWORD PropertyRegDataType, + __out_bcount(PropertyBufferSize) PBYTE PropertyBuffer, + __in DWORD PropertyBufferSize, + __out_opt PDWORD RequiredSize, + __in_opt PCSTR MachineName, + __reserved PVOID Reserved + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetClassRegistryPropertyW( + __in CONST GUID *ClassGuid, + __in DWORD Property, + __out_opt PDWORD PropertyRegDataType, + __out_bcount(PropertyBufferSize) PBYTE PropertyBuffer, + __in DWORD PropertyBufferSize, + __out_opt PDWORD RequiredSize, + __in_opt PCWSTR MachineName, + __reserved PVOID Reserved + ); + +#ifdef UNICODE +#define SetupDiGetClassRegistryProperty SetupDiGetClassRegistryPropertyW +#else +#define SetupDiGetClassRegistryProperty SetupDiGetClassRegistryPropertyA +#endif + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +WINSETUPAPI +BOOL +WINAPI +SetupDiSetDeviceRegistryPropertyA( + __in HDEVINFO DeviceInfoSet, + __inout PSP_DEVINFO_DATA DeviceInfoData, + __in DWORD Property, + __in_bcount_opt(PropertyBufferSize) CONST BYTE *PropertyBuffer, + __in DWORD PropertyBufferSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiSetDeviceRegistryPropertyW( + __in HDEVINFO DeviceInfoSet, + __inout PSP_DEVINFO_DATA DeviceInfoData, + __in DWORD Property, + __in_bcount_opt(PropertyBufferSize) CONST BYTE *PropertyBuffer, + __in DWORD PropertyBufferSize + ); + +#ifdef UNICODE +#define SetupDiSetDeviceRegistryProperty SetupDiSetDeviceRegistryPropertyW +#else +#define SetupDiSetDeviceRegistryProperty SetupDiSetDeviceRegistryPropertyA +#endif + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +WINSETUPAPI +BOOL +WINAPI +SetupDiSetClassRegistryPropertyA( + __in CONST GUID *ClassGuid, + __in DWORD Property, + __in_bcount_opt(PropertyBufferSize) CONST BYTE *PropertyBuffer, + __in DWORD PropertyBufferSize, + __in_opt PCSTR MachineName, + __reserved PVOID Reserved + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiSetClassRegistryPropertyW( + __in CONST GUID *ClassGuid, + __in DWORD Property, + __in_bcount_opt(PropertyBufferSize) CONST BYTE *PropertyBuffer, + __in DWORD PropertyBufferSize, + __in_opt PCWSTR MachineName, + __reserved PVOID Reserved + ); + +#ifdef UNICODE +#define SetupDiSetClassRegistryProperty SetupDiSetClassRegistryPropertyW +#else +#define SetupDiSetClassRegistryProperty SetupDiSetClassRegistryPropertyA +#endif + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetDeviceInstallParamsA( + __in HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData, + __out PSP_DEVINSTALL_PARAMS_A DeviceInstallParams + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetDeviceInstallParamsW( + __in HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData, + __out PSP_DEVINSTALL_PARAMS_W DeviceInstallParams + ); + +#ifdef UNICODE +#define SetupDiGetDeviceInstallParams SetupDiGetDeviceInstallParamsW +#else +#define SetupDiGetDeviceInstallParams SetupDiGetDeviceInstallParamsA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetClassInstallParamsA( + __in HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData, + __out_bcount_opt(ClassInstallParamsSize) PSP_CLASSINSTALL_HEADER ClassInstallParams, + __in DWORD ClassInstallParamsSize, + __out_opt PDWORD RequiredSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetClassInstallParamsW( + __in HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData, + __out_bcount_opt(ClassInstallParamsSize) PSP_CLASSINSTALL_HEADER ClassInstallParams, + __in DWORD ClassInstallParamsSize, + __out_opt PDWORD RequiredSize + ); + +#ifdef UNICODE +#define SetupDiGetClassInstallParams SetupDiGetClassInstallParamsW +#else +#define SetupDiGetClassInstallParams SetupDiGetClassInstallParamsA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDiSetDeviceInstallParamsA( + __in HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData, + __in PSP_DEVINSTALL_PARAMS_A DeviceInstallParams + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiSetDeviceInstallParamsW( + __in HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData, + __in PSP_DEVINSTALL_PARAMS_W DeviceInstallParams + ); + +#ifdef UNICODE +#define SetupDiSetDeviceInstallParams SetupDiSetDeviceInstallParamsW +#else +#define SetupDiSetDeviceInstallParams SetupDiSetDeviceInstallParamsA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDiSetClassInstallParamsA( + __in HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData, + __in_bcount_opt(ClassInstallParamsSize) PSP_CLASSINSTALL_HEADER ClassInstallParams, + __in DWORD ClassInstallParamsSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiSetClassInstallParamsW( + __in HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData, + __in_bcount_opt(ClassInstallParamsSize) PSP_CLASSINSTALL_HEADER ClassInstallParams, + __in DWORD ClassInstallParamsSize + ); + +#ifdef UNICODE +#define SetupDiSetClassInstallParams SetupDiSetClassInstallParamsW +#else +#define SetupDiSetClassInstallParams SetupDiSetClassInstallParamsA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetDriverInstallParamsA( + __in HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData, + __in PSP_DRVINFO_DATA_A DriverInfoData, + __out PSP_DRVINSTALL_PARAMS DriverInstallParams + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetDriverInstallParamsW( + __in HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData, + __in PSP_DRVINFO_DATA_W DriverInfoData, + __out PSP_DRVINSTALL_PARAMS DriverInstallParams + ); + +#ifdef UNICODE +#define SetupDiGetDriverInstallParams SetupDiGetDriverInstallParamsW +#else +#define SetupDiGetDriverInstallParams SetupDiGetDriverInstallParamsA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDiSetDriverInstallParamsA( + __in HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData, + __in PSP_DRVINFO_DATA_A DriverInfoData, + __in PSP_DRVINSTALL_PARAMS DriverInstallParams + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiSetDriverInstallParamsW( + __in HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData, + __in PSP_DRVINFO_DATA_W DriverInfoData, + __in PSP_DRVINSTALL_PARAMS DriverInstallParams + ); + +#ifdef UNICODE +#define SetupDiSetDriverInstallParams SetupDiSetDriverInstallParamsW +#else +#define SetupDiSetDriverInstallParams SetupDiSetDriverInstallParamsA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDiLoadClassIcon( + __in CONST GUID *ClassGuid, + __out_opt HICON *LargeIcon, + __out_opt PINT MiniIconIndex + ); + +#if _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + +WINSETUPAPI +BOOL +WINAPI +SetupDiLoadDeviceIcon( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVINFO_DATA DeviceInfoData, + __in UINT cxIcon, + __in UINT cyIcon, + __in DWORD Flags, + __out HICON *hIcon + ); + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + + +// +// Flags controlling the drawing of mini-icons +// +#define DMI_MASK 0x00000001 +#define DMI_BKCOLOR 0x00000002 +#define DMI_USERECT 0x00000004 + +WINSETUPAPI +INT +WINAPI +SetupDiDrawMiniIcon( + __in HDC hdc, + __in RECT rc, + __in INT MiniIconIndex, + __in DWORD Flags + ); + + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetClassBitmapIndex( + __in_opt CONST GUID *ClassGuid, + __out PINT MiniIconIndex + ); + + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetClassImageList( + __out PSP_CLASSIMAGELIST_DATA ClassImageListData + ); + + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetClassImageListExA( + __out PSP_CLASSIMAGELIST_DATA ClassImageListData, + __in_opt PCSTR MachineName, + __reserved PVOID Reserved + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetClassImageListExW( + __out PSP_CLASSIMAGELIST_DATA ClassImageListData, + __in_opt PCWSTR MachineName, + __reserved PVOID Reserved + ); + +#ifdef UNICODE +#define SetupDiGetClassImageListEx SetupDiGetClassImageListExW +#else +#define SetupDiGetClassImageListEx SetupDiGetClassImageListExA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetClassImageIndex( + __in PSP_CLASSIMAGELIST_DATA ClassImageListData, + __in CONST GUID *ClassGuid, + __out PINT ImageIndex + ); + + +WINSETUPAPI +BOOL +WINAPI +SetupDiDestroyClassImageList( + __in PSP_CLASSIMAGELIST_DATA ClassImageListData + ); + + +// +// PropertySheetType values for the SetupDiGetClassDevPropertySheets API +// +#define DIGCDP_FLAG_BASIC 0x00000001 +#define DIGCDP_FLAG_ADVANCED 0x00000002 + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +#define DIGCDP_FLAG_REMOTE_BASIC 0x00000003 // not presently implemented +#define DIGCDP_FLAG_REMOTE_ADVANCED 0x00000004 + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetClassDevPropertySheetsA( + __in HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData, + __in LPPROPSHEETHEADERA PropertySheetHeader, + __in DWORD PropertySheetHeaderPageListSize, + __out_opt PDWORD RequiredSize, + __in DWORD PropertySheetType + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetClassDevPropertySheetsW( + __in HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData, + __in LPPROPSHEETHEADERW PropertySheetHeader, + __in DWORD PropertySheetHeaderPageListSize, + __out_opt PDWORD RequiredSize, + __in DWORD PropertySheetType + ); + +#ifdef UNICODE +#define SetupDiGetClassDevPropertySheets SetupDiGetClassDevPropertySheetsW +#else +#define SetupDiGetClassDevPropertySheets SetupDiGetClassDevPropertySheetsA +#endif + + +// +// Define ICON IDs publicly exposed from setupapi. +// +#define IDI_RESOURCEFIRST 159 +#define IDI_RESOURCE 159 +#define IDI_RESOURCELAST 161 +#define IDI_RESOURCEOVERLAYFIRST 161 +#define IDI_RESOURCEOVERLAYLAST 161 +#define IDI_CONFLICT 161 + +#define IDI_CLASSICON_OVERLAYFIRST 500 +#define IDI_CLASSICON_OVERLAYLAST 502 +#define IDI_PROBLEM_OVL 500 +#define IDI_DISABLED_OVL 501 +#define IDI_FORCED_OVL 502 + + +WINSETUPAPI +BOOL +WINAPI +SetupDiAskForOEMDisk( + __in HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData + ); + + +WINSETUPAPI +BOOL +WINAPI +SetupDiSelectOEMDrv( + __in_opt HWND hwndParent, + __in HDEVINFO DeviceInfoSet, + __inout_opt PSP_DEVINFO_DATA DeviceInfoData + ); + + +WINSETUPAPI +BOOL +WINAPI +SetupDiClassNameFromGuidA( + __in CONST GUID *ClassGuid, + __out_ecount(ClassNameSize) PSTR ClassName, + __in DWORD ClassNameSize, + __out_opt PDWORD RequiredSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiClassNameFromGuidW( + __in CONST GUID *ClassGuid, + __out_ecount(ClassNameSize) PWSTR ClassName, + __in DWORD ClassNameSize, + __out_opt PDWORD RequiredSize + ); + +#ifdef UNICODE +#define SetupDiClassNameFromGuid SetupDiClassNameFromGuidW +#else +#define SetupDiClassNameFromGuid SetupDiClassNameFromGuidA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDiClassNameFromGuidExA( + __in CONST GUID *ClassGuid, + __out_ecount(ClassNameSize) PSTR ClassName, + __in DWORD ClassNameSize, + __out_opt PDWORD RequiredSize, + __in_opt PCSTR MachineName, + __reserved PVOID Reserved + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiClassNameFromGuidExW( + __in CONST GUID *ClassGuid, + __out_ecount(ClassNameSize) PWSTR ClassName, + __in DWORD ClassNameSize, + __out_opt PDWORD RequiredSize, + __in_opt PCWSTR MachineName, + __reserved PVOID Reserved + ); + +#ifdef UNICODE +#define SetupDiClassNameFromGuidEx SetupDiClassNameFromGuidExW +#else +#define SetupDiClassNameFromGuidEx SetupDiClassNameFromGuidExA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDiClassGuidsFromNameA( + __in PCSTR ClassName, + __out_ecount(ClassGuidListSize) LPGUID ClassGuidList, + __in DWORD ClassGuidListSize, + __out PDWORD RequiredSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiClassGuidsFromNameW( + __in PCWSTR ClassName, + __out_ecount(ClassGuidListSize) LPGUID ClassGuidList, + __in DWORD ClassGuidListSize, + __out PDWORD RequiredSize + ); + +#ifdef UNICODE +#define SetupDiClassGuidsFromName SetupDiClassGuidsFromNameW +#else +#define SetupDiClassGuidsFromName SetupDiClassGuidsFromNameA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDiClassGuidsFromNameExA( + __in PCSTR ClassName, + __out_ecount(ClassGuidListSize) LPGUID ClassGuidList, + __in DWORD ClassGuidListSize, + __out PDWORD RequiredSize, + __in_opt PCSTR MachineName, + __reserved PVOID Reserved + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiClassGuidsFromNameExW( + __in PCWSTR ClassName, + __out_ecount(ClassGuidListSize) LPGUID ClassGuidList, + __in DWORD ClassGuidListSize, + __out PDWORD RequiredSize, + __in_opt PCWSTR MachineName, + __reserved PVOID Reserved + ); + +#ifdef UNICODE +#define SetupDiClassGuidsFromNameEx SetupDiClassGuidsFromNameExW +#else +#define SetupDiClassGuidsFromNameEx SetupDiClassGuidsFromNameExA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetHwProfileFriendlyNameA( + __in DWORD HwProfile, + __out_ecount(FriendlyNameSize) PSTR FriendlyName, + __in DWORD FriendlyNameSize, + __out_opt PDWORD RequiredSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetHwProfileFriendlyNameW( + __in DWORD HwProfile, + __out_ecount(FriendlyNameSize) PWSTR FriendlyName, + __in DWORD FriendlyNameSize, + __out_opt PDWORD RequiredSize + ); + +#ifdef UNICODE +#define SetupDiGetHwProfileFriendlyName SetupDiGetHwProfileFriendlyNameW +#else +#define SetupDiGetHwProfileFriendlyName SetupDiGetHwProfileFriendlyNameA +#endif + + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetHwProfileFriendlyNameExA( + __in DWORD HwProfile, + __out_ecount(FriendlyNameSize) PSTR FriendlyName, + __in DWORD FriendlyNameSize, + __out_opt PDWORD RequiredSize, + __in_opt PCSTR MachineName, + __reserved PVOID Reserved + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetHwProfileFriendlyNameExW( + __in DWORD HwProfile, + __out_ecount(FriendlyNameSize) PWSTR FriendlyName, + __in DWORD FriendlyNameSize, + __out_opt PDWORD RequiredSize, + __in_opt PCWSTR MachineName, + __reserved PVOID Reserved + ); + +#ifdef UNICODE +#define SetupDiGetHwProfileFriendlyNameEx SetupDiGetHwProfileFriendlyNameExW +#else +#define SetupDiGetHwProfileFriendlyNameEx SetupDiGetHwProfileFriendlyNameExA +#endif + + +// +// PageType values for SetupDiGetWizardPage API +// +#define SPWPT_SELECTDEVICE 0x00000001 + +// +// Flags for SetupDiGetWizardPage API +// +#define SPWP_USE_DEVINFO_DATA 0x00000001 + +WINSETUPAPI +HPROPSHEETPAGE +WINAPI +SetupDiGetWizardPage( + __in HDEVINFO DeviceInfoSet, + __in_opt PSP_DEVINFO_DATA DeviceInfoData, + __in PSP_INSTALLWIZARD_DATA InstallWizardData, + __in DWORD PageType, + __in DWORD Flags + ); + + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetSelectedDevice( + __in HDEVINFO DeviceInfoSet, + __out PSP_DEVINFO_DATA DeviceInfoData + ); + + +WINSETUPAPI +BOOL +WINAPI +SetupDiSetSelectedDevice( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVINFO_DATA DeviceInfoData + ); + + +#if _SETUPAPI_VER >= _WIN32_WINNT_WS03 + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetActualModelsSectionA( + __in PINFCONTEXT Context, + __in_opt PSP_ALTPLATFORM_INFO AlternatePlatformInfo, + __out_ecount_opt(InfSectionWithExtSize) PSTR InfSectionWithExt, + __in DWORD InfSectionWithExtSize, + __out_opt PDWORD RequiredSize, + __reserved PVOID Reserved + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetActualModelsSectionW( + __in PINFCONTEXT Context, + __in_opt PSP_ALTPLATFORM_INFO AlternatePlatformInfo, + __out_ecount_opt(InfSectionWithExtSize) PWSTR InfSectionWithExt, + __in DWORD InfSectionWithExtSize, + __out_opt PDWORD RequiredSize, + __reserved PVOID Reserved + ); + +#ifdef UNICODE +#define SetupDiGetActualModelsSection SetupDiGetActualModelsSectionW +#else +#define SetupDiGetActualModelsSection SetupDiGetActualModelsSectionA +#endif + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WS03 + + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetActualSectionToInstallA( + __in HINF InfHandle, + __in PCSTR InfSectionName, + __out_ecount_opt(InfSectionWithExtSize) PSTR InfSectionWithExt, + __in DWORD InfSectionWithExtSize, + __out_opt PDWORD RequiredSize, + __out_opt PSTR *Extension + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetActualSectionToInstallW( + __in HINF InfHandle, + __in PCWSTR InfSectionName, + __out_ecount_opt(InfSectionWithExtSize) PWSTR InfSectionWithExt, + __in DWORD InfSectionWithExtSize, + __out_opt PDWORD RequiredSize, + __out_opt PWSTR *Extension + ); + +#ifdef UNICODE +#define SetupDiGetActualSectionToInstall SetupDiGetActualSectionToInstallW +#else +#define SetupDiGetActualSectionToInstall SetupDiGetActualSectionToInstallA +#endif + + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetActualSectionToInstallExA( + __in HINF InfHandle, + __in PCSTR InfSectionName, + __in_opt PSP_ALTPLATFORM_INFO AlternatePlatformInfo, + __out_ecount_opt(InfSectionWithExtSize) PSTR InfSectionWithExt, + __in DWORD InfSectionWithExtSize, + __out_opt PDWORD RequiredSize, + __out_opt PSTR *Extension, + __reserved PVOID Reserved + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetActualSectionToInstallExW( + __in HINF InfHandle, + __in PCWSTR InfSectionName, + __in_opt PSP_ALTPLATFORM_INFO AlternatePlatformInfo, + __out_ecount_opt(InfSectionWithExtSize) PWSTR InfSectionWithExt, + __in DWORD InfSectionWithExtSize, + __out_opt PDWORD RequiredSize, + __out_opt PWSTR *Extension, + __reserved PVOID Reserved + ); + +#ifdef UNICODE +#define SetupDiGetActualSectionToInstallEx SetupDiGetActualSectionToInstallExW +#else +#define SetupDiGetActualSectionToInstallEx SetupDiGetActualSectionToInstallExA +#endif + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +// +// SetupEnumInfSections is for low-level parsing of an INF +// +WINSETUPAPI +BOOL +WINAPI +SetupEnumInfSectionsA ( + __in HINF InfHandle, + __in UINT Index, + __out_ecount_opt(Size) PSTR Buffer, + __in UINT Size, + __out_opt UINT *SizeNeeded + ); + +WINSETUPAPI +BOOL +WINAPI +SetupEnumInfSectionsW ( + __in HINF InfHandle, + __in UINT Index, + __out_ecount_opt(Size) PWSTR Buffer, + __in UINT Size, + __out_opt UINT *SizeNeeded + ); + +#ifdef UNICODE +#define SetupEnumInfSections SetupEnumInfSectionsW +#else +#define SetupEnumInfSections SetupEnumInfSectionsA +#endif + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +typedef struct _SP_INF_SIGNER_INFO_V1_A { + DWORD cbSize; + CHAR CatalogFile[MAX_PATH]; + CHAR DigitalSigner[MAX_PATH]; + CHAR DigitalSignerVersion[MAX_PATH]; +} SP_INF_SIGNER_INFO_V1_A, *PSP_INF_SIGNER_INFO_V1_A; + +typedef struct _SP_INF_SIGNER_INFO_V1_W { + DWORD cbSize; + WCHAR CatalogFile[MAX_PATH]; + WCHAR DigitalSigner[MAX_PATH]; + WCHAR DigitalSignerVersion[MAX_PATH]; +} SP_INF_SIGNER_INFO_V1_W, *PSP_INF_SIGNER_INFO_V1_W; + +#ifdef UNICODE +typedef SP_INF_SIGNER_INFO_V1_W SP_INF_SIGNER_INFO_V1; +typedef PSP_INF_SIGNER_INFO_V1_W PSP_INF_SIGNER_INFO_V1; +#else +typedef SP_INF_SIGNER_INFO_V1_A SP_INF_SIGNER_INFO_V1; +typedef PSP_INF_SIGNER_INFO_V1_A PSP_INF_SIGNER_INFO_V1; +#endif + +#if _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + +typedef struct _SP_INF_SIGNER_INFO_V2_A { + DWORD cbSize; + CHAR CatalogFile[MAX_PATH]; + CHAR DigitalSigner[MAX_PATH]; + CHAR DigitalSignerVersion[MAX_PATH]; + DWORD SignerScore; +} SP_INF_SIGNER_INFO_V2_A, *PSP_INF_SIGNER_INFO_V2_A; + +typedef struct _SP_INF_SIGNER_INFO_V2_W { + DWORD cbSize; + WCHAR CatalogFile[MAX_PATH]; + WCHAR DigitalSigner[MAX_PATH]; + WCHAR DigitalSignerVersion[MAX_PATH]; + DWORD SignerScore; +} SP_INF_SIGNER_INFO_V2_W, *PSP_INF_SIGNER_INFO_V2_W; + +#ifdef UNICODE +typedef SP_INF_SIGNER_INFO_V2_W SP_INF_SIGNER_INFO_V2; +typedef PSP_INF_SIGNER_INFO_V2_W PSP_INF_SIGNER_INFO_V2; +#else +typedef SP_INF_SIGNER_INFO_V2_A SP_INF_SIGNER_INFO_V2; +typedef PSP_INF_SIGNER_INFO_V2_A PSP_INF_SIGNER_INFO_V2; +#endif + +// +// Driver signer scores (high order bit of the signing byte means unsigned) +// +#define SIGNERSCORE_UNKNOWN 0xFF000000 +#define SIGNERSCORE_W9X_SUSPECT 0xC0000000 +#define SIGNERSCORE_UNSIGNED 0x80000000 +#define SIGNERSCORE_AUTHENTICODE 0x0F000000 +#define SIGNERSCORE_WHQL 0x0D000005 // base WHQL. +#define SIGNERSCORE_UNCLASSIFIED 0x0D000004 // UNCLASSIFIED == INBOX == STANDARD == PREMIUM when the SIGNERSCORE_MASK +#define SIGNERSCORE_INBOX 0x0D000003 // filter is applied. +#define SIGNERSCORE_LOGO_STANDARD 0x0D000002 +#define SIGNERSCORE_LOGO_PREMIUM 0x0D000001 + +#define SIGNERSCORE_MASK 0xFF000000 // Mask out all but the upper BYTE which contains the ranking signer information +#define SIGNERSCORE_SIGNED_MASK 0xF0000000 // Mask out only the upper nibble, which tells us if the package is signed or not. + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_LONGHORN + +#if USE_SP_INF_SIGNER_INFO_V1 || (_SETUPAPI_VER < _WIN32_WINNT_LONGHORN) // use version 1 signer info structure + +typedef SP_INF_SIGNER_INFO_V1_A SP_INF_SIGNER_INFO_A; +typedef PSP_INF_SIGNER_INFO_V1_A PSP_INF_SIGNER_INFO_A; +typedef SP_INF_SIGNER_INFO_V1_W SP_INF_SIGNER_INFO_W; +typedef PSP_INF_SIGNER_INFO_V1_W PSP_INF_SIGNER_INFO_W; +typedef SP_INF_SIGNER_INFO_V1 SP_INF_SIGNER_INFO; +typedef PSP_INF_SIGNER_INFO_V1 PSP_INF_SIGNER_INFO; + +#else // use version 2 signer info structure + +typedef SP_INF_SIGNER_INFO_V2_A SP_INF_SIGNER_INFO_A; +typedef PSP_INF_SIGNER_INFO_V2_A PSP_INF_SIGNER_INFO_A; +typedef SP_INF_SIGNER_INFO_V2_W SP_INF_SIGNER_INFO_W; +typedef PSP_INF_SIGNER_INFO_V2_W PSP_INF_SIGNER_INFO_W; +typedef SP_INF_SIGNER_INFO_V2 SP_INF_SIGNER_INFO; +typedef PSP_INF_SIGNER_INFO_V2 PSP_INF_SIGNER_INFO; + +#endif // use current version of signer info structure + + +WINSETUPAPI +BOOL +WINAPI +SetupVerifyInfFileA( + __in PCSTR InfName, + __in_opt PSP_ALTPLATFORM_INFO AltPlatformInfo, + __inout PSP_INF_SIGNER_INFO_A InfSignerInfo + ); + +WINSETUPAPI +BOOL +WINAPI +SetupVerifyInfFileW( + __in PCWSTR InfName, + __in_opt PSP_ALTPLATFORM_INFO AltPlatformInfo, + __inout PSP_INF_SIGNER_INFO_W InfSignerInfo + ); + +#ifdef UNICODE +#define SetupVerifyInfFile SetupVerifyInfFileW +#else +#define SetupVerifyInfFile SetupVerifyInfFileA +#endif + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +#if _SETUPAPI_VER >= _WIN32_WINNT_WINXP + +// +// Flags for use by SetupDiGetCustomDeviceProperty +// +#define DICUSTOMDEVPROP_MERGE_MULTISZ 0x00000001 + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetCustomDevicePropertyA( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVINFO_DATA DeviceInfoData, + __in PCSTR CustomPropertyName, + __in DWORD Flags, + __out_opt PDWORD PropertyRegDataType, + __out_bcount(PropertyBufferSize) PBYTE PropertyBuffer, + __in DWORD PropertyBufferSize, + __out_opt PDWORD RequiredSize + ); + +WINSETUPAPI +BOOL +WINAPI +SetupDiGetCustomDevicePropertyW( + __in HDEVINFO DeviceInfoSet, + __in PSP_DEVINFO_DATA DeviceInfoData, + __in PCWSTR CustomPropertyName, + __in DWORD Flags, + __out_opt PDWORD PropertyRegDataType, + __out_bcount(PropertyBufferSize) PBYTE PropertyBuffer, + __in DWORD PropertyBufferSize, + __out_opt PDWORD RequiredSize + ); + +#ifdef UNICODE +#define SetupDiGetCustomDeviceProperty SetupDiGetCustomDevicePropertyW +#else +#define SetupDiGetCustomDeviceProperty SetupDiGetCustomDevicePropertyA +#endif + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WINXP + + +#if _SETUPAPI_VER >= _WIN32_WINNT_WS03 + +// +// To configure WMI security for downlevel platforms where the [DDInstall.WMI] +// section isn't natively supported by setupapi, a redistributable co-installer +// is supplied in the DDK for use on those platforms. +// + +// +// Flags for use by SetupConfigureWmiFromInfSection +// +#define SCWMI_CLOBBER_SECURITY 0x00000001 + +WINSETUPAPI +BOOL +WINAPI +SetupConfigureWmiFromInfSectionA( + __in HINF InfHandle, + __in PCSTR SectionName, + __in DWORD Flags + ); + +WINSETUPAPI +BOOL +WINAPI +SetupConfigureWmiFromInfSectionW( + __in HINF InfHandle, + __in PCWSTR SectionName, + __in DWORD Flags + ); + +#ifdef UNICODE +#define SetupConfigureWmiFromInfSection SetupConfigureWmiFromInfSectionW +#else +#define SetupConfigureWmiFromInfSection SetupConfigureWmiFromInfSectionA +#endif + + +#endif // _SETUPAPI_VER >= _WIN32_WINNT_WS03 + + + +#ifdef __cplusplus +} +#endif + +#include + +#if defined (_MSC_VER) && (_MSC_VER >= 1200) +#pragma warning(pop) +#endif + +#endif // _INC_SETUPAPI + diff --git a/setupapi-x64/hid.lib b/setupapi-x64/hid.lib new file mode 100644 index 0000000000000000000000000000000000000000..302cf5a5b5a93ab2de0f7507816fe610dcff30b7 GIT binary patch literal 11336 zcmcIqy>lDK6@QjwOQL0&rX)%tDH8ntiY1ByMB0;NC<^*OOi~C*rLYSK1dilQAb@i? z%+M+vRjSgZa~F>bkNR{jG_LF-Gl>e#WX5Uy2dMD4OX2)>?;dXVZtn;{Bxc_1-TTA&mq^O^aZ*B2IU==?eVbw0DW=siB_BBIZT&VNVL`yY2lajJQR-tNL07)=XtF;XWzM6KPl*H#zxHShGC`B)JsLy(f=0jeX#yo^ z@(Yh9mWc$-pkIO}o_jP~ArdsT<%sZdyZxUv!z(qAC;WSjRNu6QUGAqYj_)n94UcmLS18kVYfH{f!Ow`N2*-Rm;}CRW@4aGPcO?eqOgr#Y)zymmGV~ ztvR8-85E=~X6CL{6#Y^S6fPqewBQHKWi2_G>(*Y)an<^usY)36LBqw|N7VtZiMaOF z`aP@aSh1aq%3+x=2!Ac^Db5wJSianF-CEV4r3hGeW6vtt+jdD2H62jaY*1j^KNTwt z%K#JbS(7UXBxaC6&Xy~7_0P9!m5Nmo3wNznRzrepph<(R@9eu4+^?*J4IS8^AZ>G1 z+r|2_pIF|6-mN(@==!lUUoa~$?!$U((kO0)4zAVzvt`ZaGfz z^H?BHDy?|9A}!MetQ&z=S_X@VnC%i;rU5A}lO|%Av$og?tZGRKNcn}__y?)V`Y=WMHZ8qJvbc9)Il2_c;S=H|)?q@z_Vdb*ntA0l zBKi&)*^kJM&R!yVHAM8JpXk{j(f5~$7W;@Eq5K-<$0?$(t`Kz(6Kz57+X13qp!XB> zdr*D@c@LiR;6H`V9CSY&A$pDHr(?)oC!vq>%TZ)UL47np<1|Sr8lip~qH8opS81B2XoiOAH#ADK^cEdEvbv9Z zxnVeCYAH2?4`tr~M5G8G!=2!?L-p37% zU{Q1n4+5ySU!k6Wr9@5U*LAfz?{kocDo@yiqoGR-A>>5PU!HziMob+6P2BldBfi#afyG4)8GTd46s zml&c#Na274JG|_4YeSp}DI}hR<4;M3$e~mmIi$mp^eCbzLuMFfa1*))sTNn7)rF&r zE-<9|GScW;hIpeZn4*rZ5m|X5ajWN*AXMlTC<{1F;4Nc=G<@okb&2?->l&fWu}U$F zMl4;}324Y;jx)#X0jmRxW!ryRycbJd5%Fm9|KaZWt9e<0ErFp-rWoxUkGq&Ns((mx_SAOx!CF)+jYL}4* zkIl0Pi7Nd7`mfJ8j&h0SUif-9eYV8;pQ0!DOO$$X4CPtmbmDgs7j~jklXR~8B;Nle zxgwhc?f0zOC8t)eZM&(d_36|~ZtW9at`%qSCK@4#kZOu2+@&HB6;D0_EtP7I_t3`E z`+uWfe^s@ih9pxEcXbK*t>El3M|R4?@O9Ec2P%P1Cg2D@^6%zP)J2qOz6-2B;O%fO zIJ^8Vw(J@6>6?mY9Fv~$4>ZSXCXvZA%1YzKqv9DiSR_2-@BHGI!ZSp@hdSe}%q7k} z7~hzS;?`UEvdgHTH>{oX1>t-H^2C$&^y$TZDmw( z3XQpCZ#O!neHX-tl3bAGXCgx3_>13(=*i5hpOm#=+4UXG_M3WPuzt+Fn~} z4!WU!;Ybc|@$vM;vSX|af20aw;TiyeFTm1sD28iy4Wtuh?1X~GS=mwGyshAHKHVu! z(&)XT;OH58r)X&oAfdSu+r&u?Ex1VU6f2W4`}`=dPAOQ1Qv^e{?f01&?-&8*X%#ba zFkwi)Y<*?Vn|ql8VwZv#J`Z$^moTdDDtLy&6GOH?stGInjEbq9#~7~d5lujQPeW5r zcpal9jHkFU#QK&eZNr(7A=@6$8y}f{<{W(Hea7^!vHT6EZH%P2(#;q+OdNew{y;%{ z)2N(DSZzHD&S9;#bj(bNwCAHnM{j&AFrupw6JzK>` z6@1YMFeBFv4A_1YNr;YpDq{3bsB_GOJ-pw58Qk?SWV_>= 1200 +#pragma warning(push) +#endif +#pragma warning(disable:4115) // named type definition in parentheses +#pragma warning(disable:4201) // nameless struct/union +#pragma warning(disable:4214) // bit field types other than int + +#include + +// Please include "hidsdi.h" to use the user space (dll / parser) +// Please include "hidpddi.h" to use the kernel space parser + +// +// Special Link collection values for using the query functions +// +// Root collection references the collection at the base of the link +// collection tree. +// Unspecifies, references all collections in the link collection tree. +// +#define HIDP_LINK_COLLECTION_ROOT ((USHORT) -1) +#define HIDP_LINK_COLLECTION_UNSPECIFIED ((USHORT) 0) + + +typedef enum _HIDP_REPORT_TYPE +{ + HidP_Input, + HidP_Output, + HidP_Feature +} HIDP_REPORT_TYPE; + +typedef struct _USAGE_AND_PAGE +{ + USAGE Usage; + USAGE UsagePage; +} USAGE_AND_PAGE, *PUSAGE_AND_PAGE; + +#define HidP_IsSameUsageAndPage(u1, u2) ((* (PULONG) &u1) == (* (PULONG) &u2)) + +typedef struct _HIDP_BUTTON_CAPS +{ + USAGE UsagePage; + UCHAR ReportID; + BOOLEAN IsAlias; + + USHORT BitField; + USHORT LinkCollection; // A unique internal index pointer + + USAGE LinkUsage; + USAGE LinkUsagePage; + + BOOLEAN IsRange; + BOOLEAN IsStringRange; + BOOLEAN IsDesignatorRange; + BOOLEAN IsAbsolute; + + ULONG Reserved[10]; + union { + struct { + USAGE UsageMin, UsageMax; + USHORT StringMin, StringMax; + USHORT DesignatorMin, DesignatorMax; + USHORT DataIndexMin, DataIndexMax; + } Range; + struct { + USAGE Usage, Reserved1; + USHORT StringIndex, Reserved2; + USHORT DesignatorIndex, Reserved3; + USHORT DataIndex, Reserved4; + } NotRange; + }; + +} HIDP_BUTTON_CAPS, *PHIDP_BUTTON_CAPS; + + +typedef struct _HIDP_VALUE_CAPS +{ + USAGE UsagePage; + UCHAR ReportID; + BOOLEAN IsAlias; + + USHORT BitField; + USHORT LinkCollection; // A unique internal index pointer + + USAGE LinkUsage; + USAGE LinkUsagePage; + + BOOLEAN IsRange; + BOOLEAN IsStringRange; + BOOLEAN IsDesignatorRange; + BOOLEAN IsAbsolute; + + BOOLEAN HasNull; // Does this channel have a null report union + UCHAR Reserved; + USHORT BitSize; // How many bits are devoted to this value? + + USHORT ReportCount; // See Note below. Usually set to 1. + USHORT Reserved2[5]; + + ULONG UnitsExp; + ULONG Units; + + LONG LogicalMin, LogicalMax; + LONG PhysicalMin, PhysicalMax; + + union { + struct { + USAGE UsageMin, UsageMax; + USHORT StringMin, StringMax; + USHORT DesignatorMin, DesignatorMax; + USHORT DataIndexMin, DataIndexMax; + } Range; + + struct { + USAGE Usage, Reserved1; + USHORT StringIndex, Reserved2; + USHORT DesignatorIndex, Reserved3; + USHORT DataIndex, Reserved4; + } NotRange; + }; +} HIDP_VALUE_CAPS, *PHIDP_VALUE_CAPS; + +// +// Notes: +// +// ReportCount: When a report descriptor declares an Input, Output, or +// Feature main item with fewer usage declarations than the report count, then +// the last usage applies to all remaining unspecified count in that main item. +// (As an example you might have data that required many fields to describe, +// possibly buffered bytes.) In this case, only one value cap structure is +// allocated for these associtated fields, all with the same usage, and Report +// Count reflects the number of fields involved. Normally ReportCount is 1. +// To access all of the fields in such a value structure would require using +// HidP_GetUsageValueArray and HidP_SetUsageValueArray. HidP_GetUsageValue/ +// HidP_SetScaledUsageValue will also work, however, these functions will only +// work with the first field of the structure. +// + +// +// The link collection tree consists of an array of LINK_COLLECTION_NODES +// where the index into this array is the same as the collection number. +// +// Given a collection A which contains a subcollection B, A is defined to be +// the parent B, and B is defined to be the child. +// +// Given collections A, B, and C where B and C are children of A, and B was +// encountered before C in the report descriptor, B is defined as a sibling of +// C. (This implies, of course, that if B is a sibling of C, then C is NOT a +// sibling of B). +// +// B is defined as the NextSibling of C if and only if there exists NO +// child collection of A, call it D, such that B is a sibling of D and D +// is a sibling of C. +// +// E is defined to be the FirstChild of A if and only if for all children of A, +// F, that are not equivalent to E, F is a sibling of E. +// (This implies, of course, that the does not exist a child of A, call it G, +// where E is a sibling of G). In other words the first sibling is the last +// link collection found in the list. +// +// In other words, if a collection B is defined within the definition of another +// collection A, B becomes a child of A. All collections with the same parent +// are considered siblings. The FirstChild of the parent collection, A, will be +// last collection defined that has A as a parent. The order of sibling pointers +// is similarly determined. When a collection B is defined, it becomes the +// FirstChild of it's parent collection. The previously defined FirstChild of the +// parent collection becomes the NextSibling of the new collection. As new +// collections with the same parent are discovered, the chain of sibling is built. +// +// With that in mind, the following describes conclusively a data structure +// that provides direct traversal up, down, and accross the link collection +// tree. +// +// +typedef struct _HIDP_LINK_COLLECTION_NODE +{ + USAGE LinkUsage; + USAGE LinkUsagePage; + USHORT Parent; + USHORT NumberOfChildren; + USHORT NextSibling; + USHORT FirstChild; + ULONG CollectionType: 8; // As defined in 6.2.2.6 of HID spec + ULONG IsAlias : 1; // This link node is an allias of the next link node. + ULONG Reserved: 23; + PVOID UserContext; // The user can hang his coat here. +} HIDP_LINK_COLLECTION_NODE, *PHIDP_LINK_COLLECTION_NODE; + +// +// When a link collection is described by a delimiter, alias link collection +// nodes are created. (One for each usage within the delimiter). +// The parser assigns each capability description listed above only one +// link collection. +// +// If a control is defined within a collection defined by +// delimited usages, then that control is said to be within multiple link +// collections, one for each usage within the open and close delimiter tokens. +// Such multiple link collecions are said to be aliases. The first N-1 such +// collections, listed in the link collection node array, have their IsAlias +// bit set. The last such link collection is the link collection index used +// in the capabilities described above. +// Clients wishing to set a control in an aliased collection, should walk the +// collection array once for each time they see the IsAlias flag set, and use +// the last link collection as the index for the below accessor functions. +// +// NB: if IsAlias is set, then NextSibling should be one more than the current +// link collection node index. +// + +typedef PUCHAR PHIDP_REPORT_DESCRIPTOR; +typedef struct _HIDP_PREPARSED_DATA * PHIDP_PREPARSED_DATA; + +typedef struct _HIDP_CAPS +{ + USAGE Usage; + USAGE UsagePage; + USHORT InputReportByteLength; + USHORT OutputReportByteLength; + USHORT FeatureReportByteLength; + USHORT Reserved[17]; + + USHORT NumberLinkCollectionNodes; + + USHORT NumberInputButtonCaps; + USHORT NumberInputValueCaps; + USHORT NumberInputDataIndices; + + USHORT NumberOutputButtonCaps; + USHORT NumberOutputValueCaps; + USHORT NumberOutputDataIndices; + + USHORT NumberFeatureButtonCaps; + USHORT NumberFeatureValueCaps; + USHORT NumberFeatureDataIndices; +} HIDP_CAPS, *PHIDP_CAPS; + +typedef struct _HIDP_DATA +{ + USHORT DataIndex; + USHORT Reserved; + union { + ULONG RawValue; // for values + BOOLEAN On; // for buttons MUST BE TRUE for buttons. + }; +} HIDP_DATA, *PHIDP_DATA; +// +// The HIDP_DATA structure is used with HidP_GetData and HidP_SetData +// functions. +// +// The parser contiguously assigns every control (button or value) in a hid +// device a unique data index from zero to NumberXXXDataIndices -1 , inclusive. +// This value is found in the HIDP_BUTTON_CAPS and HIDP_VALUE_CAPS structures. +// +// Most clients will find the Get/Set Buttons / Value accessor functions +// sufficient to their needs, as they will allow the clients to access the +// data known to them while ignoring the other controls. +// +// More complex clients, which actually read the Button / Value Caps, and which +// do a value add service to these routines (EG Direct Input), will need to +// access all the data in the device without interest in the individual usage +// or link collection location. These are the clients that will find +// HidP_Data useful. +// + +typedef struct _HIDP_UNKNOWN_TOKEN +{ + UCHAR Token; + UCHAR Reserved[3]; + ULONG BitField; +} HIDP_UNKNOWN_TOKEN, *PHIDP_UNKNOWN_TOKEN; + +typedef struct _HIDP_EXTENDED_ATTRIBUTES +{ + UCHAR NumGlobalUnknowns; + UCHAR Reserved [3]; + PHIDP_UNKNOWN_TOKEN GlobalUnknowns; + // ... Additional attributes + ULONG Data [1]; // variableLength DO NOT ACCESS THIS FIELD +} HIDP_EXTENDED_ATTRIBUTES, *PHIDP_EXTENDED_ATTRIBUTES; + +__checkReturn +__drv_maxIRQL(PASSIVE_LEVEL) +NTSTATUS __stdcall +HidP_GetCaps ( + __in PHIDP_PREPARSED_DATA PreparsedData, + __out PHIDP_CAPS Capabilities + ); +/*++ +Routine Description: + Returns a list of capabilities of a given hid device as described by its + preparsed data. + +Arguments: + PreparsedData The preparsed data returned from HIDCLASS. + Capabilities a HIDP_CAPS structure + +Return Value: + HIDP_STATUS_SUCCESS + HIDP_STATUS_INVALID_PREPARSED_DATA +--*/ + +__checkReturn +__drv_maxIRQL(DISPATCH_LEVEL) +NTSTATUS __stdcall +HidP_GetLinkCollectionNodes ( + OUT PHIDP_LINK_COLLECTION_NODE LinkCollectionNodes, + __inout PULONG LinkCollectionNodesLength, + __in PHIDP_PREPARSED_DATA PreparsedData + ); +/*++ +Routine Description: + Return a list of PHIDP_LINK_COLLECTION_NODEs used to describe the link + collection tree of this hid device. See the above description of + struct _HIDP_LINK_COLLECTION_NODE. + +Arguments: + LinkCollectionNodes - a caller allocated array into which + HidP_GetLinkCollectionNodes will store the information + + LinKCollectionNodesLength - the caller sets this value to the length of the + the array in terms of number of elements. + HidP_GetLinkCollectionNodes sets this value to the actual + number of elements set. The total number of nodes required to + describe this HID device can be found in the + NumberLinkCollectionNodes field in the HIDP_CAPS structure. + +--*/ + +__checkReturn +__drv_maxIRQL(PASSIVE_LEVEL) +NTSTATUS __stdcall +HidP_GetSpecificButtonCaps ( + __in HIDP_REPORT_TYPE ReportType, + __in USAGE UsagePage, // Optional (0 => ignore) + __in USHORT LinkCollection, // Optional (0 => ignore) + __in USAGE Usage, // Optional (0 => ignore) + OUT PHIDP_BUTTON_CAPS ButtonCaps, + __inout PUSHORT ButtonCapsLength, + __in PHIDP_PREPARSED_DATA PreparsedData + ); +/*++ +Description: + HidP_GetButtonCaps returns all the buttons (binary values) that are a part + of the given report type for the Hid device represented by the given + preparsed data. + +Parameters: + ReportType One of HidP_Input, HidP_Output, or HidP_Feature. + + UsagePage A usage page value used to limit the button caps returned to + those on a given usage page. If set to 0, this parameter is + ignored. Can be used with LinkCollection and Usage parameters + to further limit the number of button caps structures returned. + + LinkCollection HIDP_LINK_COLLECTION node array index used to limit the + button caps returned to those buttons in a given link + collection. If set to 0, this parameter is + ignored. Can be used with UsagePage and Usage parameters + to further limit the number of button caps structures + returned. + + Usage A usage value used to limit the button caps returned to those + with the specified usage value. If set to 0, this parameter + is ignored. Can be used with LinkCollection and UsagePage + parameters to further limit the number of button caps + structures returned. + + ButtonCaps A _HIDP_BUTTON_CAPS array containing information about all the + binary values in the given report. This buffer is provided by + the caller. + + ButtonLength As input, this parameter specifies the length of the + ButtonCaps parameter (array) in number of array elements. + As output, this value is set to indicate how many of those + array elements were filled in by the function. The maximum number of + button caps that can be returned is found in the HIDP_CAPS + structure. If HIDP_STATUS_BUFFER_TOO_SMALL is returned, + this value contains the number of array elements needed to + successfully complete the request. + + PreparsedData The preparsed data returned from HIDCLASS. + + +Return Value +HidP_GetSpecificButtonCaps returns the following error codes: + HIDP_STATUS_SUCCESS. + HIDP_STATUS_INVALID_REPORT_TYPE + HIDP_STATUS_INVALID_PREPARSED_DATA + HIDP_STATUS_BUFFER_TOO_SMALL (all given entries however have been filled in) + HIDP_STATUS_USAGE_NOT_FOUND +--*/ +__checkReturn +__drv_maxIRQL(PASSIVE_LEVEL) +NTSTATUS __stdcall +HidP_GetButtonCaps ( + __in HIDP_REPORT_TYPE ReportType, + __out_ecount_part(*ButtonCapsLength, *ButtonCapsLength) PHIDP_BUTTON_CAPS ButtonCaps, + __inout PUSHORT ButtonCapsLength, + __in PHIDP_PREPARSED_DATA PreparsedData +); + +__checkReturn +__drv_maxIRQL(DISPATCH_LEVEL) +NTSTATUS __stdcall +HidP_GetSpecificValueCaps ( + __in HIDP_REPORT_TYPE ReportType, + __in USAGE UsagePage, // Optional (0 => ignore) + __in USHORT LinkCollection, // Optional (0 => ignore) + __in USAGE Usage, // Optional (0 => ignore) + OUT PHIDP_VALUE_CAPS ValueCaps, + __inout PUSHORT ValueCapsLength, + __in PHIDP_PREPARSED_DATA PreparsedData + ); +/*++ +Description: + HidP_GetValueCaps returns all the values (non-binary) that are a part + of the given report type for the Hid device represented by the given + preparsed data. + +Parameters: + ReportType One of HidP_Input, HidP_Output, or HidP_Feature. + + UsagePage A usage page value used to limit the value caps returned to + those on a given usage page. If set to 0, this parameter is + ignored. Can be used with LinkCollection and Usage parameters + to further limit the number of value caps structures returned. + + LinkCollection HIDP_LINK_COLLECTION node array index used to limit the + value caps returned to those buttons in a given link + collection. If set to 0, this parameter is + ignored. Can be used with UsagePage and Usage parameters + to further limit the number of value caps structures + returned. + + Usage A usage value used to limit the value caps returned to those + with the specified usage value. If set to 0, this parameter + is ignored. Can be used with LinkCollection and UsagePage + parameters to further limit the number of value caps + structures returned. + + ValueCaps A _HIDP_VALUE_CAPS array containing information about all the + non-binary values in the given report. This buffer is provided + by the caller. + + ValueLength As input, this parameter specifies the length of the ValueCaps + parameter (array) in number of array elements. As output, + this value is set to indicate how many of those array elements + were filled in by the function. The maximum number of + value caps that can be returned is found in the HIDP_CAPS + structure. If HIDP_STATUS_BUFFER_TOO_SMALL is returned, + this value contains the number of array elements needed to + successfully complete the request. + + PreparsedData The preparsed data returned from HIDCLASS. + + +Return Value +HidP_GetValueCaps returns the following error codes: + HIDP_STATUS_SUCCESS. + HIDP_STATUS_INVALID_REPORT_TYPE + HIDP_STATUS_INVALID_PREPARSED_DATA + HIDP_STATUS_BUFFER_TOO_SMALL (all given entries however have been filled in) + HIDP_STATUS_USAGE_NOT_FOUND + +--*/ + +__checkReturn +__drv_maxIRQL(DISPATCH_LEVEL) +NTSTATUS __stdcall +HidP_GetValueCaps ( + __in HIDP_REPORT_TYPE ReportType, + __out_ecount_part(*ValueCapsLength, *ValueCapsLength) PHIDP_VALUE_CAPS ValueCaps, + __inout PUSHORT ValueCapsLength, + __in PHIDP_PREPARSED_DATA PreparsedData +); + +__checkReturn +__drv_maxIRQL(DISPATCH_LEVEL) +NTSTATUS __stdcall +HidP_GetExtendedAttributes ( + __in HIDP_REPORT_TYPE ReportType, + __in USHORT DataIndex, + __in PHIDP_PREPARSED_DATA PreparsedData, + __out_ecount_part(*LengthAttributes, *LengthAttributes) PHIDP_EXTENDED_ATTRIBUTES Attributes, + __inout PULONG LengthAttributes + ); +/*++ +Description: + Given a data index from the value or button capabilities of a given control + return any extended attributes for the control if any exist. + +Parameters: + ReportType One of HidP_Input, HidP_Output, or HidP_Feature. + + DataIndex The data index for the given control, found in the capabilities + structure for that control + + PreparsedData The preparsed data returned from HIDCLASS. + + Attributes Pointer to a buffer into which the extended attribute data will + be copied. + + LengthAttributes Length of the given buffer in bytes. + +Return Value + HIDP_STATUS_SUCCESS + HIDP_STATUS_DATA_INDEX_NOT_FOUND +--*/ + +__checkReturn +__drv_maxIRQL(DISPATCH_LEVEL) +NTSTATUS __stdcall +HidP_InitializeReportForID ( + __in HIDP_REPORT_TYPE ReportType, + __in UCHAR ReportID, + __in PHIDP_PREPARSED_DATA PreparsedData, + __out_bcount(ReportLength) PCHAR Report, + __in ULONG ReportLength + ); +/*++ + +Routine Description: + + Initialize a report based on the given report ID. + +Parameters: + + ReportType One of HidP_Input, HidP_Output, or HidP_Feature. + + PreparasedData Preparsed data structure returned by HIDCLASS + + Report Buffer which to set the data into. + + ReportLength Length of Report...Report should be at least as long as the + value indicated in the HIDP_CAPS structure for the device and + the corresponding ReportType + +Return Value + + HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid. + HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid + HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not equal + to the length specified in HIDP_CAPS + structure for the given ReportType + HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device + for the given ReportType + +--*/ + +__checkReturn +NTSTATUS __stdcall +HidP_SetData ( + __in HIDP_REPORT_TYPE ReportType, + __inout_ecount_part(*DataLength,*DataLength) PHIDP_DATA DataList, + __inout PULONG DataLength, + __in PHIDP_PREPARSED_DATA PreparsedData, + __in_bcount(ReportLength) PCHAR Report, + __in ULONG ReportLength + ); +/*++ + +Routine Description: + + Please Note: Since usage value arrays deal with multiple fields for + for one usage value, they cannot be used with HidP_SetData + and HidP_GetData. In this case, + HIDP_STATUS_IS_USAGE_VALUE_ARRAY will be returned. + +Parameters: + + ReportType One of HidP_Input, HidP_Output, or HidP_Feature. + + DataList Array of HIDP_DATA structures that contains the data values + that are to be set into the given report + + DataLength As input, length in array elements of DataList. As output, + contains the number of data elements set on successful + completion or an index into the DataList array to identify + the faulting HIDP_DATA value if an error code is returned. + + PreparasedData Preparsed data structure returned by HIDCLASS + + Report Buffer which to set the data into. + + ReportLength Length of Report...Report should be at least as long as the + value indicated in the HIDP_CAPS structure for the device and + the corresponding ReportType + +Return Value + HidP_SetData returns the following error codes. The report packet will + have all the data set up until the HIDP_DATA structure that caused the + error. DataLength, in the error case, will return this problem index. + + HIDP_STATUS_SUCCESS -- upon successful insertion of all data + into the report packet. + HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid. + HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid + HIDP_STATUS_DATA_INDEX_NOT_FOUND -- if a HIDP_DATA structure referenced a + data index that does not exist for this + device's ReportType + HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not equal + to the length specified in HIDP_CAPS + structure for the given ReportType + HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device + for the given ReportType + HIDP_STATUS_IS_USAGE_VALUE_ARRAY -- if one of the HIDP_DATA structures + references a usage value array. + DataLength will contain the index into + the array that was invalid + HIDP_STATUS_BUTTON_NOT_PRESSED -- if a HIDP_DATA structure attempted + to unset a button that was not already + set in the Report + HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- a HIDP_DATA structure was found with + a valid index value but is contained + in a different report than the one + currently being processed + HIDP_STATUS_BUFFER_TOO_SMALL -- if there are not enough entries in + a given Main Array Item to report all + buttons that have been requested to be + set +--*/ + +__checkReturn +__drv_maxIRQL(DISPATCH_LEVEL) +NTSTATUS __stdcall +HidP_GetData ( + __in HIDP_REPORT_TYPE ReportType, + __out_ecount_part(*DataLength,*DataLength) PHIDP_DATA DataList, + __inout PULONG DataLength, + __in PHIDP_PREPARSED_DATA PreparsedData, + __out_bcount(ReportLength) PCHAR Report, + __in ULONG ReportLength + ); +/*++ + +Routine Description: + + Please Note: For obvious reasons HidP_SetData and HidP_GetData will not + access UsageValueArrays. + +Parameters: + ReportType One of HidP_Input, HidP_Output, or HidP_Feature. + + DataList Array of HIDP_DATA structures that will receive the data + values that are set in the given report + + DataLength As input, length in array elements of DataList. As output, + contains the number of data elements that were successfully + set by HidP_GetData. The maximum size necessary for DataList + can be determined by calling HidP_MaxDataListLength + + PreparasedData Preparsed data structure returned by HIDCLASS + + Report Buffer which to set the data into. + + ReportLength Length of Report...Report should be at least as long as the + value indicated in the HIDP_CAPS structure for the device and + the corresponding ReportType + +Return Value + HidP_GetData returns the following error codes. + + HIDP_STATUS_SUCCESS -- upon successful retrieval of all data + from the report packet. + HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid. + HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid + HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not equal + to the length specified in HIDP_CAPS + structure for the given ReportType + HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device + for the given ReportType + HIDP_STATUS_BUFFER_TOO_SMALL -- if there are not enough array entries in + DataList to store all the indice values + in the given report. DataLength will + contain the number of array entries + required to hold all data +--*/ + +__drv_maxIRQL(DISPATCH_LEVEL) +ULONG __stdcall +HidP_MaxDataListLength ( + __in HIDP_REPORT_TYPE ReportType, + __in PHIDP_PREPARSED_DATA PreparsedData + ); +/*++ +Routine Description: + + This function returns the maximum length of HIDP_DATA elements that + HidP_GetData could return for the given report type. + +Parameters: + + ReportType One of HidP_Input, HidP_Output or HidP_Feature. + + PreparsedData Preparsed data structure returned by HIDCLASS + +Return Value: + + The length of the data list array required for the HidP_GetData function + call. If an error occurs (either HIDP_STATUS_INVALID_REPORT_TYPE or + HIDP_STATUS_INVALID_PREPARSED_DATA), this function returns 0. + +--*/ + +#define HidP_SetButtons(Rty, Up, Lco, ULi, ULe, Ppd, Rep, Rle) \ + HidP_SetUsages(Rty, Up, Lco, ULi, ULe, Ppd, Rep, Rle) + +__checkReturn +NTSTATUS __stdcall +HidP_SetUsages ( + __in HIDP_REPORT_TYPE ReportType, + __in USAGE UsagePage, + __in USHORT LinkCollection, + __inout_ecount_part(*UsageLength,*UsageLength) PUSAGE UsageList, + __inout PULONG UsageLength, + __in PHIDP_PREPARSED_DATA PreparsedData, + __in_bcount(ReportLength) PCHAR Report, + __in ULONG ReportLength + ); +/*++ + +Routine Description: + This function sets binary values (buttons) in a report. Given an + initialized packet of correct length, it modifies the report packet so that + each element in the given list of usages has been set in the report packet. + For example, in an output report with 5 LED's, each with a given usage, + an application could turn on any subset of these lights by placing their + usages in any order into the usage array (UsageList). HidP_SetUsages would, + in turn, set the appropriate bit or add the corresponding byte into the + HID Main Array Item. + + A properly initialized Report packet is one of the correct byte length, + and all zeros. + + NOTE: A packet that has already been set with a call to a HidP_Set routine + can also be passed in. This routine then sets processes the UsageList + in the same fashion but verifies that the ReportID already set in + Report matches the report ID for the given usages. + +Parameters: + ReportType One of HidP_Input, HidP_Output or HidP_Feature. + + UsagePage All of the usages in the usage array, which HidP_SetUsages will + set in the report, refer to this same usage page. + If a client wishes to set usages in a report for multiple + usage pages then that client needs to make multiple calls to + HidP_SetUsages for each of the usage pages. + + UsageList A usage array containing the usages that HidP_SetUsages will set in + the report packet. + + UsageLength The length of the given usage array in array elements. + The parser will set this value to the position in the usage + array where it stopped processing. If successful, UsageLength + will be unchanged. In any error condition, this parameter + reflects how many of the usages in the usage list have + actually been set by the parser. This is useful for finding + the usage in the list which caused the error. + + PreparsedData The preparsed data recevied from HIDCLASS + + Report The report packet. + + ReportLength Length of the given report packet...Must be equal to the + value reported in the HIDP_CAPS structure for the device + and corresponding report type. + +Return Value + HidP_SetUsages returns the following error codes. On error, the report packet + will be correct up until the usage element that caused the error. + + HIDP_STATUS_SUCCESS -- upon successful insertion of all usages + into the report packet. + HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid. + HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid + HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not + equal to the length specified in + the HIDP_CAPS structure for the given + ReportType + HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device + for the given ReportType + HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- if a usage was found that exists in a + different report. If the report is + zero-initialized on entry the first + usage in the list will determine which + report ID is used. Otherwise, the + parser will verify that usage matches + the passed in report's ID + HIDP_STATUS_USAGE_NOT_FOUND -- if the usage does not exist for any + report (no matter what the report ID) + for the given report type. + HIDP_STATUS_BUFFER_TOO_SMALL -- if there are not enough entries in a + given Main Array Item to list all of + the given usages. The caller needs + to split his request into more than + one call +--*/ + +#define HidP_UnsetButtons(Rty, Up, Lco, ULi, ULe, Ppd, Rep, Rle) \ + HidP_UnsetUsages(Rty, Up, Lco, ULi, ULe, Ppd, Rep, Rle) + +__checkReturn +NTSTATUS __stdcall +HidP_UnsetUsages ( + __in HIDP_REPORT_TYPE ReportType, + __in USAGE UsagePage, + __in_opt USHORT LinkCollection, + __inout_ecount_part(*UsageLength,*UsageLength) PUSAGE UsageList, + __inout PULONG UsageLength, + __in PHIDP_PREPARSED_DATA PreparsedData, + __in_bcount(ReportLength) PCHAR Report, + __in ULONG ReportLength + ); +/*++ + +Routine Description: + This function unsets (turns off) binary values (buttons) in the report. Given + an initialized packet of correct length, it modifies the report packet so + that each element in the given list of usages has been unset in the + report packet. + + This function is the "undo" operation for SetUsages. If the given usage + is not already set in the Report, it will return an error code of + HIDP_STATUS_BUTTON_NOT_PRESSED. If the button is pressed, HidP_UnsetUsages + will unset the appropriate bit or remove the corresponding index value from + the HID Main Array Item. + + A properly initialized Report packet is one of the correct byte length, + and all zeros.. + + NOTE: A packet that has already been set with a call to a HidP_Set routine + can also be passed in. This routine then processes the UsageList + in the same fashion but verifies that the ReportID already set in + Report matches the report ID for the given usages. + +Parameters: + ReportType One of HidP_Input, HidP_Output or HidP_Feature. + + UsagePage All of the usages in the usage array, which HidP_UnsetUsages will + unset in the report, refer to this same usage page. + If a client wishes to unset usages in a report for multiple + usage pages then that client needs to make multiple calls to + HidP_UnsetUsages for each of the usage pages. + + UsageList A usage array containing the usages that HidP_UnsetUsages will + unset in the report packet. + + UsageLength The length of the given usage array in array elements. + The parser will set this value to the position in the usage + array where it stopped processing. If successful, UsageLength + will be unchanged. In any error condition, this parameter + reflects how many of the usages in the usage list have + actually been unset by the parser. This is useful for finding + the usage in the list which caused the error. + + PreparsedData The preparsed data recevied from HIDCLASS + + Report The report packet. + + ReportLength Length of the given report packet...Must be equal to the + value reported in the HIDP_CAPS structure for the device + and corresponding report type. + +Return Value + HidP_UnsetUsages returns the following error codes. On error, the report + packet will be correct up until the usage element that caused the error. + + HIDP_STATUS_SUCCESS -- upon successful "unsetting" of all usages + in the report packet. + HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid. + HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid + HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not + equal to the length specified in + the HIDP_CAPS structure for the given + ReportType + HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device + for the given ReportType + HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- if a usage was found that exists in a + different report. If the report is + zero-initialized on entry the first + usage in the list will determine which + report ID is used. Otherwise, the + parser will verify that usage matches + the passed in report's ID + HIDP_STATUS_USAGE_NOT_FOUND -- if the usage does not exist for any + report (no matter what the report ID) + for the given report type. + HIDP_STATUS_BUTTON_NOT_PRESSED -- if a usage corresponds to a button that + is not already set in the given report +--*/ + +#define HidP_GetButtons(Rty, UPa, LCo, ULi, ULe, Ppd, Rep, RLe) \ + HidP_GetUsages(Rty, UPa, LCo, ULi, ULe, Ppd, Rep, RLe) + +__checkReturn +NTSTATUS __stdcall +HidP_GetUsages ( + __in HIDP_REPORT_TYPE ReportType, + __in USAGE UsagePage, + __in USHORT LinkCollection, + __out_ecount(UsageLength) PUSAGE UsageList, + __inout PULONG UsageLength, + __in PHIDP_PREPARSED_DATA PreparsedData, + __out_bcount(ReportLength) PCHAR Report, + __in ULONG ReportLength + ); +/*++ + +Routine Description: + This function returns the binary values (buttons) that are set in a HID + report. Given a report packet of correct length, it searches the report + packet for each usage for the given usage page and returns them in the + usage list. + +Parameters: + ReportType One of HidP_Input, HidP_Output or HidP_Feature. + + UsagePage All of the usages in the usage list, which HidP_GetUsages will + retrieve in the report, refer to this same usage page. + If the client wishes to get usages in a packet for multiple + usage pages then that client needs to make multiple calls + to HidP_GetUsages. + + LinkCollection An optional value which can limit which usages are returned + in the UsageList to those usages that exist in a specific + LinkCollection. A non-zero value indicates the index into + the HIDP_LINK_COLLECITON_NODE list returned by + HidP_GetLinkCollectionNodes of the link collection the + usage should belong to. A value of 0 indicates this + should value be ignored. + + UsageList The usage array that will contain all the usages found in + the report packet. + + UsageLength The length of the given usage array in array elements. + On input, this value describes the length of the usage list. + On output, HidP_GetUsages sets this value to the number of + usages that was found. Use HidP_MaxUsageListLength to + determine the maximum length needed to return all the usages + that a given report packet may contain. + + PreparsedData Preparsed data structure returned by HIDCLASS + + Report The report packet. + + ReportLength Length (in bytes) of the given report packet + + +Return Value + HidP_GetUsages returns the following error codes: + + HIDP_STATUS_SUCCESS -- upon successfully retrieving all the + usages from the report packet + HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid. + HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid + HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not + equal to the length specified in + the HIDP_CAPS structure for the given + ReportType + HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device + for the given ReportType + HIDP_STATUS_BUFFER_TOO_SMALL -- if the UsageList is not big enough to + hold all the usages found in the report + packet. If this is returned, the buffer + will contain UsageLength number of + usages. Use HidP_MaxUsageListLength to + find the maximum length needed + HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- if no usages were found but usages + that match the UsagePage and + LinkCollection specified could be found + in a report with a different report ID + HIDP_STATUS_USAGE_NOT_FOUND -- if there are no usages in a reports for + the device and ReportType that match the + UsagePage and LinkCollection that were + specified +--*/ + +#define HidP_GetButtonsEx(Rty, LCo, BLi, ULe, Ppd, Rep, RLe) \ + HidP_GetUsagesEx(Rty, LCo, BLi, ULe, Ppd, Rep, RLe) + +__checkReturn +__drv_maxIRQL(DISPATCH_LEVEL) +NTSTATUS __stdcall +HidP_GetUsagesEx ( + __in HIDP_REPORT_TYPE ReportType, + __in USHORT LinkCollection, // Optional + __inout_ecount_part(*UsageLength,*UsageLength) PUSAGE_AND_PAGE ButtonList, + __inout ULONG * UsageLength, + __in PHIDP_PREPARSED_DATA PreparsedData, + __in_bcount(ReportLength) PCHAR Report, + __in ULONG ReportLength + ); + +/*++ + +Routine Description: + This function returns the binary values (buttons) in a HID report. + Given a report packet of correct length, it searches the report packet + for all buttons and returns the UsagePage and Usage for each of the buttons + it finds. + +Parameters: + ReportType One of HidP_Input, HidP_Output or HidP_Feature. + + LinkCollection An optional value which can limit which usages are returned + in the ButtonList to those usages that exist in a specific + LinkCollection. A non-zero value indicates the index into + the HIDP_LINK_COLLECITON_NODE list returned by + HidP_GetLinkCollectionNodes of the link collection the + usage should belong to. A value of 0 indicates this + should value be ignored. + + ButtonList An array of USAGE_AND_PAGE structures describing all the + buttons currently ``down'' in the device. + + UsageLength The length of the given array in terms of elements. + On input, this value describes the length of the list. On + output, HidP_GetUsagesEx sets this value to the number of + usages that were found. Use HidP_MaxUsageListLength to + determine the maximum length needed to return all the usages + that a given report packet may contain. + + PreparsedData Preparsed data returned by HIDCLASS + + Report The report packet. + + ReportLength Length (in bytes) of the given report packet. + + +Return Value + HidP_GetUsagesEx returns the following error codes: + + HIDP_STATUS_SUCCESS -- upon successfully retrieving all the + usages from the report packet + HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid. + HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid + HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not + equal to the length specified in + the HIDP_CAPS structure for the given + ReportType + HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device + for the given ReportType + HIDP_STATUS_BUFFER_TOO_SMALL -- if ButtonList is not big enough to + hold all the usages found in the report + packet. If this is returned, the buffer + will contain UsageLength number of + usages. Use HidP_MaxUsageListLength to + find the maximum length needed + HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- if no usages were found but usages + that match the specified LinkCollection + exist in report with a different report + ID. + HIDP_STATUS_USAGE_NOT_FOUND -- if there are no usages in any reports that + match the LinkCollection parameter +--*/ + +__drv_maxIRQL(PASSIVE_LEVEL) +ULONG __stdcall +HidP_MaxUsageListLength ( + __in HIDP_REPORT_TYPE ReportType, + __in USAGE UsagePage, // Optional + __in PHIDP_PREPARSED_DATA PreparsedData + ); +/*++ +Routine Description: + This function returns the maximum number of usages that a call to + HidP_GetUsages or HidP_GetUsagesEx could return for a given HID report. + If calling for number of usages returned by HidP_GetUsagesEx, use 0 as + the UsagePage value. + +Parameters: + ReportType One of HidP_Input, HidP_Output or HidP_Feature. + + UsagePage Specifies the optional UsagePage to query for. If 0, will + return all the maximum number of usage values that could be + returned for a given ReportType. If non-zero, will return + the maximum number of usages that would be returned for the + ReportType with the given UsagePage. + + PreparsedData Preparsed data returned from HIDCLASS + +Return Value: + The length of the usage list array required for the HidP_GetUsages or + HidP_GetUsagesEx function call. If an error occurs (such as + HIDP_STATUS_INVALID_REPORT_TYPE or HIDP_INVALID_PREPARSED_DATA, this + returns 0. +--*/ + +__checkReturn +NTSTATUS __stdcall +HidP_SetUsageValue ( + __in HIDP_REPORT_TYPE ReportType, + __in USAGE UsagePage, + __in USHORT LinkCollection, + __in USAGE Usage, + __in ULONG UsageValue, + __in PHIDP_PREPARSED_DATA PreparsedData, + __inout_bcount(ReportLength) PCHAR Report, + __in ULONG ReportLength + ); +/*++ +Description: + HidP_SetUsageValue inserts a value into the HID Report Packet in the field + corresponding to the given usage page and usage. HidP_SetUsageValue + casts this value to the appropriate bit length. If a report packet + contains two different fields with the same Usage and UsagePage, + they can be distinguished with the optional LinkCollection field value. + Using this function sets the raw value into the report packet with + no checking done as to whether it actually falls within the logical + minimum/logical maximum range. Use HidP_SetScaledUsageValue for this... + + NOTE: Although the UsageValue parameter is a ULONG, any casting that is + done will preserve or sign-extend the value. The value being set + should be considered a LONG value and will be treated as such by + this function. + +Parameters: + + ReportType One of HidP_Output or HidP_Feature. + + UsagePage The usage page to which the given usage refers. + + LinkCollection (Optional) This value can be used to differentiate + between two fields that may have the same + UsagePage and Usage but exist in different + collections. If the link collection value + is zero, this function will set the first field + it finds that matches the usage page and + usage. + + Usage The usage whose value HidP_SetUsageValue will set. + + UsageValue The raw value to set in the report buffer. This value must be within + the logical range or if a NULL value this value should be the + most negative value that can be represented by the number of bits + for this field. + + PreparsedData The preparsed data returned for HIDCLASS + + Report The report packet. + + ReportLength Length (in bytes) of the given report packet. + + +Return Value: + HidP_SetUsageValue returns the following error codes: + + HIDP_STATUS_SUCCESS -- upon successfully setting the value + in the report packet + HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid. + HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid + HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not + equal to the length specified in + the HIDP_CAPS structure for the given + ReportType + HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device + for the given ReportType + HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- the specified usage page, usage and + link collection exist but exists in + a report with a different report ID + than the report being passed in. To + set this value, call HidP_SetUsageValue + again with a zero-initizialed report + packet + HIDP_STATUS_USAGE_NOT_FOUND -- if the usage page, usage, and link + collection combination does not exist + in any reports for this ReportType +--*/ +__checkReturn +NTSTATUS __stdcall +HidP_SetScaledUsageValue ( + __in HIDP_REPORT_TYPE ReportType, + __in USAGE UsagePage, + __in USHORT LinkCollection, + __in USAGE Usage, + __in LONG UsageValue, + __in PHIDP_PREPARSED_DATA PreparsedData, + __inout_bcount(ReportLength) PCHAR Report, + __in ULONG ReportLength + ); + +/*++ +Description: + HidP_SetScaledUsageValue inserts the UsageValue into the HID report packet + in the field corresponding to the given usage page and usage. If a report + packet contains two different fields with the same Usage and UsagePage, + they can be distinguished with the optional LinkCollection field value. + + If the specified field has a defined physical range, this function converts + the physical value specified to the corresponding logical value for the + report. If a physical value does not exist, the function will verify that + the value specified falls within the logical range and set according. + + If the range checking fails but the field has NULL values, the function will + set the field to the defined NULL value (most negative number possible) and + return HIDP_STATUS_NULL. In other words, use this function to set NULL + values for a given field by passing in a value that falls outside the + physical range if it is defined or the logical range otherwise. + + If the field does not support NULL values, an out of range error will be + returned instead. + +Parameters: + + ReportType One of HidP_Output or HidP_Feature. + + UsagePage The usage page to which the given usage refers. + + LinkCollection (Optional) This value can be used to differentiate + between two fields that may have the same + UsagePage and Usage but exist in different + collections. If the link collection value + is zero, this function will set the first field + it finds that matches the usage page and + usage. + + Usage The usage whose value HidP_SetScaledUsageValue will set. + + UsageValue The value to set in the report buffer. See the routine + description above for the different interpretations of this + value + + PreparsedData The preparsed data returned from HIDCLASS + + Report The report packet. + + ReportLength Length (in bytes) of the given report packet. + + +Return Value: + HidP_SetScaledUsageValue returns the following error codes: + + HIDP_STATUS_SUCCESS -- upon successfully setting the value + in the report packet + HIDP_STATUS_NULL -- upon successfully setting the value + in the report packet as a NULL value + HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid. + HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid + HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not + equal to the length specified in + the HIDP_CAPS structure for the given + ReportType + HIDP_STATUS_VALUE_OUT_OF_RANGE -- if the value specified failed to fall + within the physical range if it exists + or within the logical range otherwise + and the field specified by the usage + does not allow NULL values + HIDP_STATUS_BAD_LOG_PHY_VALUES -- if the field has a physical range but + either the logical range is invalid + (max <= min) or the physical range is + invalid + HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- the specified usage page, usage and + link collection exist but exists in + a report with a different report ID + than the report being passed in. To + set this value, call + HidP_SetScaledUsageValue again with + a zero-initialized report packet + HIDP_STATUS_USAGE_NOT_FOUND -- if the usage page, usage, and link + collection combination does not exist + in any reports for this ReportType +--*/ +__checkReturn +NTSTATUS __stdcall +HidP_SetUsageValueArray ( + __in HIDP_REPORT_TYPE ReportType, + __in USAGE UsagePage, + __in USHORT LinkCollection, + __in USAGE Usage, + __in_bcount(UsageValueByteLength) PCHAR UsageValue, + __in USHORT UsageValueByteLength, + __in PHIDP_PREPARSED_DATA PreparsedData, + __inout_bcount(ReportLength) PCHAR Report, + __in ULONG ReportLength + ); + +/*++ +Routine Descripton: + A usage value array occurs when the last usage in the list of usages + describing a main item must be repeated because there are less usages defined + than there are report counts declared for the given main item. In this case + a single value cap is allocated for that usage and the report count of that + value cap is set to reflect the number of fields to which that usage refers. + + HidP_SetUsageValueArray sets the raw bits for that usage which spans + more than one field in a report. + + NOTE: This function currently does not support value arrays where the + ReportSize for each of the fields in the array is not a multiple + of 8 bits. + + The UsageValue buffer should have the values set as they would appear + in the report buffer. If this function supported non 8-bit multiples + for the ReportSize then caller should format the input buffer so that + each new value begins at the bit immediately following the last bit + of the previous value + +Parameters: + + ReportType One of HidP_Output or HidP_Feature. + + UsagePage The usage page to which the given usage refers. + + LinkCollection (Optional) This value can be used to differentiate + between two fields that may have the same + UsagePage and Usage but exist in different + collections. If the link collection value + is zero, this function will set the first field + it finds that matches the usage page and + usage. + + Usage The usage whose value array HidP_SetUsageValueArray will set. + + UsageValue The buffer with the values to set into the value array. + The number of BITS required is found by multiplying the + BitSize and ReportCount fields of the Value Cap for this + control. The least significant bit of this control found in the + given report will be placed in the least significan bit location + of the array given (little-endian format), regardless of whether + or not the field is byte alligned or if the BitSize is a multiple + of sizeof (CHAR). + + See the above note for current implementation limitations. + + UsageValueByteLength Length of the UsageValue buffer (in bytes) + + PreparsedData The preparsed data returned from HIDCLASS + + Report The report packet. + + ReportLength Length (in bytes) of the given report packet. + + +Return Value: + HIDP_STATUS_SUCCESS -- upon successfully setting the value + array in the report packet + HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid. + HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid + HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not + equal to the length specified in + the HIDP_CAPS structure for the given + ReportType + HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device + for the given ReportType + HIDP_STATUS_NOT_VALUE_ARRAY -- if the control specified is not a + value array -- a value array will have + a ReportCount field in the + HIDP_VALUE_CAPS structure that is > 1 + Use HidP_SetUsageValue instead + HIDP_STATUS_BUFFER_TOO_SMALL -- if the size of the passed in buffer with + the values to set is too small (ie. has + fewer values than the number of fields in + the array + HIDP_STATUS_NOT_IMPLEMENTED -- if the usage value array has field sizes + that are not multiples of 8 bits, this + error code is returned since the function + currently does not handle setting into + such arrays. + HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- the specified usage page, usage and + link collection exist but exists in + a report with a different report ID + than the report being passed in. To + set this value, call + HidP_SetUsageValueArray again with + a zero-initialized report packet + HIDP_STATUS_USAGE_NOT_FOUND -- if the usage page, usage, and link + collection combination does not exist + in any reports for this ReportType +--*/ + +__checkReturn +NTSTATUS __stdcall +HidP_GetUsageValue ( + __in HIDP_REPORT_TYPE ReportType, + __in USAGE UsagePage, + __in USHORT LinkCollection, + __in USAGE Usage, + __out PULONG UsageValue, + __in PHIDP_PREPARSED_DATA PreparsedData, + __in_bcount(ReportLength) PCHAR Report, + __in ULONG ReportLength + ); + +/* +Description + HidP_GetUsageValue retrieves the value from the HID Report for the usage + specified by the combination of usage page, usage and link collection. + If a report packet contains two different fields with the same + Usage and UsagePage, they can be distinguished with the optional + LinkCollection field value. + +Parameters: + + ReportType One of HidP_Input or HidP_Feature. + + UsagePage The usage page to which the given usage refers. + + LinkCollection (Optional) This value can be used to differentiate + between two fields that may have the same + UsagePage and Usage but exist in different + collections. If the link collection value + is zero, this function will set the first field + it finds that matches the usage page and + usage. + + Usage The usage whose value HidP_GetUsageValue will retrieve + + UsageValue The raw value that is set for the specified field in the report + buffer. This value will either fall within the logical range + or if NULL values are allowed, a number outside the range to + indicate a NULL + + PreparsedData The preparsed data returned for HIDCLASS + + Report The report packet. + + ReportLength Length (in bytes) of the given report packet. + + +Return Value: + HidP_GetUsageValue returns the following error codes: + + HIDP_STATUS_SUCCESS -- upon successfully retrieving the value + from the report packet + HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid. + HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid + HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not + equal to the length specified in + the HIDP_CAPS structure for the given + ReportType + HIDP_STATUS_REPORT_DOES_NOT_EXIST -- if there are no reports on this device + for the given ReportType + HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- the specified usage page, usage and + link collection exist but exists in + a report with a different report ID + than the report being passed in. To + set this value, call HidP_GetUsageValue + again with a different report packet + HIDP_STATUS_USAGE_NOT_FOUND -- if the usage page, usage, and link + collection combination does not exist + in any reports for this ReportType +--*/ + +__checkReturn +NTSTATUS __stdcall +HidP_GetScaledUsageValue ( + __in HIDP_REPORT_TYPE ReportType, + __in USAGE UsagePage, + __in USHORT LinkCollection, + __in USAGE Usage, + __out PLONG UsageValue, + __in PHIDP_PREPARSED_DATA PreparsedData, + __in_bcount(ReportLength) PCHAR Report, + __in ULONG ReportLength + ); + +/*++ +Description + HidP_GetScaledUsageValue retrieves a UsageValue from the HID report packet + in the field corresponding to the given usage page and usage. If a report + packet contains two different fields with the same Usage and UsagePage, + they can be distinguished with the optional LinkCollection field value. + + If the specified field has a defined physical range, this function converts + the logical value that exists in the report packet to the corresponding + physical value. If a physical range does not exist, the function will + return the logical value. This function will check to verify that the + logical value in the report falls within the declared logical range. + + When doing the conversion between logical and physical values, this + function assumes a linear extrapolation between the physical max/min and + the logical max/min. (Where logical is the values reported by the device + and physical is the value returned by this function). If the data field + size is less than 32 bits, then HidP_GetScaledUsageValue will sign extend + the value to 32 bits. + + If the range checking fails but the field has NULL values, the function + will set UsageValue to 0 and return HIDP_STATUS_NULL. Otherwise, it + returns a HIDP_STATUS_OUT_OF_RANGE error. + +Parameters: + + ReportType One of HidP_Output or HidP_Feature. + + UsagePage The usage page to which the given usage refers. + + LinkCollection (Optional) This value can be used to differentiate + between two fields that may have the same + UsagePage and Usage but exist in different + collections. If the link collection value + is zero, this function will retrieve the first + field it finds that matches the usage page + and usage. + + Usage The usage whose value HidP_GetScaledUsageValue will retrieve + + UsageValue The value retrieved from the report buffer. See the routine + description above for the different interpretations of this + value + + PreparsedData The preparsed data returned from HIDCLASS + + Report The report packet. + + ReportLength Length (in bytes) of the given report packet. + + +Return Value: + HidP_GetScaledUsageValue returns the following error codes: + + HIDP_STATUS_SUCCESS -- upon successfully retrieving the value + from the report packet + HIDP_STATUS_NULL -- if the report packet had a NULL value + set + HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid. + HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid + HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not + equal to the length specified in + the HIDP_CAPS structure for the given + ReportType + HIDP_STATUS_VALUE_OUT_OF_RANGE -- if the value retrieved from the packet + falls outside the logical range and + the field does not support NULL values + HIDP_STATUS_BAD_LOG_PHY_VALUES -- if the field has a physical range but + either the logical range is invalid + (max <= min) or the physical range is + invalid + HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- the specified usage page, usage and + link collection exist but exists in + a report with a different report ID + than the report being passed in. To + set this value, call + HidP_GetScaledUsageValue with a + different report packet + HIDP_STATUS_USAGE_NOT_FOUND -- if the usage page, usage, and link + collection combination does not exist + in any reports for this ReportType +--*/ +__checkReturn +NTSTATUS __stdcall +HidP_GetUsageValueArray ( + __in HIDP_REPORT_TYPE ReportType, + __in USAGE UsagePage, + __in USHORT LinkCollection, + __in USAGE Usage, + __inout_bcount(UsageValueByteLength) PCHAR UsageValue, + __in USHORT UsageValueByteLength, + __in PHIDP_PREPARSED_DATA PreparsedData, + __in_bcount(ReportLength) PCHAR Report, + __in ULONG ReportLength + ); + +/*++ +Routine Descripton: + A usage value array occurs when the last usage in the list of usages + describing a main item must be repeated because there are less usages defined + than there are report counts declared for the given main item. In this case + a single value cap is allocated for that usage and the report count of that + value cap is set to reflect the number of fields to which that usage refers. + + HidP_GetUsageValueArray returns the raw bits for that usage which spans + more than one field in a report. + + NOTE: This function currently does not support value arrays where the + ReportSize for each of the fields in the array is not a multiple + of 8 bits. + + The UsageValue buffer will have the raw values as they are set + in the report packet. + +Parameters: + + ReportType One of HidP_Input, HidP_Output or HidP_Feature. + + UsagePage The usage page to which the given usage refers. + + LinkCollection (Optional) This value can be used to differentiate + between two fields that may have the same + UsagePage and Usage but exist in different + collections. If the link collection value + is zero, this function will set the first field + it finds that matches the usage page and + usage. + + Usage The usage whose value HidP_GetUsageValueArray will retreive. + + UsageValue A pointer to an array of characters where the value will be + placed. The number of BITS required is found by multiplying the + BitSize and ReportCount fields of the Value Cap for this + control. The least significant bit of this control found in the + given report will be placed in the least significant bit location + of the buffer (little-endian format), regardless of whether + or not the field is byte aligned or if the BitSize is a multiple + of sizeof (CHAR). + + See note above about current implementation limitations + + UsageValueByteLength + the length of the given UsageValue buffer. + + PreparsedData The preparsed data returned by the HIDCLASS + + Report The report packet. + + ReportLength Length of the given report packet. + +Return Value: + + HIDP_STATUS_SUCCESS -- upon successfully retrieving the value + from the report packet + HIDP_STATUS_INVALID_REPORT_TYPE -- if ReportType is not valid. + HIDP_STATUS_INVALID_PREPARSED_DATA -- if PreparsedData is not valid + HIDP_STATUS_INVALID_REPORT_LENGTH -- the length of the report packet is not + equal to the length specified in + the HIDP_CAPS structure for the given + ReportType + HIDP_STATUS_NOT_VALUE_ARRAY -- if the control specified is not a + value array -- a value array will have + a ReportCount field in the + HIDP_VALUE_CAPS structure that is > 1 + Use HidP_GetUsageValue instead + HIDP_STATUS_BUFFER_TOO_SMALL -- if the size of the passed in buffer in + which to return the array is too small + (ie. has fewer values than the number of + fields in the array + HIDP_STATUS_NOT_IMPLEMENTED -- if the usage value array has field sizes + that are not multiples of 8 bits, this + error code is returned since the function + currently does not handle getting values + from such arrays. + HIDP_STATUS_INCOMPATIBLE_REPORT_ID -- the specified usage page, usage and + link collection exist but exists in + a report with a different report ID + than the report being passed in. To + set this value, call + HidP_GetUsageValueArray with a + different report packet + HIDP_STATUS_USAGE_NOT_FOUND -- if the usage page, usage, and link + collection combination does not exist + in any reports for this ReportType +--*/ + +__checkReturn +__drv_maxIRQL(PASSIVE_LEVEL) +NTSTATUS __stdcall +HidP_UsageListDifference ( + __in_ecount(UsageListLength) PUSAGE PreviousUsageList, + __in_ecount(UsageListLength) PUSAGE CurrentUsageList, + __out_ecount(UsageListLength) PUSAGE BreakUsageList, + __out_ecount(UsageListLength) PUSAGE MakeUsageList, + __in ULONG UsageListLength + ); +/*++ +Routine Description: + This function will return the difference between a two lists of usages + (as might be returned from HidP_GetUsages), In other words, it will return + return a list of usages that are in the current list but not the previous + list as well as a list of usages that are in the previous list but not + the current list. + +Parameters: + + PreviousUsageList The list of usages before. + CurrentUsageList The list of usages now. + BreakUsageList Previous - Current. + MakeUsageList Current - Previous. + UsageListLength Represents the length of the usage lists in array + elements. If comparing two lists with a differing + number of array elements, this value should be + the size of the larger of the two lists. Any + zero found with a list indicates an early termination + of the list and any usages found after the first zero + will be ignored. +--*/ + +__checkReturn +__drv_maxIRQL(PASSIVE_LEVEL) +NTSTATUS __stdcall +HidP_UsageAndPageListDifference ( + __in_ecount(UsageListLength) PUSAGE_AND_PAGE PreviousUsageList, + __in_ecount(UsageListLength) PUSAGE_AND_PAGE CurrentUsageList, + __out_ecount(UsageListLength) PUSAGE_AND_PAGE BreakUsageList, + __out_ecount(UsageListLength) PUSAGE_AND_PAGE MakeUsageList, + __in ULONG UsageListLength + ); + +// +// Produce Make or Break Codes +// +typedef enum _HIDP_KEYBOARD_DIRECTION { + HidP_Keyboard_Break, + HidP_Keyboard_Make +} HIDP_KEYBOARD_DIRECTION; + +// +// A bitmap of the current shift state of the keyboard when using the +// below keyboard usages to i8042 translation function. +// +typedef struct _HIDP_KEYBOARD_MODIFIER_STATE { + union { + struct { + ULONG LeftControl: 1; + ULONG LeftShift: 1; + ULONG LeftAlt: 1; + ULONG LeftGUI: 1; + ULONG RightControl: 1; + ULONG RightShift: 1; + ULONG RightAlt: 1; + ULONG RigthGUI: 1; + ULONG CapsLock: 1; + ULONG ScollLock: 1; + ULONG NumLock: 1; + ULONG Reserved: 21; + }; + ULONG ul; + }; + +} HIDP_KEYBOARD_MODIFIER_STATE, * PHIDP_KEYBOARD_MODIFIER_STATE; + +// +// A call back function to give the i8042 scan codes to the caller of +// the below translation function. +// +typedef BOOLEAN (* PHIDP_INSERT_SCANCODES) ( + __in_opt PVOID Context, // Some caller supplied context. + __in_bcount(Length) PCHAR NewScanCodes, // A list of i8042 scan codes. + __in ULONG Length // the length of the scan codes. + ); + +__checkReturn +NTSTATUS __stdcall +HidP_TranslateUsageAndPagesToI8042ScanCodes ( + __in_ecount(UsageListLength) PUSAGE_AND_PAGE ChangedUsageList, + __in ULONG UsageListLength, + __in HIDP_KEYBOARD_DIRECTION KeyAction, + __inout PHIDP_KEYBOARD_MODIFIER_STATE ModifierState, + __in PHIDP_INSERT_SCANCODES InsertCodesProcedure, + __in_opt PVOID InsertCodesContext + ); +/*++ +Routine Description: +Parameters: +--*/ +__checkReturn +NTSTATUS __stdcall +HidP_TranslateUsagesToI8042ScanCodes ( + __in_ecount(UsageListLength) PUSAGE ChangedUsageList, + __in ULONG UsageListLength, + __in HIDP_KEYBOARD_DIRECTION KeyAction, + __inout PHIDP_KEYBOARD_MODIFIER_STATE ModifierState, + __in PHIDP_INSERT_SCANCODES InsertCodesProcedure, + __in_opt PVOID InsertCodesContext + ); +/*++ +Routine Description: +Parameters: +--*/ + + + +// +// Define NT Status codes with Facility Code of FACILITY_HID_ERROR_CODE +// + +// FACILITY_HID_ERROR_CODE defined in ntstatus.h +#ifndef FACILITY_HID_ERROR_CODE +#define FACILITY_HID_ERROR_CODE 0x11 +#endif + +#define HIDP_ERROR_CODES(SEV, CODE) \ + ((NTSTATUS) (((SEV) << 28) | (FACILITY_HID_ERROR_CODE << 16) | (CODE))) + +#define HIDP_STATUS_SUCCESS (HIDP_ERROR_CODES(0x0,0)) +#define HIDP_STATUS_NULL (HIDP_ERROR_CODES(0x8,1)) +#define HIDP_STATUS_INVALID_PREPARSED_DATA (HIDP_ERROR_CODES(0xC,1)) +#define HIDP_STATUS_INVALID_REPORT_TYPE (HIDP_ERROR_CODES(0xC,2)) +#define HIDP_STATUS_INVALID_REPORT_LENGTH (HIDP_ERROR_CODES(0xC,3)) +#define HIDP_STATUS_USAGE_NOT_FOUND (HIDP_ERROR_CODES(0xC,4)) +#define HIDP_STATUS_VALUE_OUT_OF_RANGE (HIDP_ERROR_CODES(0xC,5)) +#define HIDP_STATUS_BAD_LOG_PHY_VALUES (HIDP_ERROR_CODES(0xC,6)) +#define HIDP_STATUS_BUFFER_TOO_SMALL (HIDP_ERROR_CODES(0xC,7)) +#define HIDP_STATUS_INTERNAL_ERROR (HIDP_ERROR_CODES(0xC,8)) +#define HIDP_STATUS_I8042_TRANS_UNKNOWN (HIDP_ERROR_CODES(0xC,9)) +#define HIDP_STATUS_INCOMPATIBLE_REPORT_ID (HIDP_ERROR_CODES(0xC,0xA)) +#define HIDP_STATUS_NOT_VALUE_ARRAY (HIDP_ERROR_CODES(0xC,0xB)) +#define HIDP_STATUS_IS_VALUE_ARRAY (HIDP_ERROR_CODES(0xC,0xC)) +#define HIDP_STATUS_DATA_INDEX_NOT_FOUND (HIDP_ERROR_CODES(0xC,0xD)) +#define HIDP_STATUS_DATA_INDEX_OUT_OF_RANGE (HIDP_ERROR_CODES(0xC,0xE)) +#define HIDP_STATUS_BUTTON_NOT_PRESSED (HIDP_ERROR_CODES(0xC,0xF)) +#define HIDP_STATUS_REPORT_DOES_NOT_EXIST (HIDP_ERROR_CODES(0xC,0x10)) +#define HIDP_STATUS_NOT_IMPLEMENTED (HIDP_ERROR_CODES(0xC,0x20)) + +// +// We blundered this status code. +// +#define HIDP_STATUS_I8242_TRANS_UNKNOWN HIDP_STATUS_I8042_TRANS_UNKNOWN + +#include + +#if _MSC_VER >= 1200 +#pragma warning(pop) +#else +#pragma warning(default:4115) +#pragma warning(default:4201) +#pragma warning(default:4214) +#endif + +#endif + diff --git a/setupapi-x64/hidsdi.h b/setupapi-x64/hidsdi.h new file mode 100644 index 0000000..8f97d75 --- /dev/null +++ b/setupapi-x64/hidsdi.h @@ -0,0 +1,494 @@ +/*++ + +Copyright (c) Microsoft Corporation. All rights reserved. + +Module Name: + + HIDSDI.H + +Abstract: + + This module contains the PUBLIC definitions for the + code that implements the HID dll. + +Environment: + + Kernel & user mode + +--*/ + + +#ifndef _HIDSDI_H +#define _HIDSDI_H + +#include + +//#include "wtypes.h" + +//#include +//#include +//#include + +typedef LONG NTSTATUS; +#include "hidusage.h" +#include "hidpi.h" + +typedef struct _HIDD_CONFIGURATION { + PVOID cookie; + ULONG size; + ULONG RingBufferSize; +} HIDD_CONFIGURATION, *PHIDD_CONFIGURATION; + +typedef struct _HIDD_ATTRIBUTES { + ULONG Size; // = sizeof (struct _HIDD_ATTRIBUTES) + + // + // Vendor ids of this hid device + // + USHORT VendorID; + USHORT ProductID; + USHORT VersionNumber; + + // + // Additional fields will be added to the end of this structure. + // +} HIDD_ATTRIBUTES, *PHIDD_ATTRIBUTES; + +__checkReturn +BOOLEAN __stdcall +HidD_GetAttributes ( + __in HANDLE HidDeviceObject, + __out PHIDD_ATTRIBUTES Attributes + ); +/*++ +Routine Description: + Fill in the given HIDD_ATTRIBUTES structure with the attributes of the + given hid device. + +--*/ + + +void __stdcall +HidD_GetHidGuid ( + __out LPGUID HidGuid + ); + +__checkReturn +BOOLEAN __stdcall +HidD_GetPreparsedData ( + __in HANDLE HidDeviceObject, + __out __drv_when(return!=0, __drv_allocatesMem(Mem)) PHIDP_PREPARSED_DATA * PreparsedData + ); +/*++ +Routine Description: + Given a handle to a valid Hid Class Device Object, retrieve the preparsed + data for the device. This routine will allocate the appropriately + sized buffer to hold this preparsed data. It is up to client to call + HidP_FreePreparsedData to free the memory allocated to this structure when + it is no longer needed. + +Arguments: + HidDeviceObject A handle to a Hid Device that the client obtains using + a call to CreateFile on a valid Hid device string name. + The string name can be obtained using standard PnP calls. + + PreparsedData An opaque data structure used by other functions in this + library to retrieve information about a given device. + +Return Value: + TRUE if successful. + FALSE otherwise -- Use GetLastError() to get extended error information +--*/ +BOOLEAN __stdcall +HidD_FreePreparsedData ( + __in __drv_freesMem(Mem) PHIDP_PREPARSED_DATA PreparsedData + ); + +BOOLEAN __stdcall +HidD_FlushQueue ( + __in HANDLE HidDeviceObject + ); +/*++ +Routine Description: + Flush the input queue for the given HID device. + +Arguments: + HidDeviceObject A handle to a Hid Device that the client obtains using + a call to CreateFile on a valid Hid device string name. + The string name can be obtained using standard PnP calls. + +Return Value: + TRUE if successful + FALSE otherwise -- Use GetLastError() to get extended error information +--*/ +__checkReturn +BOOLEAN __stdcall +HidD_GetConfiguration ( + __in HANDLE HidDeviceObject, + __out_bcount(ConfigurationLength) PHIDD_CONFIGURATION Configuration, + __in ULONG ConfigurationLength + ); +/*++ +Routine Description: + Get the configuration information for this Hid device + +Arguments: + HidDeviceObject A handle to a Hid Device Object. + + Configuration A configuration structure. HidD_GetConfiguration MUST + be called before the configuration can be modified and + set using HidD_SetConfiguration + + ConfigurationLength That is ``sizeof (HIDD_CONFIGURATION)''. Using this + parameter, we can later increase the length of the + configuration array and not break older apps. + +Return Value: + TRUE if successful + FALSE otherwise -- Use GetLastError() to get extended error information +--*/ +__checkReturn +BOOLEAN __stdcall +HidD_SetConfiguration ( + __in HANDLE HidDeviceObject, + __in_bcount(ConfigurationLength) PHIDD_CONFIGURATION Configuration, + __in ULONG ConfigurationLength + ); +/*++ +Routine Description: + Set the configuration information for this Hid device... + + NOTE: HidD_GetConfiguration must be called to retrieve the current + configuration information before this information can be modified + and set. + +Arguments: + HidDeviceObject A handle to a Hid Device Object. + + Configuration A configuration structure. HidD_GetConfiguration MUST + be called before the configuration can be modified and + set using HidD_SetConfiguration + + ConfigurationLength That is ``sizeof (HIDD_CONFIGURATION)''. Using this + parameter, we can later increase the length of the + configuration array and not break older apps. + +Return Value: + TRUE if successful + FALSE otherwise -- Use GetLastError() to get extended error information +--*/ +__checkReturn +BOOLEAN __stdcall +HidD_GetFeature ( + __in HANDLE HidDeviceObject, + __out_bcount(ReportBufferLength) PVOID ReportBuffer, + __in ULONG ReportBufferLength + ); +/*++ +Routine Description: + Retrieve a feature report from a HID device. + +Arguments: + HidDeviceObject A handle to a Hid Device Object. + + ReportBuffer The buffer that the feature report should be placed + into. The first byte of the buffer should be set to + the report ID of the desired report + + ReportBufferLength The size (in bytes) of ReportBuffer. This value + should be greater than or equal to the + FeatureReportByteLength field as specified in the + HIDP_CAPS structure for the device +Return Value: + TRUE if successful + FALSE otherwise -- Use GetLastError() to get extended error information +--*/ +__checkReturn +BOOLEAN __stdcall +HidD_SetFeature ( + __in HANDLE HidDeviceObject, + __in_bcount(ReportBufferLength) PVOID ReportBuffer, + __in ULONG ReportBufferLength + ); +/*++ +Routine Description: + Send a feature report to a HID device. + +Arguments: + HidDeviceObject A handle to a Hid Device Object. + + ReportBuffer The buffer of the feature report to send to the device + + ReportBufferLength The size (in bytes) of ReportBuffer. This value + should be greater than or equal to the + FeatureReportByteLength field as specified in the + HIDP_CAPS structure for the device +Return Value: + TRUE if successful + FALSE otherwise -- Use GetLastError() to get extended error information +--*/ + +#if (NTDDI_VERSION >= NTDDI_WINXP) +__checkReturn +BOOLEAN __stdcall +HidD_GetInputReport ( + __in HANDLE HidDeviceObject, + __out_bcount(ReportBufferLength) PVOID ReportBuffer, + __in ULONG ReportBufferLength + ); +/*++ +Routine Description: + Retrieve an input report from a HID device. + +Arguments: + HidDeviceObject A handle to a Hid Device Object. + + ReportBuffer The buffer that the input report should be placed + into. The first byte of the buffer should be set to + the report ID of the desired report + + ReportBufferLength The size (in bytes) of ReportBuffer. This value + should be greater than or equal to the + InputReportByteLength field as specified in the + HIDP_CAPS structure for the device +Return Value: + TRUE if successful + FALSE otherwise -- Use GetLastError() to get extended error information +--*/ +__checkReturn +BOOLEAN __stdcall +HidD_SetOutputReport ( + __in HANDLE HidDeviceObject, + __in_bcount(ReportBufferLength) PVOID ReportBuffer, + __in ULONG ReportBufferLength + ); +/*++ +Routine Description: + Send an output report to a HID device. + +Arguments: + HidDeviceObject A handle to a Hid Device Object. + + ReportBuffer The buffer of the output report to send to the device + + ReportBufferLength The size (in bytes) of ReportBuffer. This value + should be greater than or equal to the + OutputReportByteLength field as specified in the + HIDP_CAPS structure for the device +Return Value: + TRUE if successful + FALSE otherwise -- Use GetLastError() to get extended error information +--*/ + +#endif +__checkReturn +BOOLEAN __stdcall +HidD_GetNumInputBuffers ( + __in HANDLE HidDeviceObject, + __out PULONG NumberBuffers + ); +/*++ +Routine Description: + This function returns the number of input buffers used by the specified + file handle to the Hid device. Each file object has a number of buffers + associated with it to queue reports read from the device but which have + not yet been read by the user-mode app with a handle to that device. + +Arguments: + HidDeviceObject A handle to a Hid Device Object. + + NumberBuffers Number of buffers currently being used for this file + handle to the Hid device + +Return Value: + TRUE if successful + FALSE otherwise -- Use GetLastError() to get extended error information +--*/ +__checkReturn +BOOLEAN __stdcall +HidD_SetNumInputBuffers ( + __in HANDLE HidDeviceObject, + __in ULONG NumberBuffers + ); +/*++ + +Routine Description: + This function sets the number of input buffers used by the specified + file handle to the Hid device. Each file object has a number of buffers + associated with it to queue reports read from the device but which have + not yet been read by the user-mode app with a handle to that device. + +Arguments: + HidDeviceObject A handle to a Hid Device Object. + + NumberBuffers New number of buffers to use for this file handle to + the Hid device + +Return Value: + TRUE if successful + FALSE otherwise -- Use GetLastError() to get extended error information +--*/ +__checkReturn +BOOLEAN __stdcall +HidD_GetPhysicalDescriptor ( + __in HANDLE HidDeviceObject, + __out_bcount(BufferLength) PVOID Buffer, + __in ULONG BufferLength + ); +/*++ +Routine Description: + This function retrieves the raw physical descriptor for the specified + Hid device. + +Arguments: + HidDeviceObject A handle to a Hid Device Object. + + Buffer Buffer which on return will contain the physical + descriptor if one exists for the specified device + handle + + BufferLength Length of buffer (in bytes) + + +Return Value: + TRUE if successful + FALSE otherwise -- Use GetLastError() to get extended error information +--*/ +__checkReturn +BOOLEAN __stdcall +HidD_GetManufacturerString ( + __in HANDLE HidDeviceObject, + __out_bcount(BufferLength) PVOID Buffer, + __in ULONG BufferLength + ); +/*++ +Routine Description: + This function retrieves the manufacturer string from the specified + Hid device. + +Arguments: + HidDeviceObject A handle to a Hid Device Object. + + Buffer Buffer which on return will contain the manufacturer + string returned from the device. This string is a + wide-character string + + BufferLength Length of Buffer (in bytes) + + +Return Value: + TRUE if successful + FALSE otherwise -- Use GetLastError() to get extended error information +--*/ +__checkReturn +BOOLEAN __stdcall +HidD_GetProductString ( + __in HANDLE HidDeviceObject, + __out_bcount(BufferLength) PVOID Buffer, + __in ULONG BufferLength + ); +/*++ +Routine Description: + This function retrieves the product string from the specified + Hid device. + +Arguments: + HidDeviceObject A handle to a Hid Device Object. + + Buffer Buffer which on return will contain the product + string returned from the device. This string is a + wide-character string + + BufferLength Length of Buffer (in bytes) + + +Return Value: + TRUE if successful + FALSE otherwise -- Use GetLastError() to get extended error information +--*/ +__checkReturn +BOOLEAN __stdcall +HidD_GetIndexedString ( + __in HANDLE HidDeviceObject, + __in ULONG StringIndex, + __out_bcount(BufferLength) PVOID Buffer, + __in ULONG BufferLength + ); +/*++ +Routine Description: + This function retrieves a string from the specified Hid device that is + specified with a certain string index. + +Arguments: + HidDeviceObject A handle to a Hid Device Object. + + StringIndex Index of the string to retrieve + + Buffer Buffer which on return will contain the product + string returned from the device. This string is a + wide-character string + + BufferLength Length of Buffer (in bytes) + +Return Value: + TRUE if successful + FALSE otherwise -- Use GetLastError() to get extended error information +--*/ +__checkReturn +BOOLEAN __stdcall +HidD_GetSerialNumberString ( + __in HANDLE HidDeviceObject, + __out_bcount(BufferLength) PVOID Buffer, + __in ULONG BufferLength + ); +/*++ +Routine Description: + This function retrieves the serial number string from the specified + Hid device. + +Arguments: + HidDeviceObject A handle to a Hid Device Object. + + Buffer Buffer which on return will contain the serial number + string returned from the device. This string is a + wide-character string + + BufferLength Length of Buffer (in bytes) + +Return Value: + TRUE if successful + FALSE otherwise -- Use GetLastError() to get extended error information +--*/ + +#if (NTDDI_VERSION >= NTDDI_WINXP) +__checkReturn +BOOLEAN __stdcall +HidD_GetMsGenreDescriptor ( + __in HANDLE HidDeviceObject, + __out_bcount(BufferLength) PVOID Buffer, + __in ULONG BufferLength + ); +/*++ +Routine Description: + This function retrieves the Microsoft Genre descriptor from the specified + Hid device. + +Arguments: + HidDeviceObject A handle to a Hid Device Object. + + Buffer Buffer which on return will contain the descriptor + returned from the device. + + BufferLength Length of Buffer (in bytes) + +Return Value: + TRUE if successful + FALSE otherwise -- Use GetLastError() to get extended error information +--*/ +#endif + + +#include + +#endif + diff --git a/setupapi-x64/hidusage.h b/setupapi-x64/hidusage.h new file mode 100644 index 0000000..331b109 --- /dev/null +++ b/setupapi-x64/hidusage.h @@ -0,0 +1,292 @@ +/*++ + +Copyright (c) Microsoft Corporation. All rights reserved. + +Module Name: + + HIDUSAGE.H + +Abstract: + + Public Definitions of HID USAGES. + +Environment: + + Kernel & user mode + +--*/ + +#ifndef __HIDUSAGE_H__ +#define __HIDUSAGE_H__ + +// +// Usage Pages +// + +typedef USHORT USAGE, *PUSAGE; + +#define HID_USAGE_PAGE_UNDEFINED ((USAGE) 0x00) +#define HID_USAGE_PAGE_GENERIC ((USAGE) 0x01) +#define HID_USAGE_PAGE_SIMULATION ((USAGE) 0x02) +#define HID_USAGE_PAGE_VR ((USAGE) 0x03) +#define HID_USAGE_PAGE_SPORT ((USAGE) 0x04) +#define HID_USAGE_PAGE_GAME ((USAGE) 0x05) +#define HID_USAGE_PAGE_KEYBOARD ((USAGE) 0x07) +#define HID_USAGE_PAGE_LED ((USAGE) 0x08) +#define HID_USAGE_PAGE_BUTTON ((USAGE) 0x09) +#define HID_USAGE_PAGE_ORDINAL ((USAGE) 0x0A) +#define HID_USAGE_PAGE_TELEPHONY ((USAGE) 0x0B) +#define HID_USAGE_PAGE_CONSUMER ((USAGE) 0x0C) +#define HID_USAGE_PAGE_DIGITIZER ((USAGE) 0x0D) +#define HID_USAGE_PAGE_UNICODE ((USAGE) 0x10) +#define HID_USAGE_PAGE_ALPHANUMERIC ((USAGE) 0x14) + +// +// Microsoft Vendor Specific Usage Pages +// +#define HID_USAGE_PAGE_MICROSOFT_BLUETOOTH_HANDSFREE ((USAGE) 0xFFF3) + +// +// Usages from Generic Desktop Page (0x01) +// + +#define HID_USAGE_GENERIC_POINTER ((USAGE) 0x01) +#define HID_USAGE_GENERIC_MOUSE ((USAGE) 0x02) +#define HID_USAGE_GENERIC_JOYSTICK ((USAGE) 0x04) +#define HID_USAGE_GENERIC_GAMEPAD ((USAGE) 0x05) +#define HID_USAGE_GENERIC_KEYBOARD ((USAGE) 0x06) +#define HID_USAGE_GENERIC_KEYPAD ((USAGE) 0x07) +#define HID_USAGE_GENERIC_SYSTEM_CTL ((USAGE) 0x80) + +#define HID_USAGE_GENERIC_X ((USAGE) 0x30) +#define HID_USAGE_GENERIC_Y ((USAGE) 0x31) +#define HID_USAGE_GENERIC_Z ((USAGE) 0x32) +#define HID_USAGE_GENERIC_RX ((USAGE) 0x33) +#define HID_USAGE_GENERIC_RY ((USAGE) 0x34) +#define HID_USAGE_GENERIC_RZ ((USAGE) 0x35) +#define HID_USAGE_GENERIC_SLIDER ((USAGE) 0x36) +#define HID_USAGE_GENERIC_DIAL ((USAGE) 0x37) +#define HID_USAGE_GENERIC_WHEEL ((USAGE) 0x38) +#define HID_USAGE_GENERIC_HATSWITCH ((USAGE) 0x39) +#define HID_USAGE_GENERIC_COUNTED_BUFFER ((USAGE) 0x3A) +#define HID_USAGE_GENERIC_BYTE_COUNT ((USAGE) 0x3B) +#define HID_USAGE_GENERIC_MOTION_WAKEUP ((USAGE) 0x3C) +#define HID_USAGE_GENERIC_VX ((USAGE) 0x40) +#define HID_USAGE_GENERIC_VY ((USAGE) 0x41) +#define HID_USAGE_GENERIC_VZ ((USAGE) 0x42) +#define HID_USAGE_GENERIC_VBRX ((USAGE) 0x43) +#define HID_USAGE_GENERIC_VBRY ((USAGE) 0x44) +#define HID_USAGE_GENERIC_VBRZ ((USAGE) 0x45) +#define HID_USAGE_GENERIC_VNO ((USAGE) 0x46) +#define HID_USAGE_GENERIC_SYSCTL_POWER ((USAGE) 0x81) +#define HID_USAGE_GENERIC_SYSCTL_SLEEP ((USAGE) 0x82) +#define HID_USAGE_GENERIC_SYSCTL_WAKE ((USAGE) 0x83) +#define HID_USAGE_GENERIC_SYSCTL_CONTEXT_MENU ((USAGE) 0x84) +#define HID_USAGE_GENERIC_SYSCTL_MAIN_MENU ((USAGE) 0x85) +#define HID_USAGE_GENERIC_SYSCTL_APP_MENU ((USAGE) 0x86) +#define HID_USAGE_GENERIC_SYSCTL_HELP_MENU ((USAGE) 0x87) +#define HID_USAGE_GENERIC_SYSCTL_MENU_EXIT ((USAGE) 0x88) +#define HID_USAGE_GENERIC_SYSCTL_MENU_SELECT ((USAGE) 0x89) +#define HID_USAGE_GENERIC_SYSCTL_MENU_RIGHT ((USAGE) 0x8A) +#define HID_USAGE_GENERIC_SYSCTL_MENU_LEFT ((USAGE) 0x8B) +#define HID_USAGE_GENERIC_SYSCTL_MENU_UP ((USAGE) 0x8C) +#define HID_USAGE_GENERIC_SYSCTL_MENU_DOWN ((USAGE) 0x8D) + +// +// Usages from Simulation Controls Page (0x02) +// + +#define HID_USAGE_SIMULATION_RUDDER ((USAGE) 0xBA) +#define HID_USAGE_SIMULATION_THROTTLE ((USAGE) 0xBB) + +// +// Virtual Reality Controls Page (0x03) +// + + +// +// Sport Controls Page (0x04) +// + + +// +// Game Controls Page (0x05) +// + + +// +// Keyboard/Keypad Page (0x07) +// + + // Error "keys" +#define HID_USAGE_KEYBOARD_NOEVENT ((USAGE) 0x00) +#define HID_USAGE_KEYBOARD_ROLLOVER ((USAGE) 0x01) +#define HID_USAGE_KEYBOARD_POSTFAIL ((USAGE) 0x02) +#define HID_USAGE_KEYBOARD_UNDEFINED ((USAGE) 0x03) + + // Letters +#define HID_USAGE_KEYBOARD_aA ((USAGE) 0x04) +#define HID_USAGE_KEYBOARD_zZ ((USAGE) 0x1D) + // Numbers +#define HID_USAGE_KEYBOARD_ONE ((USAGE) 0x1E) +#define HID_USAGE_KEYBOARD_ZERO ((USAGE) 0x27) + // Modifier Keys +#define HID_USAGE_KEYBOARD_LCTRL ((USAGE) 0xE0) +#define HID_USAGE_KEYBOARD_LSHFT ((USAGE) 0xE1) +#define HID_USAGE_KEYBOARD_LALT ((USAGE) 0xE2) +#define HID_USAGE_KEYBOARD_LGUI ((USAGE) 0xE3) +#define HID_USAGE_KEYBOARD_RCTRL ((USAGE) 0xE4) +#define HID_USAGE_KEYBOARD_RSHFT ((USAGE) 0xE5) +#define HID_USAGE_KEYBOARD_RALT ((USAGE) 0xE6) +#define HID_USAGE_KEYBOARD_RGUI ((USAGE) 0xE7) +#define HID_USAGE_KEYBOARD_SCROLL_LOCK ((USAGE) 0x47) +#define HID_USAGE_KEYBOARD_NUM_LOCK ((USAGE) 0x53) +#define HID_USAGE_KEYBOARD_CAPS_LOCK ((USAGE) 0x39) + // Funtion keys +#define HID_USAGE_KEYBOARD_F1 ((USAGE) 0x3A) +#define HID_USAGE_KEYBOARD_F12 ((USAGE) 0x45) + +#define HID_USAGE_KEYBOARD_RETURN ((USAGE) 0x28) +#define HID_USAGE_KEYBOARD_ESCAPE ((USAGE) 0x29) +#define HID_USAGE_KEYBOARD_DELETE ((USAGE) 0x2A) + +#define HID_USAGE_KEYBOARD_PRINT_SCREEN ((USAGE) 0x46) + +// and hundreds more... + +// +// LED Page (0x08) +// + +#define HID_USAGE_LED_NUM_LOCK ((USAGE) 0x01) +#define HID_USAGE_LED_CAPS_LOCK ((USAGE) 0x02) +#define HID_USAGE_LED_SCROLL_LOCK ((USAGE) 0x03) +#define HID_USAGE_LED_COMPOSE ((USAGE) 0x04) +#define HID_USAGE_LED_KANA ((USAGE) 0x05) +#define HID_USAGE_LED_POWER ((USAGE) 0x06) +#define HID_USAGE_LED_SHIFT ((USAGE) 0x07) +#define HID_USAGE_LED_DO_NOT_DISTURB ((USAGE) 0x08) +#define HID_USAGE_LED_MUTE ((USAGE) 0x09) +#define HID_USAGE_LED_TONE_ENABLE ((USAGE) 0x0A) +#define HID_USAGE_LED_HIGH_CUT_FILTER ((USAGE) 0x0B) +#define HID_USAGE_LED_LOW_CUT_FILTER ((USAGE) 0x0C) +#define HID_USAGE_LED_EQUALIZER_ENABLE ((USAGE) 0x0D) +#define HID_USAGE_LED_SOUND_FIELD_ON ((USAGE) 0x0E) +#define HID_USAGE_LED_SURROUND_FIELD_ON ((USAGE) 0x0F) +#define HID_USAGE_LED_REPEAT ((USAGE) 0x10) +#define HID_USAGE_LED_STEREO ((USAGE) 0x11) +#define HID_USAGE_LED_SAMPLING_RATE_DETECT ((USAGE) 0x12) +#define HID_USAGE_LED_SPINNING ((USAGE) 0x13) +#define HID_USAGE_LED_CAV ((USAGE) 0x14) +#define HID_USAGE_LED_CLV ((USAGE) 0x15) +#define HID_USAGE_LED_RECORDING_FORMAT_DET ((USAGE) 0x16) +#define HID_USAGE_LED_OFF_HOOK ((USAGE) 0x17) +#define HID_USAGE_LED_RING ((USAGE) 0x18) +#define HID_USAGE_LED_MESSAGE_WAITING ((USAGE) 0x19) +#define HID_USAGE_LED_DATA_MODE ((USAGE) 0x1A) +#define HID_USAGE_LED_BATTERY_OPERATION ((USAGE) 0x1B) +#define HID_USAGE_LED_BATTERY_OK ((USAGE) 0x1C) +#define HID_USAGE_LED_BATTERY_LOW ((USAGE) 0x1D) +#define HID_USAGE_LED_SPEAKER ((USAGE) 0x1E) +#define HID_USAGE_LED_HEAD_SET ((USAGE) 0x1F) +#define HID_USAGE_LED_HOLD ((USAGE) 0x20) +#define HID_USAGE_LED_MICROPHONE ((USAGE) 0x21) +#define HID_USAGE_LED_COVERAGE ((USAGE) 0x22) +#define HID_USAGE_LED_NIGHT_MODE ((USAGE) 0x23) +#define HID_USAGE_LED_SEND_CALLS ((USAGE) 0x24) +#define HID_USAGE_LED_CALL_PICKUP ((USAGE) 0x25) +#define HID_USAGE_LED_CONFERENCE ((USAGE) 0x26) +#define HID_USAGE_LED_STAND_BY ((USAGE) 0x27) +#define HID_USAGE_LED_CAMERA_ON ((USAGE) 0x28) +#define HID_USAGE_LED_CAMERA_OFF ((USAGE) 0x29) +#define HID_USAGE_LED_ON_LINE ((USAGE) 0x2A) +#define HID_USAGE_LED_OFF_LINE ((USAGE) 0x2B) +#define HID_USAGE_LED_BUSY ((USAGE) 0x2C) +#define HID_USAGE_LED_READY ((USAGE) 0x2D) +#define HID_USAGE_LED_PAPER_OUT ((USAGE) 0x2E) +#define HID_USAGE_LED_PAPER_JAM ((USAGE) 0x2F) +#define HID_USAGE_LED_REMOTE ((USAGE) 0x30) +#define HID_USAGE_LED_FORWARD ((USAGE) 0x31) +#define HID_USAGE_LED_REVERSE ((USAGE) 0x32) +#define HID_USAGE_LED_STOP ((USAGE) 0x33) +#define HID_USAGE_LED_REWIND ((USAGE) 0x34) +#define HID_USAGE_LED_FAST_FORWARD ((USAGE) 0x35) +#define HID_USAGE_LED_PLAY ((USAGE) 0x36) +#define HID_USAGE_LED_PAUSE ((USAGE) 0x37) +#define HID_USAGE_LED_RECORD ((USAGE) 0x38) +#define HID_USAGE_LED_ERROR ((USAGE) 0x39) +#define HID_USAGE_LED_SELECTED_INDICATOR ((USAGE) 0x3A) +#define HID_USAGE_LED_IN_USE_INDICATOR ((USAGE) 0x3B) +#define HID_USAGE_LED_MULTI_MODE_INDICATOR ((USAGE) 0x3C) +#define HID_USAGE_LED_INDICATOR_ON ((USAGE) 0x3D) +#define HID_USAGE_LED_INDICATOR_FLASH ((USAGE) 0x3E) +#define HID_USAGE_LED_INDICATOR_SLOW_BLINK ((USAGE) 0x3F) +#define HID_USAGE_LED_INDICATOR_FAST_BLINK ((USAGE) 0x40) +#define HID_USAGE_LED_INDICATOR_OFF ((USAGE) 0x41) +#define HID_USAGE_LED_FLASH_ON_TIME ((USAGE) 0x42) +#define HID_USAGE_LED_SLOW_BLINK_ON_TIME ((USAGE) 0x43) +#define HID_USAGE_LED_SLOW_BLINK_OFF_TIME ((USAGE) 0x44) +#define HID_USAGE_LED_FAST_BLINK_ON_TIME ((USAGE) 0x45) +#define HID_USAGE_LED_FAST_BLINK_OFF_TIME ((USAGE) 0x46) +#define HID_USAGE_LED_INDICATOR_COLOR ((USAGE) 0x47) +#define HID_USAGE_LED_RED ((USAGE) 0x48) +#define HID_USAGE_LED_GREEN ((USAGE) 0x49) +#define HID_USAGE_LED_AMBER ((USAGE) 0x4A) +#define HID_USAGE_LED_GENERIC_INDICATOR ((USAGE) 0x4B) + +// +// Button Page (0x09) +// +// There is no need to label these usages. +// + + +// +// Ordinal Page (0x0A) +// +// There is no need to label these usages. +// + + +// +// Telephony Device Page (0x0B) +// + +#define HID_USAGE_TELEPHONY_PHONE ((USAGE) 0x01) +#define HID_USAGE_TELEPHONY_ANSWERING_MACHINE ((USAGE) 0x02) +#define HID_USAGE_TELEPHONY_MESSAGE_CONTROLS ((USAGE) 0x03) +#define HID_USAGE_TELEPHONY_HANDSET ((USAGE) 0x04) +#define HID_USAGE_TELEPHONY_HEADSET ((USAGE) 0x05) +#define HID_USAGE_TELEPHONY_KEYPAD ((USAGE) 0x06) +#define HID_USAGE_TELEPHONY_PROGRAMMABLE_BUTTON ((USAGE) 0x07) +#define HID_USAGE_TELEPHONY_REDIAL ((USAGE) 0x24) +#define HID_USAGE_TELEPHONY_TRANSFER ((USAGE) 0x25) +#define HID_USAGE_TELEPHONY_DROP ((USAGE) 0x26) +#define HID_USAGE_TELEPHONY_LINE ((USAGE) 0x2A) +#define HID_USAGE_TELEPHONY_RING_ENABLE ((USAGE) 0x2D) +#define HID_USAGE_TELEPHONY_SEND ((USAGE) 0x31) +#define HID_USAGE_TELEPHONY_KEYPAD_0 ((USAGE) 0xB0) +#define HID_USAGE_TELEPHONY_KEYPAD_D ((USAGE) 0xBF) +#define HID_USAGE_TELEPHONY_HOST_AVAILABLE ((USAGE) 0xF1) + + +// +// Microsoft Bluetooth Handsfree Page (0xFFF3) +// +#define HID_USAGE_MS_BTH_HF_DIALNUMBER ((USAGE) 0x21) +#define HID_USAGE_MS_BTH_HF_DIALMEMORY ((USAGE) 0x22) + + +// +// and others... +// + +#define HID_USAGE_CONSUMERCTRL ((USAGE)0x01) +#define HID_USAGE_DIGITIZER_PEN ((USAGE)0x02) +#define HID_USAGE_DIGITIZER_IN_RANGE ((USAGE)0x32) +#define HID_USAGE_DIGITIZER_TIP_SWITCH ((USAGE)0x42) +#define HID_USAGE_DIGITIZER_BARREL_SWITCH ((USAGE)0x44) + +#endif + + diff --git a/setupapi-x64/setupapi.dll b/setupapi-x64/setupapi.dll new file mode 100644 index 0000000000000000000000000000000000000000..0331b84d484c0568af45517782ad08980b2afe7d GIT binary patch literal 4518336 zcmeFad0<>s*#~^n6ex6IfQo)G-(SG!0~#X3_;ICX>u089JF6X6Zr! z!)leH0V`BQ2w0#>(fA68iWsCSXu*J>tP-Fo2=8mqDy#DSerLJcOwv@}?|c9GCOOZ! z_uS{4^PJ~A=Q;a1wV&xW3Jt>;4fFBGhVcMw{>lU#9t`61gp+?X!MOME$0t8fQ1kfY z#*S#(Or{d;sZgic8j8mg8M7r~rm}G}8aFHJgJx$U94Q$;{)j0m=r=Z>vuF2lMK@}5 zNAvwRet`FPlap__UD&7IaEJIl<;F`+p!*c@{%+D#cF_&@2)t=GoFVMzZ-(onbWUZ+Yy2PZ-8dr+Z+6vHeiP7@C3XuMuRuaIe29ysYomVMDmEdGM<7RhVA&38OAcl>;L~a3|1y@OwS@z9z%B@3V&QUYILk zYG8aYyXH>ty$6#lF7yo|ydGsA0$Tf)8@?aFej4^f*aNT=um@p(8}{fb!}ld+H^3(T z-wF+565RJI`|rx881wrXuo+JHaOwX#yiWuE*aE{i6Lu2s0oVc9j2A`S2;+UKavukq z;T#E@;lP{Gh3_mL^uI;flVR_``_sz4Lb?AD^w9qpyzj<$6knqc_EE40V8>yT{*a>Y zHQ?{ZJ4*oZ@ha#!N#Q+%@J5sN9cH?k6H4li*$kyA*ag>@wI( zVXuWf5B4V5$HU$M+Yfs;>{{4;u$RMr8ul5m-++A*>@n4bZzb%Bu;;>_274mxGT5iW zu7SM*b~Eg0ursh1z}^bG9`+8{%V6(@T?zX^*cGt%!mffn0DBSaLDN1tu@=EI%{ zdkO3*uouHV6ZS&bjj(HAcfg(lI|CcZ7r!>ZZFmpE-VHkf`$5uy?>d8aDH_6ZUSrlMu@7bl8+T z%E4Z^Gyf@XpMt#)@2A41oKJ(@1w6{dez;Tq$J7|U(_l}6&3vB=oB2(C9}Amu$b4T5 zca|f{6XmP}?`hbZU_%ufTVZEm?|{7l_Ab~PVLu3)b=zLpn_&;Y1{;MuZ-V^>-Y!M+N%ug>s|hs|rzGRwg4<_L@Ijz`&G5Z_ z^#mE-6udK2vjtWf8Tgf@Qs(&lpZvN%80+hS>4oW2HlMW_90xwY^uuichPKA%vjP4H z`@^w5AB>?4-F*1QFvWKe$#Cdb`=>n!!!T&~I*f^M_?_QqOqfy_5f;8RFPh-%g6V!qB@gNto?0 zkHU*kh0n zm_0DWF@J;ng5mRfPk^TZ#G&5r#d{yjvoLSNEclmAyZI0B_IUe!>zg(W)TQ3v+xsC$ zCqNGVZut6P&w%|P>}J@zV0Xjb4tp2uF4+CBW3UHduZ69{Yu;z4Tf6oA*>=-$p9#04 zO^Ko10_2m|jd&^`jTg@2wkeO>wmfbsC}ZaW@cC0V-Nr-U<0SClC*VEoX|Q`?`(WP; z`=bXTpRoI3XJFHRGweNhuYo-g_5#?uVNZd*4K^xC-!#}CA)f9&ls(u<*iXX_!0v-R z7xr%0ny!q>C!JQh-wZb`OB(OlS90Cn&f~UeaW3AtH*B8j@G>X^n$Oy80sMO1&UECF z#@m|5Z*QJ-?19^1+LN-M&6Bpb^WYiCOSU1LzlqFW)9HdXRvtHET>Llat&<_cu*bo^ z7xsH6AwOa7gZ&2Ve%SB9eh{_~8L+p*?tTbz4?BSO80;kMwRDGF3Ht%qrLZ+M zlaQ|yCqsYy6mGEJeh9`yUc-JC_Ktaw9oRnTuwK|N!u@90dth&c{UGcN>?>jG^z8eSEel#U`}4T%rp%bqm&V%zouK7NyNz-9B{tn3_@j-d-6rM1 zE6wB9aaOM1?RoG9^2D(pZiQA#B`tJwI0^cuD4Eu@(XOGJ$tUTL_JTZk&3W)1g{n$w_7wSU%zzF5T>)jUgN^n-V8+cX@Xdu;3$qF4W|#+I24H-p2oEL+(*v^y<_(zR zX2Bh16HG768!(fQ-ZGfRlYkG?1M@VDaWc{f6NA|W^EAvj6K*hJm@b%Jm=|HjOa?75 z9WXb;^ug?d8GQ=eVb;QQ!|Z_>fEoR1gagw7b2H3dnEf!*rWE*^VYb2C3$q`lvqnJf*;wf!Pi72F#RcNE6Ifn0sON!R-7L;(~b(X38Y+ z73N}?-7tG$-iDcWVu5cR%r=+@UF{V@Et_XLCyD)2oE!}tFC zkXD#M7~lPHg9*Tt!gRqTVR~SCVTjLP|3s;c;TIhN0{Dje{Qy1!c*dv#L6QLBV9Q1&uF;4c8?AVA+ZbOq3(1d#;jBZ5c*^b|oUK^Z}SpqU^^&_&Qg&`Z!q z&`&TxFi3!|Jc1%H0Y>?b2N;+H(0wvMj|nhH(D!M&6#?{514z!`>l}c=d3-tppll&P z*CK)?06nz`bl^ff8CUT2YJk3L0S0dZ2;2?OFTewM>is1^*P{T*Ujg*|1|ZN6F!&^Z z`CEYAXZiFzK-WtEfdM}4189C7V1S@>5TNYuh_@GDRNy^+_z^`e;i>f70LI+_ecuJ>?WNm)(e3*Hg9K&w0rdX}Ao(+ZzDEEC9t9|S5}^AjfFuU1 zM;X5dXnq!;>^VL?577NGK>q;1z$*a0w*k8T2cY{e0D(aOb3ec!LD@g(_AZ~^BX}R6 z^aB9nLx3(!FpcW_7eMl30Mj@G;f(??3IPU319Tk*&^rcT;BbKcBLD`+0T@RTpxPZZ zNMIff;F}0g`U!yMV*v&y0}Px3&^-m9uLz)YGb-w?i}2*Tk{_-DFt+lEp#O_}x(1+c zJ3!f20h(_H7$6wDg|9sTWxM$L7=Ujtfblqh`2;}oZvgt9LmXu<;3@ecK-tTD8UW~d z4WNG?z~Jiu1AheQ{S(2P0R05Le+KA&3t;eVfWZF%^!){(XAq$K9lrh*V1S_aZvZ{} z0h0d!=q4C^7oholfYJ~6T8hDxvIPL$O#uB*9SR@62k3eZugxz2lop^3*Lxg*Ir%V< zdkVn76o9}~zAoic8G#=tJ+*wQ0~i1>0`&lW1f>Cjm3$@WZUE?M23|4*P}%}8NYK?v zw=lp!1fZ`CptJ*^m!Ln&*Y$iQ=o*_>3_KU=%>_XaL_~0D}UI z!BhX?0LEB=K7z6d0OpYZ{R9I?0rVXW;G4)Nf`MZJ0>|@-AbA3S@hQ5U0?-U#7^ebs z5d@~gt)C!pI)J$dZUf~2y?%gX72J$!fW8o3yIc4~;A;g)5|nllnV|17y!KxK&~p_) z;PU{3TLF5%2vB+rfUymri=g={@L_xvVBl+bExQR|a2LV12zCSbz5~!p(Dhw_vR;7Z z`}q{X*jni(0N;A*x_wNAB1ipU&loAXO z81M4+eSksp2!Kxmm@@#3VuINKrE}>v55PB{PiFvhFXHQ&0LBu4J_2(oKo3DzIY4s- zK%XBVPz7Mt19Sxdd@BLE33?j<23FJUGXP!Z12i`S^jrWCSPw8r&=mvd>%{P8PaMFP z07xbQ1~(Aza{vRE0d!vuP<91?aV0>KpzJDu-m3uu+W?Gf`AX3IWq|%3fUesKz6sDn z&`Z!yFi2qR1n?1<1f>LJ1Ob9(f+Rr~!N3ndRr3QR?I!>|KLbea0SLT^uiY;ZlY1g08di+FL`=hSxv`Kz|gV>;iyZg1~x!L4w{+fMgn= zX9K{%E`o0n>;~xj4nS!yfbjr8Pai@n$BIqN)q=aD%5DXGv4g`S`U={-?{{p}qlVM=832p}F+%OG=SAw#m0h&L- zR|2dDKzQQmSUh1l0D}4?Kp6p62mo1tsd&P~6i~JRV8|YL_W)p`3b7SnUJlb$cp|{0 z6_5`Dz;Hgs+PQvY_ey}ZL4b}`0AsELz%PhZL@UimJZ!EG#iHS8X0zEA3$>@06m2pq z63NYVSWkqPFme6HCL?1+jJT0DqDBICg@73&WrU1Yd`lC}2m&W#WRd6~TtmQH4*VEg zSHd+S4Dq%!1uM$ynwD4B_?uR)@~`rnkxkLew4(3~vvgBY>4HtuFH!Wxvz;xGl$mHV zTS1c#!>KA>t!=0UR1yR zmD@9Wt6umKb*$G7wVF|x+E5uux5^lc&7zH93N-ekQcw1elGvW#_7;TS(Hn&@(H4{z5U2c_;Tv`ID#D-{C`PT6wk+HNSMbi=h zZxhIcs1dgK{HL1tUj5)plghsxz0qH@^Ve&nylD{wPbFQ!)tu9u3J{W zmi(+S%8hf4dSew8{S+h!JmC}LbpCvvm zN_-G0N+azNqf>BM>Mo{HN_4x(F^L<1EA^VzaQU&AFLszR?_{W?X`Rskd8h&xDH#or zkafu8a?rFwNVOk0AN};EqPqf5RDE|$$76T>eoh;8IrVQV=+27rRSjq$4t+S=AuBD**HtEC>tgCRu_qc)AH5($*3z@w{z0V|E%jW+n-#%D=>iG zYK|Lv-6F0|aD(wjjTTTAfh#H)xTHYcMqx`guiitqD@PYH9xoo-jMR@%u$G=GogJQ8 zB*9$rV09#w_Uf@3#Jw53piDdER7$a~zmQLnP^z^9#oBC3Kuds8)s@rI(}n(yBRvtM zgSA=|`EK(bapFq~Ut~RK7)3@YFiVE8kp^Jv8cO=5jF7$*!j0g26rrt$(bUSil$F70 zh9F0Ty#O-6xM=goFZsi%0|z=0vI++_spH!w_(l=H8@VTcTkKl6siHn`uB?jfg3Go* zFtZtDR{X45(Jl#g-A)ab1o!#tcyoSj(Q8i}_0xyP7^lBdc${7Cs-VZKk#5kR$fjB& z4T(gCrF@Y&6^Wi|xtl3`Fq16*Eul1|88w#lfqG8)Rl0wXt@|wuJ2;ewHbK00TA7Vx zBSGYSEW+fKl%Qa2p$HUvQ!m}AQ1E#X+8=RBHCq}n=t0@Gk$i4|8+D`8P4mO)x*HbmkxDPJD`JUsgauJ(9W-`gF{E^32b)0`QW3E+1ZuPCh&c^Q@YhGe)4>3L zDuqHLm4RRi!aKF~`77?cackN3;BD70U9)&P>te6$vb} zbPZL9D@J}}JD;s#rypwCJn@P4p5@N^Op%aRmx}L~P!Bn}16nh(eCZZmz3Nx8{${^M z{#fU_^}>H%{_HrJZrOWfdz*DQfo9sb?*Lm-yJwf!y2> zkyR*Fum{c4pD~xHX0^y|)^S7Wtu?5@E74w|R8T|NI*qwi0&YqDCVLc2&nByNL(O)P z;->wbEg<&u*aN8%F|&r{FO4_Zf)1f=5k=^vYtAs=W)Jgi))3#AzZ(#COi)0i+;|y( z(uKo1-<|$tLb}&OHzW}Pe@@*HL`q~UeVxS*hLMCTTa@yvY(KFbOTJd&TLK*APxpKS zJ^OE%b?KS@tqLZf7h)+;yHVso-q;7 z$J$5AqAbm%RJMN^wzovc_9fe#vR$kp){ugh6ewYiGEVj(*iP4V2h*r)QoG*mL|ool zcBA0CUCYY;aS9<(XKYX*N*dQ8Of5sK#o3P|$66tCG6Z{^O6FM+(q#AI>>MltecpZw z+YkJOlF{PMbn(V$yf__6u~sYY48=q3k5A_NCM>JpjWq#D1<7iXn^b^Wrl?I;tm zh$FRzQB_&(dJnGf*VH&%f-7p)ln1J<0Lm*@gitcs5s4-BtFdZRV+Ul*dJm^Iq%+7E?GOy0^`c)8 zUNFFlZ>8lzd^S(CLrW-ZqG^)AU<|s{7)p+$I-?l(LZ>SniAN*UKy7TZpqG-)q>XsO zOlMm=R0~dii*xWXlSr7cM7$mNs&$8&ClyJHzMk2VO>Z`$2{Xdx4Nwf(IZ32AxSKH} z9MLnP@eLf4HbbfQEQ=5E7+*4kwxS@2t|0ZL)Y93WpJ8x+xlOLQ4?xuiimhlSKgH(C%%a&S-3N z6F)mr2f7mRxNHbFg<=?=4sT|VC<*Nh-Y}5QO(X>|r(09eBxJ_rr$w|eT;Zf5Z6FD0 zafFS)A|hW9OePu^sczD=r6Lz*(dQJE7UNUyMh6B|o3e3Gg$BQ5z0ET>nUDcASyS00 z8a!Ganw;{W6Q^hrk%8AuT-niNHYZW9MLQ$mrbLzj+Tm?XWMko`7D_tY75_~sGoqlmWJZ6Ny$~B8(Ywlt z;yLDGgp3KE>pa0w0=iXp;kVpDn&{~zIz_n=dPd4NWl@%0hb+=f<(bivO018>&14km zv}Ml><;o~jmymTfhHY7Q_{k%~R7yEAY-(OOWjL}4HA;pO%dv{i5cHH#UqbJQBqOzu zF3L9sRbBFp`IC4i+7`taYzn$%1DO^@7qC4PGg~%ea5Ig<5`nfrKA{{XL47h6<)|mL zBodHGC1R$PvBZ(OF&&98YYlWBLr%q~c!w^mly@b&rbo7|#Ov=)vY~6GY)h3(-HV}8 z^q@f;2k{v%+=SMHt)q0RDSp@4$Y(9mNQy2SW;z2-b&?WMH+bt56B=D>4iTTIZ!`%) zHXR9QNr>K6uua4G7Zx{Tbi=(4_3G9V?^dwO$cOClC+ z6(VECA{#J;i0~lE82+#ekkD_os0jTAH1W&VzKf+XZ6zp&;|Ezx%Tf*+>|)q-6v>3{~>{%MiEB%IIrXEFX(Ulf^nSv|Gf5r zo`t2=H+LOb_m%xSoS6Kc+j}yM<7#*Au35JFjNg9x&uc$;`lWx=e)_PBr;q){{4OcOb_dX~Q{ktf7Q}d0v2t&TJZ`G+>+-{6V<8-3WBYhdh)z>tA(R}jtrN3I+*7rj5 z_3sj|!tfijfH4P0JVP;@h5%#+8OUg(pNk&`M00DsbTSr!Lgn1G=1%?Q%-*Mp^DY7EV#Jv z>?sdl`Rc{1&^KET!?9CV#2ka*cu^L;Ov>LM_O>m3=JH$TWPbnl3w^iGyZ`En!>3I+ za`wV6ERH8D@f%P|kzmmCLXk3R(NFrOpn`6d8OG5;aQ3ERDXJW*oVTEt1V(kTNZrq#;L<0Uv*kJ z9yAobo!X(XI8Ma*InLv9lz?M5Hdph-I2^tm>KHiSZhaLM! z@blAgHgcFU+kTML4CQZln)3U?eB_S8Z_fVaoAWPzW>UIw%Mmj-PHq0v%y}h~Z$0|z zk|Y1ySFzi8`{B>LS==>cNznsKSDp6NEhQiS@a9|pRPe<8+t+Wr{>I~d4b9iS_0YFR zFIYY4lIN!1{L!{`za6}LeKFez+WzvLu0KXQLQi~H`s(Y0FZts8CjIP{>`%_#cJ4KEYyJ`$d+VM>i#Fb} z?&JB#eE(;c-Sp+<$EIq35npuLL+}6Q^=H0#?4Eho-1n_pm;U_fSDt&SWlbjf+2<~; zcy!qnpZ)RA&%12%=RY61@#PN|*9DHb_OF+n|5oG4CvN`TU)x@5UAyn5fpKT<`ta4Z zS8ljz)ufvHZmYj18!M`s)wBQUmu8uR4}bWBi(V`E4cDv;-b|EMIb=-H>=PGy9 z{%zhB#ouY2|NPoTmwfWk_ji6ie!`76KmPKja8uCFDP%m=8gU*PwT#HPNB0C;kJ{3ILFmM(kDvYA z%Rf1$vg@w9zd7&u+A&Wox~2OMkKA_j=x@L9iPfRoUv6r=d(NI)jymP+Uj%3GyXGb1 z%|D)c-!pe_eak=j)yJ-RXIcIGFF*6eUEz86J+$}T*S~hfasS-W z@y-iXS7smk=DX8>ebY;$-@kF&bqn9R{IQ>v*S>SsgZm#|{9i|&@sRJ4!nxP^Z@u9c zcYpcK-%kJCop;`T;+flKoiuJv(cixE@rupw_nh;G+wT18kJe8)|D{h3T>PbdZ%zH6 z>7iY}TmHg}_mn|f^H-O_{7`ChP_*$dH!S)YVkE|H^LK`lGtp%^v+*o5ir#UEefN5- z1XzaJw+c4b1XaSGhWEwzE5*2b8zBGA5H5=a&U6=s{=!h)U*;%3%MgqE%RDPI@0VHX zOEqdaw;vr^Fz1W*6BMnDVzeNN(e`lro^8d*7Kz63V&xBMw!l9_gekdg9FT9`_+|;J z7}Bf*P$n_w2+UGrHrh!{4PEEJl%j<+A8-85r&1XHogoY{&k%ly!$0~dh6`Qi3C!7m zbK#Ga%oZ36#5ab>R@oecI}6`uAZ`?3A1*QkP1AD$D{oz&o zM)NmnbYUR?9n?HXnfQp+$?Dydz6wm~USKMBeZGg+9;3cnwhC`F`v!7_4QJ3egUmKD z=al5klnKq|Tr_z6e)jyjr@ za2`A+TC1E_a zffIg|JoY&o;pWGhyJ|f98H|O)xlpd6EC*(d2TO-j4vZlDRsokQFR6`I;fY}d9bpCF zR*#uMKkP=}%dd7^^jiyz)v%p3EC+4_LTVJgYK1>Po>w6(Hy-1y1C{R7XgZzgtw3rd z-IWNtTExjXoZ+n&spcBGa>PbH9oUbXUqk!QG*yT=Di8-(tDXZBfQ!rpjlj;3CdB0|S2m7wfie_0`GaCLtwEi(SI) zI1c33?Q7)zn2&yub4=;EkP4Z92S<0kkagz2GZZZ=2cn(1SO*hSYrSpVWv7FAx=Qe- z60I}a-JK_Vqck-@hGdC!>N029U>U9xWwwS%MXpHw>dnh0Asy~m7``*ya`>(kxo2xi zmU;F({E!=dr(TlrvBcT&9mp?RMAXw9HFVO*{HCP(;p*gv)HthDi6ckr@h5rWj5h$+ zH6jeDn}dqlHL%ZtyAxN^s7n;X@|OOQrIos0>t&~YYeLReJJL6_Jdl^H`Km#Eor^|N z=i~`jI?0u-`Pb(yHT0izT#{piZJ;Izo9lxj$UTj>)IIKrv}o;9Cpawi7HeqMysRx( zA|$^s9FH6dpBl1qgt&It>?tmD`8seM2j|C*i{*w|mO0PgfzmQ^d?zO5nYCrZ0phUf zVxCjuP=ZH7*U0gmmyv=0!w$r&k>P5rk)a2XFvBX^zEAHa_;EyQ;FA3iRf7FmmUeGZ)_9iQJ=3mO|hF*OJIF?@X5AM;Sk zCwJH#*q<$z)Y%o#qPnd+G>uNok>;(`7fzqUrzbaWn~)lA9vqr3J1r~;_O2|pkZj#M zw0}wCaDKV(fa^o~<6$Yya|(?uFgL(_4`wgS2QWo*3ym_E^I)EX*$;E%yh7tNm|B=y zV15YmG|XRMj+kF)tb*x+`5R328HL7nn7uFs3-C^}u+Z2H^Ie!RiwccvVIGA!YB9dS z#9^+3`8kYnW}$Hz%=chUTvBK(gNeW#a#o>H3=@R8lV)k5@fgg0m?>q2#!8s`V2&&Y ztuP%hy)e(f48k0sslU+J z15>&j-(ZfaDl|62`~l|B6@|uhm`<1{Va8R1W|)mI*TeL|dA zXIwpD^w!f4`Qncc9eaq#7o*I;KC3QcO*D=r66sY*oT?wGz)HB55Z2BFLa9u7Qvll- z8nHLpIKt`c0{BuZ*jGg3Z9%!}3Qlcu4^jX-my80uF2`~!qdX^+5>+}&gyfee zqsB2t!3pU={cpZ-dDZs^UVP)R(Hnj=`t(en%xL3$g>Q6yLVUNwJ6*hAVd3M<3yNze>c9Z)N%6ZcaH*#UACl|tn<<_pESlZkeO3P(V zT-$aUdJw096D7hB;?N41RdKO?E|V}JJEmOmCD$2Y0h3%b8+Fclx$!eXcYtoEs@p`cTizZSzUcSwxq9VsBZL&BQ3mfi&c9}36@cb_05bI^vYHj z>E&;jI27?AoSmWQYRkrAa+?i`u$k$=sy?WBk@#W40j&-GKn=D`)z{UWt7v8at`V&= z{;2+#Ou5eotW!JMY~F;imP;n2IFZ7dd~kxv8=ii|yS%=k!rxTqU*m63@s?X@Ay1j5 zTr0+fVjHn{AQQp)3VORW{5$eb?$~pF)J#D@)^>?8mN!)S8~tmm zgN;E!gNPK-2-Rn+Yu%i5JEg3`O_P$tAW&E+JJXO4(a$csiS+gGk` zcTs9{@j1%HQG5RG`~K;FJ$uEQbA8u8HF)#eJ8o@)TM0%a_^Y&}yXGQ>qBdh%tQZN7 zxx5_v9x!%gg@v6iLj-m}932=U4t}Pxa_ivKIi%r}H?6Hnt($z-VPE+AF}HpA?w)BK zi|@Yrl<%E+gn7-6&T9E=I$)h4g547+NUSNQ&B~e7H2bv zg3D#tSa=t~(LgO&NRE}nZ6r}{oMmWOJIga_Amkm0nhU0}%p9+w7}_QX7TX`O4U)?# zAlTNbiV`Eh^{AUEN}Zwg5unGgm{>Gb#K|NfHlRT3g;^9mq&OT+v;GoWXdUTJMKY-< zmb04G@iw;iQ7U55^%3Y6P^wa+$`dL_TW_~wX)j2FPwsB9-Nj;FBuQ-65R4?3kXJhV zbTZP))#TVg97S}M4b`aYYM?`#mN(SbHmz!?QTkl&(X?lfcvg}wbM@GSQc+o30cMHI z%fuFCheIV6E5{O{u(OPasf_lV9y#(H`%Tje%A7!GdsPn11#ZG1{Pqt!`;e=w8 z0>oo^$3|c*vk$dqOtCFp>0XaVZE(c@S`3+9S>0!Rc*b&8@9Pwnf z1x2p|N##)wWP_?KAfWhjJ}bODXF!=XiS~q9m58A!={*mMXGF>G!DtK(lf2(o;p`h6FCoeZWzrKz zc^0iRY{+P3r^EBD4*XC$fD94m6QN#ijfgD^5KwMLksJ4gzN0v*GENn@$jM@n-|jPJ ztadJRWQRCv#x74%e_9HeO-rRr!B(L^*`_W<&1f5@4t2H=50b(R?$o(&3H=PKC`h@s zj#5G12p3SA_e=)tR)HqPp(pY{2K2l{^Td0$Lz`?<=|+M`w|8$ZPb{JW`OOTo;ZMOA zmp=3BT@Uof2+9;bqQ3QEWv0}W0y)h zbW*iG@n*7+Gy7ef9Vg{mXYgb%53R%HMiiGwqbEM$=HRwB!rXjQC-bmo(Z2hVbkzXKPY-+BI?CrP<}m_`rZaaM(F=h%{j14Sn1^?M-M&n>0)IU+&^ zmC)0w4rReRcJhJJs_~KD;tFTgy z^T%ARmU8GxYn;QGkvwB+x~nx~@m0i%+F}@gy3Ng2P*OD4fiHDcQP@&Mj`&1$;9C*2 z{|u~gX0;Ie06ER-PmH(}EQXVSJkn(+Vv9B<+b7 zc2OKcR$YlQQ(4_qSI;f_;t)2pe%U(1XbAnS!3YfT(In{P_IEk-CYx?hpTOd0acq(r z9p||j&q6PBIRDjqVrCkNRzvZ($bwch@-l~PjxEuPRB{A z7^*4?>m!?mtU2k@Z5=Q>=bP07V1JNf1WJ#p%*?@e)@G}c6uH3biF31Qy-TUWlQw`&~$i1a?s28 zoTEbCTw~wI9y3zxvc`F;E2WE_euig_0&yHxQ%~KDaRW}hX;3qRmN%3k!i*u`Ax$bjp14gzNO-30uxgK%L1EJtyW6VGrZO6SgYv;_!BzXsf!; zk1Gb5YIqERBZ=ayMJ^dK?9WRqM{n9ytTw6@k~d!zCdbRnAdd5Z&SZPa!j}wid=Wx1 zM11989Mz9j9qNW4CdM~%zOg}%ky}B!WZ6+BM(BH3G=x30&PGp*dCYDHYFt}?XT`D_ z6Llqr`Bjx-QiX7;0cXt$MXtu14}^B0cAedCl6Akgo8%hd5%mW~Rd~XHK8H^AiCALl zR@Ky~2Dca86loKVOs>hBBpNMx!-fL9I_~Q zU`K0>esUZ|oI;z8OFoHN9*-M%*Cu*UB^VV#(l8Dv&a6d=M&lN;uJA>YImNrg5kAkB zoNly5k~19#jt^==w1E=&CZTibfSEfVAh)_h*HaNos9Dhbq?a#Xnk|O zu^h=WpHy5{3@TVh8O3=??1hmc^-=bZoTpjtoT&)y z)GCIn(ycgrFr-H!l;{XmF7$%BZNMG_6LZuQ4=^Px+lS&bl@e2qi7b($)Tn)JKcXM2 zkU5>fejh^@eo(%ws@dU(Ym4%C$b>qUbmhdUYG~3Y507Twm?}k zwCq?p<)bktL+tQI!dp4vJEDM*Ry%Bw*E!yX%XNP~2FvkAPwv_EkkluOOs71DrS7-l z<|vx3w?>5Tu9gncudGu{*<78?dEEvcN@wbr#hXyeiq2M56h(`Jh4oFSo^|TX6gMnPpTR~soz;|>>X~dJU-(o0ImE{jD%wViRQ~@vp{nr2=&>Ax z`AU7Hh@%gj; zP#@~5(?Op#!LGmMt8_Lw$MLLmT4{89Mfp*TP_?h14<|Z;G0bOiBCokw&J}ocYFMf_ zI|^CQFxsibRJFD2I4nl%YeP_3;MNdPWq898lsI^z{j#o>%>j2(a(Qa=6NMk6&vFpC z#PniT%j{HOA-!V2 zQE6ML&J|?oN2DX42a{vlUVi4CA4Umsj(-m~X3gHP99)jbcA@Lei8k3+a+Md?*q&q7 z&K|X}Wx<6T&_mY&YHqxFM=*2zNughkrFrpiOw3-{k>sOE;s>M-*5fKF*Bm~Fh(|Tg zImsbgl8#|JN7+zml5wp%uICul?sqxAm=sM6n?xM|)KrS7J^>jaV7M)NyPwCq2cyIrzCOl(w>2 z+zBS)5Nbg7v)V*a)C*YhrCs%$HOeK9wv(Es5}i8tMRJu9Hd!#=ikTY5`!Rm7a(-U- zMExC`KbYS==iZGIe(}#UZolD#=&b0T?Je_fKmPKWZC6x%yA~@89mSKGR3x{9TH~+E4 z>4i-J0f>T=ju-0{cn1vX!G=867$7H6-0{;$@2s&k%7 z_Le;>;BeN_YHDe9Z6?}C;yMh+#N%XyFY1{^CWM;JE~p%}k2x(t6c%biEFO{75oRGph7HL+oqS_xe723jWie_b2gfn;>`Dq7>t6pkD@I&;mxAbR98m5?#0c4b%Na~p{8H46zL_Gc^HkW0Ns9b5{b3VtTMz=+?=37e})6CNMnv)J6>XV*{<-z zL%8RqAN!d|o=UDBxP*M<#OdQX*@rQT$mF@jAU7^MouVVD@$=~pXfLxd z6>V?lt%(sXvcqOTTull_ipGlTyF%prj+knZ@+Aj&+u3T8tr?ded$2hY3uEaxxfwXwCdSWRB?Kslo3;mn>>i>j1Bj$C+dUg_j= z40Z%~`Yue|2_;v59>|}N7d_t3jRKfih_~Y)fm6_q;FvtyzV;K!h|C4=Mx)|q2A@1M=?7+6st2chcpD;)5!F*Hx5M~vz&Zq8`@`chF#gky5un`4 zXbAtR5+90cPrO!TJ~TeYw>kU?p;HSMshW5XlN{&K!!KfjUa=@QpKP8|8EQ`ENvCQ| z49y=bjzhuIAz;%WD~q(Ft{Z|c&Uo|qa_VcSIX1bGV&3lq9rLC?y@bed(VPy z$2^P@H4NP ziU8@+WyJDplbBM)C+%q_d3g}bwo>SL0K#TS9_SS7K6AVcu^&YZ<~xKRWPvWRiQX!@ zsP%`WrxL63dB;YzSii&Daga~w{kPy0h0S8N9lFD@bBf;^F$2%Dg1Oc|<-!YNhS&X- z_}rV7Mi}(P-2!?Q0LPoWCol&EH7P)S4?EHWJl>%hMF>2%I3Pme9y9JpBNeRGWjtIT z5C;ySzG<4@xFUdeUDU%bzosw_!gGVOpol;BevD-Zo4XlO;x=|aY~rRoyXd4pa*y=d z{Bnn7yH_IAv>0^>AzV9s1vg)I`0SzubH}ba`lQEN8a`mSoxtS16fxj0!mRmBtR^5$ zVbH;K1v4==!+Uj?U|+?2%&c>6{S27-7?t5k>9df7++h)cE8SY~G#7g*xWl3p7z=^R z`)TIjZy`7}7jep)=$U5Td`kW?{&Mh$I|BoFCfyu^nP75UCXF$f2`1n58=ub;U(N^K zM)(YaH&L-F#CfwV@=EQIu1<@Y6I`QJZrv!j_k!empDMU(ZtIsnFgCCG;cIKajVL5k z?>cebfo$tIR>5m(t6gfF+ov(4!8_V#h^C!Vr*hy0Z9NW*U;sraOweqHr@MvvkPB9T z4Bwha$O%wH;R(?WkA+)oC>D{5h7K+j6;%uU9DLBAmU3&~w7L%Y#yy)XCFGTR&nKml zH>|r|dE+{{%R897r7@l3Vi^6W4t}C|_Ji{tIcwqbJL9Lmbo#pI4n42?-o-EO`d!(? z!qH9Ex^~&_4+-@q)u&_smSOz$Tetn{)`rt(KlZcf-`nzyH(#m{(v^lxF`wCg3f?TyNBBePwy4-l3+LgR){^bbC0Q{|&y{ z`o-2cj=Rkr`37>3KJN+jbp3beaBClGM(*&nPco4AYRNmUWxc~g8sug{(PN^Zqdl2L zN8fH2)Tn){&JTJ?AL*>Oc4ZB9&$c&M+jl#1CyCtREy^39L5lIjA9t7WHY=%#IL0b* z?3u>ISLv*6XN`j*;;23jQmv(+* zJgp)(Wy^#4CGRzmd92$bJh5NiU&hI{x-xxoliZg+Y;V-V>RMW0bBBg=K-)B)?4LJ))n$rc|nY#hhb|v|MPg=GVe^I zvn=tMZA<=wpqRX4-RCZoI0FW0celUn8i#)Q-R&p$`zpi~L9Q|QBrfmm zSqS$zFnp5pfShIHeFD@3en_;IZCn1>s`1LbyA8b#-<|EH|McE_r(`(GC-Wtro|f(h z+kVTf-|JE8c$NptEPpGI$2DSBQa)E8SNW4Gl4bpG3K!nnD0RaByL@90jxlMCCFvvy z|2O%VpB}olLu%Oils&&Z<+_c_sDnZY=PQ%qv!g_^Jm!`a-Y7*0XSv{?ys?XSO6hXK zJE|6<1kiB|KIENWvaJ4p7eDV) z)B0yIYC&7~{NK@J-;Cy@$9dnBR}VVxVsn3^7P7;0f7AJH-+eY)X|Lh+w3|;(x@>x# zx_L2j*{!$#cj>K6VV=@DIE|GX&YUyr8t0i6sm)1LM7Ge2F<{`MXkcbI62MK(sHJ2- z0&^`%u4&@&x~St=jzmEbODdNX$$5=rby^-PRhOBEXv|hts+=^$3UdbT{Lc5PNXEZD z>)dB0hVMn_7IPCgWFe@3*MG;hEuASe`|Y0*8Zx z7)tEK#v6<+k{=S;4%Z!}1H}<{s8x)tgFKw?i=o~yY%YFvriJwB?@=6kggr1~T2#B) z{WEN`#kz#XR5qPaWY~0BXM`}zu=AvKJ&ql4_U)jVTXFtVC2ZCt&R&wc*Pz?d`El(! zPM#Ab+uiwb-QjwD=Bt-%s$@TYofx+`Pz@hIdXlOKuwJ!zaAbe@4Kjj7RTeX1n13P7i_&y4}hVn#O9` zdPR|u^&84o9p-6+m6-ZqkGz7b>Qa&VmJ3jVgO!bmU^pC;6TvvCG|NLXt(q@CZc7Nq zQHTYO8Zkef{2E0wLC&d)^(&F`)|gq;fo#FDCd|>N5jz>Fv@<5J`rjDRs&sH5O8*m!eu>fERiqU+lcX`8gxncpGn6j_<;Qj>X{~=D8=% zkGAd<`kP#|6(Z7Oe~-i=X=05Rk+_y2g%cW41wdEFIfZWppuUM{JPWwFT+y)oi}7D< zILV66MG4w}?2q$Tgc54E&>Ns3<-PU%_QG%e**Cgk$E-^x-uU~4e~V4xUP1Ocgnog4 zw#a3lo?}?@l*w}Sv>9=*f5IPiVGG*E95X0~Kd#HUfL zB`cnseBu%sND`LpVC9vVji*0uyVdVhYGMnjKHOF>N(q6D9at}|Jky`ee|NZCgTwD) z#!`DQ(dWgn%}{sTCq07Dz5a15Ks!_tPMb_D!;T}IKh!Go7OPhx;v{qg%>!I@^2Aag znbD-?-w1C8_JME%F*Tuzz5&asaMmTyfD(I_y*$8rjCh7E8o8jJr=QMX1%d{F+E2L2 z>i>@f_WGG5u zY~;EAZE!$K2z8S zt1CP#@>$PQNJOh$)(Yy+#n8(qpwj}WS+^jZde2Es5eF9Fu_g*Qf2eaUS}Z$PF8Tai!4BgoljVy09`4v zQ;_Y-7H~mUlllxOfuaEFES{H6Z|hSt?XA?PxNJWGnko;>qJ=bIx7*b-DtBfBdq$^gAO zWL~v15Ci6%Asj86(bPp2us@0>8G~f2&&2W+oVm(IdU&JQg+sN^uu%74C5gVvL7Y4z z+lZn_i6|X1z$HgRulrvh=if|FwAX?Du}Nr72iZ zUe{!6Unt&SV5P$~(BKdH>ni+S_toV!)s@wa=Q`Y11);plYigF2SDfQtYlnjpSl@t? z*s(Q%G+5yW8dlXwbuTr)^P4lQreJkdoxg#>Q~{0j~u*;`r1HwLv^s8LD;mFS2R|yE^qWVp+(6L_=)nUgiz)+n#j$^ zqD>yLjuYhxqsWl_@nE5T&dw)MbOb0+kB7jf;ZN+%g6(uG6kptK+_S}>6HkYs-Dw|6 zpnm%MVcG$>MT&>QWBdog(P8N@%xP$ZitC#)QJi2Q<in7_yGFQzq*Zrg~T( z#=(WFsnPY-0mHXE%xpU0$rD0tXPv+HwVR$gYwMG;4=h)^mLhlcFNk|&gUD;{D)p|* zkn2e}H_25@95c_io{#H2;xMv*t=~8eoh<9jn|EO$m>R( z^-|=4T}w)~m)&#Y>tDHRT=sX=Np(f*c20WvpLJbk`;*Ie1qO=p_+`0Y`Q!9&e!A%P z%Bu!$TJp==CeNn+OTIb3w&=Adj{51tV~o>ZDLn4{L-u~@bEBU;>JA(?{$BR1ColDU z&v@R`p7*ThJ??qm?0LV~^L~lvJ>_}d{qkQ2J&l?`=np0b!zv9jtx0Y=W-gf=cHH)XSUh%rI{^@=Btw(+L^&i#s zy3zAk(X!XPGQzODvP62lc=_aub)(nsNqPLT?)Kubeem-;%PKzj%Ar*^&e#&}8gs{8 zlua)lFSji4@M#j6l|zp%P1z3qo9zWv-23obqW z=W)j2#bbNO%lmx!%Qlx6FJJyr9=&+^_`*E$;^otCq}hu{-h17sFTHNeU#}ba;&sc% zKgy(+SNUjR+4bU)2c_>6{opTEC;0AoXH@gHTi)7D8S=)PPwvSVuiTq(^XeeVeW9m( zkbhn`(mdLOM>nqyqF=8Y@g8out@eALEi2zy83;diS=|QarI)^GdE8FU<3>Jv{ZjtC zZuxjX{(143zn7GL7(2=DNuhxBO##)g6DR-TKSV zJax{AdEBViym-`qUbhqSxKTfQ@mPMnbv^mwbt4bFZsdX2jXdzWF>PLXW?p*rZWwOf z^6}|BZj=`<9(m<;Bd@$}Cym%~IUN`11M)xa1SUZB#AH`^>I88(} zx+fcQ%1fWEfuY_IZ_&nx7Kb+l4(3Ye+2rWIyys1}*VT?|wL@M^tn2Yl9US7$@0U}H z+}6gK1v#MP3I_i8%kS47C>Pt|hYUo`<{gk0ro-O$E#q7fRae@{q`IQy%@~+D$PM1h zOFh|5ZrX>LVsKN;@_7lILm87(N;aOD{7jpj@@!!? zKPa~{sq$b6*IWhW#}K`iQ0Lw+`@W12j}X9qU?I!ImeOtb)hYyLj7WnRjTF=hbdl+Z zKl|!E|9xKlQw#5k{rIp8&-~h0?(N_hJNxl^Hv;uUiRjPSy9n5ix7QPM6u{mSC3lx_ zKa3o&Pho_Bdr2a~B^M7X$`F_Hgm!rb0&dL2dN0Op?>%C?q{ZDEq}v+wNUQNx?x~Tn za95Rl=e?TjSMpaP)?2lMevVMc{SWnO4^t&T30wAK?R3*!-$}#u6ZTDl+TEsA z?)|d&WY91732@Z~@1T-~MJd)+Xed?BkOU97T#D zJaU@*mvm2@vQ`aQ;s}CseF^vY+9OC#%d0uE|V2>yZ+tLSY2To;()==;`Q1Skqae#(20k-;Xh#CeTAl%V9TxE6&{vD!4QNlOr=t*o8%38m9v9?y&Xupyf^s=l&$QKU|kr z=A_&uq22ZVaR%V@=iWo){>E~z_v}!IwTV)j!LB%|)8y@V_HCUETjI%eqPiSNUCR8U zB)7u9EL99&>kZzW${))>{{5m-n=2kFV=CARdZ|}X6 zM_kFuoiO^|K3gx;2#&7z#8C}wJ@)JjXBl|G5$dq;)ee5zc-&tlOBgjI^OkiC_m#=~ zse-HA!$Q6~CCQsB5`Vb8dL!F|%wt{UI$YUq(nn6Y3ik|+#YU6f?*RoTksX{|mgf%8bcA8Wn-6iSTyZBF{^ITcaR&El zvC?m95$0dh9oF&_(L&>G&{*7%iE)-!@)%?H5wXHfE&{gV!x}nqs;cfwSa|AGVf(ur z*SC`d{x8DOd}yVma6X^7L4r5GFk7%x8F=#e8qwy>>(?VJI%RorBcidZQ7n0|l7U!f z3f3*+)&)V3wQm9xSnKdD4zHXB10o)s?JV zzNinhwQ(4RhxPfx$U$<4VG$`3>ZZe9D`jCZ*Id$WhT5?z%XvVJlq1k5#K`g~8R_yX z+qg@xE|FRmY}OfBn0Z>;g$fWOIK8{mo_hg_>` zs;nh-b@dfB^~;v|8)nw8_BX6)sBZMv*VUXWmRurJyu6T^=t$GN={Y#KG*QxGX*Y4b zdk$VaveERQIB>9l97kchzPsp=_sI*aup5o(wduy1S+VOkALVk5pFGV>T@565J_M`+ z$2EXMf5-X=>{XB__~(YDPJYsXxsbi#dTRDHzPRB$PbBFpu;IOioE4q;Qmn#39+ic5hiW7w5~FEKXk@I%IFEmB|O zH@Vn{N9xMzyEP7aO1iGQ=Ce{_89ljht>JY?(o^Zwp+-uwJqc17c-&&-No{7g1TR$$HHs+vZ5)u3pT984Hw;|TEW9IZ*J=RWGQgs zu@A;^8A6S-3Uc8M&yDAfdt`hXF6Mk(%NK{2D$O(r5F@{F%6_AkqHv5t|tn5hs)TIEf` zaPc_9XQ(rU#%%|Wof1ZO%9oS|?>DyYOx4EI`%Uya`ES#y+RY(Wc;cW()=8T6vfL>3 zE4RC;9gU7dCjFbxp%bl09fXvbq3{|1Q2WPtVuii0jH3)Zm8Bj=rjssGlgqJ}ncxb~ zk&*kz*pueiBQ>=g18{$57?cA!=BD{7$D8Z$g*|=4+Mgr&H9TZmSg%NG(B^ZM1CH^^ zlUHQeCdPC)?nhgGF+pbn@80srnn~s$PqmY>#kd^xV}rk{I@suMsH~|8vQKSqY$`Ep z#W_`+S}0=sy~xo~#)4?>_mTJX%-uA@%;024tX{>wr!cOQEZ6y~<|Rc9FQePZugzqXztknv){}+%_M@>IL8$&nBjGR8x-)HAI--?CDqfU;I0#`adL=b`F40K;GV(QtQ^(RW0wiE)5uHKnUr~!UY@7OvdZyzeKrcqC1`ZYxt&xV z1|2fRHfpT6=JC+tctfhb3Z&a9o*At(F8w1oqN;ttvpPmRAdapz75CE-Em^u2u7OpiRF6O z(8^&k&@p76WH|c0OY?{3k<{;L%rOqfttH?ye?x_%>vfL)vOEkI8pqN36TH=gf3)FGzF;W zRF=fCrwckrE)<=^ZGvaU~H;#g4H8t-z{RM1Ytx%}6#a<@&XTf;8 z9S0WRq!R~VnzZk(xmb=i~9qc*m;;f~cXdA(mwrrr4Av~BF zvk(q}JC%TYk^G=J5!{2K6eW62zd&K}3Cx1_dlkbdW0+D;dE$CBx)P^~Y6l%fL~wG7 zi0g0&o;X2@2%W6GK?R5)+bW{USi%+M1AR@5?4TkDj~^BxeJbBj=qI~3Cn_MX*= z^-zZPnW@Q#VTXf3fY`y26t)=wdeN+Gpjw*n*m@8ZqSq1_F@$fK7>QmMFnoZX)3j;~?X%}!ih`?yY$Ujc-6=R7kUr^!D4X&&@FdEMEkTIo8LNMb zVy~kZf+_*yxcN?RXCekf^i3RnY2M%qyKZO$!bArkHWTNgOG_5cbG zSd-!2a1=e4>*Y8$!AyL4d;;_bX}Qh;t-cAgfpQSzdp;% z5Czf&ISzjz$&mP zgfJuZfk~!KYu8BE{Gv5yk)zOK!}dc-G#!as7>etR%nHE^T1IO$l$`W=lstYiYRX<* z4-ktqKLnXb>&~gXvFQ26=-pCsk74R)MGC(Dpeo_nQ{;?mU=K{_8Y#^T+GOR7=%tqw zzm+Z_((Q4Eii|9!Hfya^D+VGE1#H->$JPyyj7Q@4nR)yJg+oEnaDo4Fo4 zba0`!+mT?}YHb+s3xD8FMle^A^H9`_+16=F-%gmUu`=|@swle}@1o+AH0`wM!Hr+8 zK5@_ZHxSesY#=F`bQ?t|-G7wU;TYD082z#}V(YLMBPvJoiWj2a$ix0fGUyX&K=+_( z#U{ZCFVT!N#^$gus4k?EXn(T13)puEs6#9JOk1)rf*K1{hhgBLF+8=Njv>iL*+5># z?)oB*Fp@Ox72%#c#$I%RU$g*2c@_azMg=5MQI<7zx3vLR^L0( z2AwW{oTJLpEbg+$0JlUf19xz7Pui5mnJX=+2wx{B!+Jq0T$;n9bi#9A`-;}u%ymCV z#hqIGVC&vsWr((ExVy{5rN>z^y1qxU`P?Btv)V-Y&e*=mtJ52v#enY1Yk-#Q0Rt%jFL{fB{U)b4;65~d28#ZXQ;7Y65(mQ<^&d}o%YZtH zAKY=^?=a{)(Ni2@7KFkb>PHT6h50dhIDX_kLkn7Qoe6DgiB>0@A9bMsm_1&gJK?nt zl$G(rmujEz#!x8Z47tfk!l;pGBBOI&Z4hY5N4k$#A_>_%gvA=*J2 zB;zBk;mg8-Igl3oX?h`}h-XoI%7NLN?hURhh?P0v@htT6`YAb+(Apf=95@zar68{i z=D{%`*mZ|-kq@^E^@BAa(z<+}@*`MrE_y*t*rE^gQC^$a3Q`nH`LZJ_ z-9O3sC_PHDW5BLq5f1E|EEc8PKraU3Z{RCh17kVnM0D9UBw<1f6CFglUg?&}x%NJQ z0fKjVG(tEV(jsy`qSz}z>ZreEsuyK6X)de z+DF{F0QMYd$tPV888z{_=nIv|(vd$%eIm7xCJ0rdyl$9|q%nr$jr?3(f=IW6bB9Pf z`Sk2f&kh_nFW_6UaEjY5VoR?Ak>Wd334jbY{=}z z5yqNOAHcsz4YK$^T4p1i5zT--_e@@XgcS2R(A0%>I{?mI=$^@!LE^N=NJrE)<@JSd z5#%XI#f-;S!}w>TK^|ARH!Z-3Wd`7e&hSuak&`{q|?jfH*SS0Z& zizg;8OBW2cAS*96T^b*R4v?D@O_z)nn;)UWUJ%|d&G`uISSR7|tOYr0Tga&yykRYj z7Dse@O%o>!@P36%VBSFPia7%$Qz^B%dN2mE8T5NW<5 zSs&4k?dcK4m8UGO3H(G4l+;aGT%+#FNM|C^Jb}(7c?RKIxUyyF4BrK!&Wi98UH?aX zL{iscX-1NU5qm^}BVQ#eSNuh73#ov`oAkK+te%F(2k}oh7}4608psX+!qTvwz{o42 zvm@2B(xaiauttOvtw0*eL)u0uias+49m3;A4X1mLGs_X~$?A$7Z8lwU?qNIZGiD4> zLbH;LeJ;Lo5HE-6`2P22dzz#?jvoi0l-~xUe}w{Wk#pjkT=Jfog@et*U>P+_j3mISe+5@N3 z<(ZucTpuCb{@6FO*S-h+pm`VCXk=N^N zX|`Qa5qlm4AqeO5qEbn_aJqs$*h-~E`9iEF#Js3Z`{d;Kv1}T#$7jz=$9&}dB}V$d z_kQB>YaQ=$SpRG0%NPhyy=pz<4n#Q<&7JhtQy5_pLgKALlxQ>i=X$*yuTFp z6+nwk{Gdgq5xh^s_hR_*P64|v`b{;w?FAbH^l!y8QM#pq9S4|_f_VcR>et=K2;LYw zdHcY*0e)cVmI@&m;A|i;_HLj&oj;U*--*5#$+SII0{mjcUi9Wd4uc%w-jzKqgfF;O zUSBu%v2-;Z(pmJLR>@#b`@QZrOg%JX-tPRIzA2C{Lp(Teyb;UEz-#f1UmDy8!#y9a z@g6O&#eI%gf2!V)3*uHNX!^7dTW8TKn7STOecgoE>L6ZFe<6Dyyl7Di)|aE&@y;yYUjb*IN?eS&`sT0wyO>6;k+28;rVhk;`1Biu@#@J!_hM2^g=>~TRqSHyc0cGHEJ9<$c#KUv8i<0c03wwh8)-bl`8HAU(Y-|@%V0>XPxWKZX2Xg&Fvh7O z&dK@dh;x7+U^FnKg|T!WrQwJH19>p(WjaRp3H#1K0;DtK z91s&0X1TQeB=XV-D1jat_(l_VH#oo##4QS3fv=#xgBlM?cwEZ`Lv8rMoN1u35`PVr zb1^AIuR+nu_@#peL&H=he_`xy2o_%0hY`qeUAua@gd?{ zUirRNIZOw?VRJV|sK3gBKeHo?IY47=cT-tZ{k zlwj}N>WOS4iB|XM2`2&XAGXV~-ah49YY*o<(YE zG#p(grlp7oRAh-+UsmM4L=S6`_?R5j3P>sdgbpBm~~U_$6@aAPxuZ{zAlCH)s;Zgp3l$7aXRdm;*4$W(>?T zsru?&K^Xt5uzK-=UF$^$@{)2^0T@L7Dqw~wRUadpXuOD%etkpXQSnLG{Ui=O2LOIN z;E#htFVYzSZRk+@qgG}5@h9!lJ~DsQxGWxj-aed=3hEMc8+;<6!@tr;Xy%9bt;Z=l zct{eomiCAB%c(LAy#jxeDrDdWnt|0QL)xe~*5Be}Ko2DXaRLZroCC>Wsj1)xm=c+e z;p13JLjOf^Po-WQSmzSqk{*U$T!3MQvxOy&O%D?tZ6-yh01rP=G=DJs1Phy7#EJW7 zK~Zqd`tL&fzr-KTHCi~=k3Aw%9FLI_{umAMrT;hh{4?nP*Z7TQwbObfkzg3~qXZiL z^5x9`Gde}Q{wmaxGVS+hNoro!(;&;z#96D{$q6_DenN9|6nzXokxQp?>i>2A)^IB_ z^dzSp$$tDA*OIAMyb>|42>V=c!XwQ%e@VXnymhH@`IC0(5s@Qbf8O{{MCvb8DTOyV^~s~RpI7|zdc}u`%#+`niKuP-x9IKnxwKS&#XI+_ zbl(vD{XQ^%f)^Qj{G(>2=~Ds^a)?WeSpOsK$!S6!{r-MiQsXP99r3Obdj3^;^xvi9 zUxPxbf8w3_PtfnL0r4NB+h1-@nqK9Ms}za;V%1Xklv8g*bopxy{JehgA(W=aIE>#Q z(&J>;{QoO@{1FsV{S)uZf0iD91jK)V9)HrDG(9r?mP0=c(&Z1Ekix5+dYLB4ehNx@ zk=Hb+tucwPM?*)vfSo~aE~u=I;u}l#wb5~f!q|5(WYzo2_0SqJJwJY0kZB*W0q;}k z^#?D74^Fp{KP@YV&g*-?>QmzQFyg>_9MX*h*sKqOV9@D!oGiqxXSbJOYc3)l>;`xU z4II!-YxtmxOYhi=hdKF0JpPZ`XYv1EYw!o-_FrjJitbr*!Oa^H!C+t>@^ZJKbz6h` zh-`hL0Pa7pK_Y%tq{Nm5aVeLHOGEFP!knYGTaOFk{Uc+(I3_GD>CqxW4vi1LvS<3Q%IraUFL;f6hMx6Q` z35d=^n3ojVq~(HGuutGUB&HZ14Cf4+;PeaRhW7KN=sKpxCAlZT}NbTZ!PA zX81w-9+82Z43Od$IvD!}d+SZx&0r)jtN~9H!)P`XSp867v4dU=XyJ~r;fS9EW3P*T z6=?JAMfIbt)m=otPVn0eY?o{RTJ%+RgDdm{wxR!_T{~K)iQ6rR>`frTF~rddgMh$n ztZAZJ$?$&3@-b1c@Icc+2y`?Cqb16z2t~5&8-6rVKn@}bV?{Z}<4Z&re>W$RBBCWw z_s}eePV0pu%jnK1?3uDsbjQR?ZLkMY`Rn;HU4RbIDl!qEIdm^kEF}^pHzg`LEG|Vn z9xZd+Y!ti&hq%K~8~u)>f!2wAEg$TqI50kFrAp4i6YZ&O(sSb$BhI$ z6ZOEGL|vot0H&T&{i+YdMwbCr4U01Z6$~P4E6Lhmk<)l1qA<==q?DB4($T}1Ss_6~ zVBbKi4Dw>J$qYP+=Ow=%qEL%sQN$$A%tTvW^b8=sLy1^kg^Db& zm|u#@9{O_Tn#MPq?;b&^2b_5N`kB-{(l~zP+25gu3lqOk(pH)SHehU=DiXCH?fYv{!}2;p{BwtPeHYYL z+b_zg3)(aCzR>{tb>EdIHg{V#Cb^O6+fxhBW;Fr$3=eGDh&>)-sYgL7KEwMMnP+fZ z7tayGrY9vjlH+z#xfl)$&d`Gsh?2&_GzOC<-dNvQ2v6z_djj~(Edegv;cS&qVk9q_ zCMqeB&nF73`y!&yWL_d2Y~&qAJ0`^^(ZYeP7t+1bqEf&jkWPa#q$L?}XahyCSn`5^ zy~r}qnSoC0N2$|M`0;NK`X64AG%k!7+B@P|3?zmZ+VP?FJP-a6>v}w!0WCGfPisg3 z%0#Pil7l^$0qw*|WHO|LU|MFR(pMODDqKW2c)CRbJWU15&ItHThxRcpr+9=Z^p=T$ zaUvs@Ok3AOthwKU7hzx`iIS5}$K1IU@u8k;n-x?09fMo}vd4#;?b7G!Vn$ zBb_d?_2$sgzc|p#41gO)kXY+td5mI${&48|hF)~&fsP(`=-uT4PtdCsqiqr&WQ>mD zD(dZ@;S=q1v2~maq0S-cUC|8fQ;OWzQ)|hCU-j zFk_tx{l(~_IKoI%I9HJN5szp`91B+nz3ki~5OV-`Jn*x{SZzp|;`AmB!>`ncRET!S z#L7Af^eQ8%6lW2v9I8K!L8M8^GI*klWQuGV7T?%^>?ukmwB{ZMJ?REo7YFEr#UP$( z8VNX&q(TA#Mh|3W2I`#Xae~;uvtN1eOL&VfXbUJ=@b^zJgB+QqLuqSojGiZc{wE8d078&fIO*z9q5htXt4E6js#zS%jH9Q`&`F?*4FjfJ^U?KhSg5DANfHmO? zkBkV5cf$Qy54IoYLwaq9x{yAQYLGe@C^&#?^x9$Nv?TV$DU2Bb9Dh6~15cSDaUgkc zk8mReAU!fCY}nJ(hIBx*1e7KW-7~cKyHvtJf&K?bsecBEbT7%g_%m3rmpJQ)AA|f+ zM5yJ>XEJMSbh^l6T$r;A_5 z8qqOX3^ANkvi~>^^2ZWmdEkhmlw#;L9PSe9X_N5z1i5&{GBHv(V6lp$MRa29H`2Z= zoTyvjDg|p|Miu!bMlHq@V2n$FzRtlwPr;Bk0&0YPPhLDa0O7VA+8NLeOz!l#bM(?3co4e> z5)5k|oZYDF5 zRI;%k*qvtNL->(b53~2$&~w>#*hpBxQjnA0GdeVCm+0*+jRoBMLoURe6M~+FvKSz< z4p-E;@*hgc=7b!P*CSo*yih;8Uhu=HU3aR4(L_nOFTgPaXOorM;doF=|ld&ZJ)?~ z^?!^yo0vsHDRr3S^iI7i<97o4Q*cNIpB&Q%wWQXc=L8Y>Q*hTUqc27ufpSUU11{QG zrXvd&b&iDpy#Rz1IIJoPj(CU|%{+iqK19QSTilJqGcjS43D4N^8=H)&Sk68L+?Yj2 zm0=Q)Q$#`}4TCMbQXBwn25~dsT_ZpOZy5SUubF1njw+HJ0MRpfqrg0p7z$CM^mvGpWd=pPse02O2RQF9kpMzNBGcmN-{|-;^lwD+So#-U5YxZmVWa6^ zejJDV^5W^=xX5t&H!(7eq$ecPzp1<=@*73oXGJ8C`XeI9Z(39${X98|)DxLN+KEg{ zrPCn*2K_5OAg zg~^NUNy-LEo+h6+N~U5R-oT-7H-w3`PfirT7$3~etavMU&JH;(LQ?X;ybF(kD@)v`zz8^<<5N+_xx)d?z7Uut5jiNX0NLGggo1pUC{dJxGDX!jfnT^*gs(Du zRp8qgzN+wTqDoOs)u3LuZU$d9_^QLVEqpcLs|DZY@NEI#uJG*wUv2odgs%>KTj3Y# z(1qVN@NEZQL-@8eq^S1r+X24%@HK$1668~YUj<5$YD6hf%9IKXXvenSYeptbR3Eafc{AmMQCAkL%M^9PM{Mf**Hh=ASpvYI!o1~+2_F$^n)WC^8 zF~c04!F{*0 z;PJg)-49jk&vzSmBK@pZvzZnnno%#3J_k0N*^N45-g5d>gK7H|4BCA;G-;mIysbLZ z9Ab3$wz|{ETWiT$L}ql&vM;_dl2uz1_@ZnuV}?VV};`atQbHwl|Qe(YXzKKyD>+n_pbhqhG8`&-YJ?|QL)t>;3M1J?$c_bDxi>)Wa3-T>&ZEj_{|9iB#SImU@19wmh z7A(DOmRFORrMY&?r@$L3MURdv|EtqVX|?&sEf)4+$~_;9SjvfgsHAtsY4n|e3gyBD z|KxVCJnb;?*z)p{Qe)R|7lxNOzdSJDbor}gb;II6&%3bIYPrdYJs}r|8z0|c9GGNY zv6Qd=?#z+v`g7ad+eDR}7X zgst81;K_kYi&wvn(>k<)&*S-Ra@iMlGd(Wf{>10?drTkHXeqr9{MYwFr*0jFbv`S& zZe>*D!3n@Z1}+;%BL zVUEvNFTLVL@6sa1tq3*$u*}5ag?VRH*~-D2+vb7SE^IK5^tH>GwJ2%#^)ZkyEHJVi9*@ZsuLaa-7meGr>y$@-*ZlW zSznXJzD`HV zSiNVyil$}z#<>NSY0XrX)!)7JdUtDjNzbE!VKdW>M^*Z5Zxd9r?9+s~=|?Qq&2Fo( zy>&0ErCsz6y;@b>`+bnr2Z3L=76!XlZF*xfZ~I>X@4E8L6ZdcN7mVJk?pdq*`1YpM zA>M957Jh9OavHrEd#lsHOD#|8P8c+0;Q`~Uv+KhtpI%lf+za|}IV*ZmoAIM{qDB-gSiOAq@V*b)f3B_UP^jEuWb1=& zwTgwwtD9cw&a*GBXj#xDMeudTT957BGatL`b-w4Q8dh31ef8j$;VIjS#&Tx(u4q%6 zrnT%$2hCSu`!p4XPwYG4#>I!4Ynu&y79Qi37`3x{wCdXr)kh61<}c6H2^sqO1m{4% z`TFm61#$P*H8aZSe>WkdlZn&Js<9QP%f@e>m7tV$KK0brrD`|Z+IJi2CiuMX^Fvz~ zzWRz~ss82Lm5qBWF**2`w&Pb_V{gr6PcK~ivOerp`F5q9HcdQ2BlrDXQ?7I^_(tr= zg^QYoK3j6G)%dYK#?({CeNUoqDEqmLxwu#8Z=^Y-&cxxsV5!Cw3pNpE_%JscO%%`+YQ84z1f6snU7)wH zrtJ%^duq`8;@G>{g>|QRZCV?rdcV3kqSUa>(Tn@GD&Bpq>1}cJAC-s~v-a#PH;4|K z_r`0~&>L-x53b2LIU#5CrW;*j8_)l|wwDS2YqKP~_h0q5TvmxIj$CDUzW0t5$_eq= zyI)d{-vhAHoqgvU zXOA;AEW9|Wk`jJ9d1_&9ix2si=I?lCbu{zn4Yx?sZRB={vjxHL1c>c|th56I= zUhH+_)56^5S{9q+x$b$o>L+1h>!*10W>S=`g} zu<`Q;GZ#(RbHHd^nA!5^ue%0#PC1u9o0C3V>r{vQ&WqwymOFlp*|ab9^;&)-{x|QX z1HW~-aJuZ4O38iQi`6R6Z&vEJ{I;d}j6Ek(cLWr#)7=r8QMc}Ml--1TLr4F0dEA=J zqu;eU>T0y=VLfIJYdxZ}O^tJZ&YQxe zBWM5H`pn4%uUZzjhz;1SyzyX`DuQD|Mi1#tIk#7$k zd@}lr-jXI}wZ?-QHD0h{+(xsoTaR`>a=X@SlwH?VWdlEZ+%H;js&$~UasTBjihQvH&+?b8U4{(;%$LG2FdgcLN}_2}IYMdhz^JXZ~^JFS+ow7oIs z^XR?2=VdnvjvtN5a5L-J_2aF9Ge$Q#ZE$ay@6h)bJG;$q>XLFRWJSQK_wyb;tZ1YB zuJy%ov!iEj8yr3pe0!4d)WyZ4&z~$7yqK17rqc_T@~8dOCq}AN?&}yxIUOEQo~s&q zsOKu3&(l8Nx^wNK;V`OHaPHHgDR*4BJ>~_4zgl?xV$0|iFX#0zJ{Fa35}UmLromPF z`)hW(IJ!EO^;%vq;6U%%QO_vd!8oCbgST)o|CrD*w)>zt>`#i%{eeRc3?{N6npa~ zYrGzeEpQvEy8335`z00Y-*#3hsmk~kb5MC{9ktnMQi8VfjPCQB>OShaMBu$PcEGM_ zEjGoRK9c#U`;0A}*KJ+tcJXs|>gU0_;TyHCn>}cwaKN|2;u}tVPL4ZxVBg@i4wI_x z9rW$>NP}v+>D->z<2(G-aq^0tS8iFqA2fXUZ4;*#+zCUYD^8TIpO=4|yDHFRr23S! z4rK$5_72#;UGVzNIfcrpG5#}7#lERKp$t55kmbW(F`st!>oePMQfbEKPe)=u&UOsd zu*tn;dnjOi{{E0s1-PuQ#DNpa~Sl~BoaMbb35j$FUta|X#KxM?qfK^Zq%+rPQDlda!GeMx#z;E-Q)AiX4~ zOJZD^%7G0hC%pa|mr-9~fsW;kZB^;D9a@Y}dT#nO?%VL`sfxv& z=O-TS9X_K^mhG9%o3dJ*uR6c)NWhl0rT#-ZO}x6d*X#1^g(IJSem_qu-0(!|k;6yB zr@FM({!p`XaI1lDl3K4=VO4o{i1)qO&LI;vElHU3*9pDZdA7ZtZ?(uA9aE9K!6&-s zd8cG(C`zizJe}Y^{MzvuJ2e;H zx5&-2xiDepR^u&7agi-Dlph$)o=`D)YS5wMUd7pUU46#)k5;x$d#e?^x7N^pbl9Bc zEv6X=7oBy}D_Rv;^1g>{^J{m<+aJ1h$JE|(U+{^8mfA;VUbr!OAZ0tS=h@I*)8=HK znszScr1GLPyB8n&{N2-F>fF^iet80q>dMHPTX&M@t?6+8&5;%ltfuL$duLfDSh+A~ z^_~tL1KWOXt@Yh6);>j8-uHl#(gySIURfDwod&wzd2}S^>Ye-+R(_e?V*>x))VCtT z@!2ZDkgL(RzLvILlr{d@`nDrJ=r(D$u5IFlFTF-YY+XHR_CFH}-B*;EZ8R(ok2vsl z$k=tKTIZgkuD4#@+26ya^Ky;q$>)s+=x3~b?Qo{L^TF*}2X$_|8+C{?eqN{d*8h}^ zxZmD#uK)SrPbU52cxv&$9EVM99}WNO>VPS4K7Mp~+-lBCKS!VbMf%f)%e?+niqC{!n(>^0l@_ z&q0HxZq1x%@L0LS3X6nIFtM~7ib6qWGh~aeq zOAcK_pIRMjd7yYq_ILH~)lWb4eU@ zZr^^_vW3m-U4g^4v@<-r$^T{3o6oDgZl14M_$6}R;%mD)XQ$tMcc;418voAgIsSXk zT@JTfpqI7DCFPrBeSo(`{306=n7xc$^Al&+Ny1{8UM7^1;?F-g7R;cKT;3AbJ${~ z+OX?anx;5pDVyb4xg1{+X@*pq9J2SypjrExPruxE?|W;`y1r@4U5AY?96oqi=$4$4y$=m8>sMO6 zuKBdJPPO~@%O37e`@d00a^Emab;Pny%Bt&HI(*4loxw9%W>(^IzxNRVzyoynC3F8df|+#!@h?cAM<(L{>imHG%7D|Nygxgl(&wG z%9;_1e~!2{%G|6(*s@9K0a94FF1EetCXf@VUBAjDxB9X-o%M2T4?`4?bNj`#%oG6 z7jb8eaOm{LwV(d5V}Hlp*SEMInBr%mwCes$VRmND>)yGMy=n$bq*^{-S2}EP>&5Su z*_&TmJ*;=ENzpWF$h-W$OAmisXZj$zc1GNmwS`xl!)EmEx$~c%?}xwYcKU3OeQSEG z2>rM9?YQ-kSIXwZwVL))ts=y|w$}1epIJNhuQ?Q!^SRN`tnf&SC4D{&xp#EMSX`s)9)0YxpdjS&&w#azSJ^r?PkL)qURsxZ6CVM^S;f@m%a*z+bG;k zwnpL@_G zt>cwx+I>3q9K5!Cuc39Wa9idsz1l~~H@>gh9XM;6`?1*PZf*PI&#TxIelLA{nb*Ml z@!L~k|C;;mZ`HkN5q>vrj*VMzw)E)rr+f5T+1xx3kbX95;K>f#=ghX6Jgnul^=s{? ze!T81Gpx9Q&?)t9JLYLDToa zE2n;bIcBzPuPZ6{$F}May!-IxmhNqPOq>)K_ipF3@mCkm*#rf|a+_hkKHF%x9IiNfOE0*a^b3k6;oA= zn`FKIICE>wDNct&yg-YI4;SsfG$2xM<+y(zKU*?rNtnYCtFBWn)RgiI%yx9>F`@au zos;9Nsut;=){GK<+c`P*;82ym2lVm+Qubc@`QPqU@!jv|Us-+S@Q9SD6E~@L`L|@BM^tV83C(0!{6&{+y?Dgq;tM;h~qFTDC zyg#ng<74!jm5;h8Zg6*-pr=?gHYMI^Db=sZ<}Li1sHRu%U%l-zZfeS$UTSTOyDfH5 zC}~}_$X44t=g3>#@=M*P27lQ@J+Sf25{(DHt{M~72=N2;ry8+Cao^;)Y^r}u|c!4=PU>65OQ;mNp7XZLjwaX)v`TDL-Y;1`3~`VWv*#FvvoIElWG1o%V2iVZTOB z1^P)t?iftSUbN7!ub(X`byweWeU)Crj_I~lERm-=UL_wT^Z0(Zy8{L5ww|=q{X67TjLTVd-FwqsHg>P;@Hy0K7T@5*$t=aoi--ED1qXe} zzdL+sXulQC2T$p*ezSIq*TOHWoU^|)SKMtj{8sdV?-`BFrd3>Mf3sgjW38x#O2)x& zR|i~aqdMV2Slg9ZRI7VC4rQ!SzC2BN__rpmqn0av4{hIk-I;MVxrT4YRt7)2VPI3D zFn{!j{GCHG?%uj__4QrF<)=fY9&5dM+ndoH?W%Vrtb7xEjJmdY%dKyFdet<#r!qZl z??pW-`s0GMaE~_1iatqqy5yc8pxe0YwZ&^+1C8n3ueTi2%qdPWW$|*2W(R#X6)d-P z%HFV3yTkD@YJCkax@apj-8Hd~)A;QRRT@q4-0`f&=H5B0e4mxwb(%lwR;K6SF;1;! zlxCN^dcG6;TO?Oh@pBXxjVfE)*X8ZIzdcRuP9Y$c3&nm&sX}8{dxUI*N7_TM*TO;zxr|9&HFe0?iWAB>SIb5!!<*qk_~fb9K1DZ zQ;TKJdpE9{Bzk{}XS9=;`o#W*Sh7j_gT~M{P?2;Aahnpfib{od!DyY0mW0k=_k!oY zGuGQ!0PRnRg(2E!$>v~Bhd@i5D5yy`4_b)h*%@e46HmYOMt>>sGz!X&1#24GyaoOu zlo-n$E%DG-jkRb)n9$b*E$CVA2nz1d>IQvs$hjTZH-rb@I}^)5tOu=`lfe57Ya9)C z$ygojXORJK)`_nH*3bGBI!eJA4<=i-egnW+FNuSJeX)ERIE^QzNT$+WopE6Ko;W%& zDLs*RltbRQBrpbv3ZoC_VXncX1(WLY5dT-Sl^`*mMCK#ONvYuF1}0*n`+5*eO#7Ib zTUc84wGIo9h>VIxn8e@U`_VljxE%w1MoZ14#3+oH92^!2(V2tO6XJrSz(j(V8Vv4Z zU;-4J5SEw>5!8($k})zpu^z>GF-AQbWuL(|jvso7kT%dZ7{?j!(&29!JY_7b7#jd? z8qY0}2XQOF^Nm;?f&B}e<`c!knDnB=Xn;K)$|Ggr2WbK+J|3<|!|zyV0j(J#>*)$% zW$eRT04B6Zq-aZawC%!r*pa5{EyU3K3Z3%MJ2??3gil+7VQw<7(B?ivPCB7Nq%(4g z0a|DiUu4Fkhk_aq2KFA|ix$;O?9|x#%0i5`qRia(0JvpmA%F`udT3>jwr)5lqM_#A zaK0e+0j=}VJEFH(J!F<(IrQ0xhtYJW^Ag|dgs@~|IF&?#kUP3Z!k9by&Db#~=T(S?WJYs1LeW8#ipnWb6C=NNbGyFwsT`Z3uaULHE7(x1EVglgv z&JrBW2TG&=QfGicoYSFKE<;s>?*xn5L;T{$2^g8c@cNZvxcY zgSOlSTf())yR1&mv`#kLVZ34S3GUDMCWOIEOpJ;rTokxExaZS6R1%BqEGIrbgpbOO z0P+AyS;$CNhF>xFSU>u1Gn~?m<_D58(i!@VzVJw|q&&+BCGY)#GoUmkV}rJ+(z2AC z=OZagnUN)01euWpJ_3~+&54oz#8b)0;EYLyR?v$YeXQ^!Im7LN9vFWI^kZW61#xc8 z_K5ICdAywTRlF2|)g7=y`bl^>S~pAca;#sRm%9UQ7~pMvDUbe7y=f1qzED4&$A-Ta zaCRG>%!X&MVGca$676WM;IAoVPN$kfY9B~9hju zd$jSFr_KL--7imOFtR&)=J2Bvr!DGR@>+G#mGN5N8=QZ%>Ws*|Gc9G=K2pvKZWq6@0?mhkEHNT(s_yHS@0yV-0sUSeDUo=q-%!u+%6b=@u_~ z-hNdxPwUT>hnG>K{cj<*a329#DYov9pJ4# zqtBxOU1w}CsHB2CiEo(XxJa&7P#3nR+eM!}s6&%ppG`(Kk@5W&G&a{RyN} zU+}lH2hL&vJOw}Ekq?kR;0_!{D#4G3Z|^{EfFDGUAh8-Sja;E`CGJl!pUGZ6zD~aT zxXP0**Ir*%;u%?ccI#ae1$a!Klp2;CXOtXC4#D+z@usvWY7V$&7^R>_V;G(Sn_6>P zQB)=57p0k)kYp;OHAQuUikNgWQTl3KiYjhapFVD!C_T~;d_b@sM;|}Kp^o+lVJxKe zV$=LFZGmLI;h45WBF&91yFw}r6IV;7(Ph^|S_Q%r6CD=`h{=ZICiNh%QA}JI5AIjP zy&V8S`T==iNs9<#`UQ_Etr74?gH1ETG+6FVX7ipzoPaqe;-Ug0O{y2ES7GK>4lJfw7)`q`Z!3NuuFmRW5;dWxN(u; zxQSZ29{@xcc~KcW!^k)+UwS}+@`gxLBrQJK#I&9g;0Vf&eM~}=Q{t?^H%mj2s{SCB z&rBkpnMo*#r=64-PYV()rAAaK_#4&NYyRW>73z(sIfxG$Hh{xYGQUM=?AY)W@Js_2 zOoThRc_S(rWK?~AYl-|808di9D0fB6M$}||CT{|U?xIGTK^o93DW5@A3~EH3gmiL0 zHWKr!84PLl_!>t~qi~N#l!iLsn}%~7-Ph#dN>t@VRVEFGfEwCeo!SQ!XG9Z%A#Q(A zYT4>kA@(sc4yePB9@h)g)F}=;6Qv<3Q7<9wn^Jw6Ii^+4RHyRW)Thx*VaY~yN>#Z& z4Mqv*YMVNhJOR?8LA=L)u4hA9?UNS=R$w6 zGLVK7u@utsnQ{aiYVrWFe2|9uvLVe@EFTVFA*5|)+CZ?q0oMpK4ttoP1!SQX1c>S~ zF#+`%cpBViBW;j8G;Qb&*PyhqZjwgRh6$vJ)kV`r@kkA-yi_=Cbe3F zDur2Zl#-effyjYRX%kIq$x?GBjc%6%>C!Udj#*{fwwLnTctzj1ur_$ec`VC(Vqx-V zRi?!$P{WEYz$dmE@1xm!YB1afu=iSc?_7UhSqdW-%fUp``b4Zq^f~0zUqh=BJr-k4 zFq4{8rbD*){0U$$)()S)jAbAp6~uaD>h=26%ClJ2NK8CgpU5-@zp=^qXk-1O%6%|+ zv6C@zZhfLyeqo)z@a3rQu}iwEYsFT#X`~go22tak^|G&TK;W7MeKfR8xu4Ab_Riy0 zN3O$1f~d+h1tuC={qYY^{i7X-AVo?u$7zuQRl@y-SKhomHJq z-+3BZIfa_pK9Cexr}KC&xwVGdQSh&hujXBsu2iSPgM7kjs4b^fGrJu;#lp6b=v$|w zG(G8FRk2Kqva z7FTUFwCZ&BL8SujV}$MXLIRAhu-rE=fCfv))|UWU1kb$1iWNe!oI;+muv`%GSP*hF z=eB0{PRJuXpEpEdhJt-|A^&sFbM|Jn02ItFO32lPCUVYU7Jsdr%e+ZKuC~od&8d}; zVs;jr-w#*)0scvv)3(B;z@sqdtmgD1aCr#2HA(ocgj-A_yH1dKN8n!};9d~$O9dWh zu<%sKmUEV;Iio}NZC;bIP`SeDb6 zP|K>MG_#LF-mFRm&753FoWa#HJ3HOE8z4pCtOdvtIBN^JdID!%A(ta?)-x+CaW+Ie zM%#GyNDcH26ndJ^2uz zM7>U5Z9H}P#WoZ5_$T%%R2|dY_PMI;!i6;;IJ5$?KGpF!Fg!V)(71P;nkLztOLPt*5gnhHM)8w-aj3Exc~uMX&~SpYTJ zDG3`3DEQjJB+QCYqUv-w{u)}tgdXq3#_udZTB4k9tD!a0oPu$PURMCuqZ$v7URMei z(d#PdzZ5X80?bvSybu1u-hq}t=K@>_)X(5woyYWb1%3UEzWzjCYePYSx)%Hup(Cra zJKRuNoxSlV;5gn@qQbZiuV}=K>Q>og3~)w7Nl2y z(F+u2am%AjC@q^3UXz?;JROd{slXLNRE1nM0e3qx6mC9BsRH45LFPWWQbc#10`-xr{TU$F%;^L- zFlB}3D+lWU_XaLsfGpk_l1sRSh5)*dt0iz$%HtM-q}=Qcj4P``$-9ofz0M58+Z-Y_ z^dP%1vjSSQK8S*nuaPwyiK;GZHs03NaUL7Y;U*O!xXSu@9kZbc-__?@l! z`86QLJ_E9sH{^6wvlVeh!7r3W4?)6iV{*v%t*> z--4;6Dm)huDDe13qwFw}(s5N-Y!gx6B*z=5sUK7{N-xyfMl)v!U1#2yUVs{bqpHAB zP2dP<(iS-C3T*PmD{X*}(7qd{4AvDJ1yYeEUD^&v?<|lW8Bhs&K0*^U0%21Gq?`eb zx5dVZ1_2aZ*&au$TBwd0ZO%iUv5-dt@`M5f0YyvA7I_pTnMP*+_t<10DoK4wm*K*) z`cet^F$@7vN(KIi^^?_}=B-8gGz6lWz6LH~crmNcL$&f&3+#e`Ux5;{1fC5M`l|^q zR?ce)VuO1J$NdPT%B^)fJTR;Ct>bg*_-GZ;^hyb-2Nf|6P8G_0#xnvDA0B^vn_xxnt|&1Sa_z= ziU3KIXigA3cz$3F6wcJGnk_kdMDhsmpD%-dwco@)J!AN)FcS(i3Hw_nhMrPL_ogXB zz-K7P`L|=r9dPQl7)X4ul+>C(jJ>vfl;fI3!ND}7J7Q4cIyI{Ik$P* zSzqgTnxhm)QNESEU_X*BCiD!(ET)h}dfjIUX;~9-rZ{6=xwvcrww3b_{0fibPKD+H z7rm@cp!~aH)=8=qPpi&~U6kQcBvA5Jc)T1-=OQO6$;E5@l+gEh1qf&iDA^7rf$lYc zO=W=mgC9&0<`zPhsz!NkG#qW9(Ex8|1&EEwMMME)Gn0~yLXXF0|5P^igKj+uDe{(t zu_X5lG=rZKy3cs^ycytGY*H}vR4qeKS`E*K9|@9?2<2@-$TyT7E7b@~smOsDi%*1n zHPmir03>FG^#TE;!N+^;YCBa2;PN_|kkL?vebfQppN&LVcM!2nG>IRrzdJ%hIk)+S zd5&`UzBa@6aiv_f946N7A;Rmx=}rNxNEOk5puC}hqE#bh0Gky?0Zn3(4#`&Azy2ZhQe6` zK*^Yd)fWPf7C5U4oYi0%3u{5{Gz_C4lFKkYN2}(-_`oWc{V?NUA~PONKOGO$ zy$euJW;AdiU$2Bq^E$Z`?$l~_gs#FW8AoUzj!+RiKr&v4m^_UV6j&gLP|${H)nI!a zzW~Q9o~C4eGqD~4k5Bw#!hVVX6@rc?ts)aPfSbiAA$1w@c^(S1OcP6i+zzTjeKfIj zq$~ap5Q}EEJ~YYf$z`{Io9DHw6xcN(Gk)GOp*p$C52AB06v)7zECc@!^f%!x;oBea%-PsB>N0}NZ=g5C!g{)1{U+q9`oadA7VtLy9oRF_7Gz%SS;XfGJ+p>D>l_BCHPt-W;LFH(^oe2(y2JD!Y0R!iGH>+@X895^mEt^sX$g zTnzM%4B_RxhAh%*z-KHrYXvlgib4dedqFZMg0jnt!=+6y^cDsQxubN+dsx!5m%!sO zZ0rdOqlLAZv7C`d# z6wPdR*cE2*pFI$6o(DmJIyYCkJ)g!Ujf z&4u`z^#jt}9`z6`yp=zOeA>4gDi7)vy zb2dQ=KFP-?jcQLS@%>BeaJQHO_`nz z(7@YtxSEa^(0bKEF?84CJ6{Ih?hWgEVpEJ&1_BWZV6unlnJfq?#SJN(M7XbYRKPEW z-7Qc+xbVLM*@A}}kYYA!q(g*du#x2h@0{Q%D9Ukp`3Save?d4gUXWQ1Qwhr02~vrZwtk6JCMfyJZu5ES49GggHWEGlE`h)N1=NgE#1fW;Onwp19U z74^iR(uX0m$o+qRd!L&(%zyIv;JIZpbY&v&}TlJhad6Y=yyh>=mP?d`sCSk{O*u7f%!lj zn68ibW|LUWC=Oc$pxA9D#-$(JL0dwk?6*j*>HQ$zZq2ddZU0@`-uBDxv%8C)p8P-c z=N<3W()NBEkWT}2R&;YA5~JIObEbDe+2x6WIzT!WHoW&bF}nXYcZyJZG&lqQ{82sk zS1V6U)0)|N{@b5O1Dfn?VI0NMJ6my_V>xI7oy(RNM4eyZ=-paz1+ilcL!V`$aWh3~ zsknmG%NT#vF?Lgs7RTfA(I5m^;tA{*u9!_2D23BXX1#N zZ(@#yxn>g6@A&?V2=BM<`p4-j3ub+!Cbo7z$0Ln`XSz|~O%Hn;Zqk*sCz@JE`W9yg z!PhW8zHu2zZinGGqp7c`Kwr7Vd3?k8REm5nXpK%lswy&s7&`qMk{}m3rxbTD@knv& zz1_WNu-P`|O{O~bJo%B8Gsl{RZ{~QddaaK`MxF$6kzf*EGa9W4@gOYlY<5}T+3d2w z7nlWpcuQ5T61Og(zscv*ZC?wqG=rZdz3?-6;ym(pPQxF1_1Rp?Tk$UZY7srCAJqrH z5=VtxI)heZO>o~Q3}&sqv(O$mN4L!=@OFMM%{rOvxGH|Hx0CIA^oiX@Q1zGfj6+os ztxd-w!+T?|JBS5o3Vl*kY4e1)*-_kok#|u`POfsWOK59rsmf7sKh%ZumX@mF7v!*b zt%XJYpVoiZC`wTyc>*bEX>)0N9VdF#lqRuXo1X4FDJu+EYj>zwV zbn?6s&BUb-C{|Gq62zB~4jNQ*@5AJ2`aI4HxC-Xw5Y_ z+x7-etR56;J7W8Hykq4FEva@pv&T&pkHrUP^lTx&{*>aP+R`K58?&o}Js&rt&!Y;%Ow~9JA)4{M)N*Nk58yosbZaMr(R9J4n@py(4bj(^})ZKl{$X+QPK%~=thvbX&$9Mw5pH8Q?O{JBBxlR$cfyWp6+ zAP8pT_7Z{D!92Vz)-fiM?^kZ8f)#WVEf8>wHDa%@c`(f(4wj`tftCCH%01Pw%Q+$Q zE740iRP8P}OmjK(2Oz8eAV5f8C1BYcjClNnBA^Lt$XtI(ZDy-s`F54RlN_;4rU6^R z21rI$e@RV!wqLoW8nNKfuyC^OgrN!yIsDfVj02h&v1rmp6-jE1*Wda%)TFUJJxMe&vn~5RbwoSEFas1;oEX z3A_bInW%$7bV0BzL9;y zpSHuL?Nx2B8~DwdmAtznlDzv&q{e%5ddFQrwTqA$*&Q&mR-6pxR_t>WODhL zNYwcOu|_K+9Dq^GPw$P=w6}{D46#FH$I7#&oRmk(m1oIH7rtcNi~{cajT^#>`!mK3 zvBUidDrgDWGUz{qlB6S2`L>%y<_nmgyE$sk)p95hw*A#YNWkeqC?l3o4iY#L zIi<~-%N5ez>HB9&(0Ny%_3J$RZNHp?#L}hh+6f%fw(dA5j-16HQa$4i$Smg&x3%<9 zGfhXM|Hi0E4JmOUtG+1USGAWS>+)j+-owFRKEe^SD%rw>GSZXaXSDZOi_wR3K27HH z9ii2#@ZL;~4mU&R-SuK}S_}tD58#TL@ypdO z_}L#2?y@l)o8u4w4vt(RU7$y80>bI)c3LYcL>4I~w<>nHgQg z#7vyj2kR!TtlBrNuCC#a1^8=Pw%Bp|zDf$NB4M8rqRs>WEh_yziaFnaOj9~gLXv;a z)YBgacS{+uW|({qD-2*-vtd$vNBlPpG@UY{8Y;UNO5-}}68MyQgym*}WIWO2w{e!X zw+O$;yr#i#-CxOE+qS(!-{(E;0=(%<>pb{hFKr1&R^TDdwJP zEl!DCwpcwu7fnUU-Fh7Z*)`8H_*8Ul@BK?NB;`E&mxf2)1&vO-O*{B?o5sqAwxM&c z9Ess><6;w1=sI!ZC~}>p#!>7#%W$+fkMpI?Al?>S8dGTB`pvkRpUz%>U1t;D)y|82 z`$fvVbiM3-d*PO%sbP>hjn?y!zcRx+q47%CDZ@=g=uOo58R^r*HUpvPw!N;uF05<2 zscVD2@N@jZdpxXhQWG^!`#?#yzy_;kp$xe<`2JgVJM$A_JV&tDT#>jSxtC1x*im<# zhjDvN!hpJDdSdj;l{5g?9nn?g#?|y2qQ)iieCH^RFg?>|H2K_yt$ce-9u=p_bJR|r zUrQ#JLqXmz{8`!NJhsluO728Iw;BE1UmQH`e>Tf|POMPm)N8KOY)ak3*Lmr_Xmr&L zWYw-{)rWC(6aN@~<*>V6Dc$v}l^)sH&&&vki}?u){7O($y0wqucGu6dX;wdpZ#ywx z@=W7BUqzH2f$BD`QDOdCeH$0*+fbsfGoP;tT|`#+;H#tC-cyG{?-h0K#q`9MliZbU zp)qsX)V8fk{ZUevHrKgXwr&e!&oO;N2k2u&dtv*9QELD1S+495x_*iNi!+VF0dT}?)P(Y0aQzjgxE^g6JtnkJNx(V6oM$I)iG3K3S+*EQTo0Q}|XvE=pMn$-d zhAcF0BHRiQd_x>MOUv!AwD`~!O(G$%rf6ca6M*SAhrq!Q0kuifAL8&a`tCKT0!=G4 z-tDeit@#~&v@($PofT2%&v+I57k&|uvra{wGYTW0er*@ijiPhu#--*PH{ZqPdoN!$ zIE|t|HR(nXjM`8MY1n+IIy}dbc(j);dA|g31GV+p0UN=>&u<`xWvR%jyZa3yLff_0 z_>CF>(b`4)x{Wb?oeF&$rs(UB=d1pG`8)J!U;NVOwsCdvH5b*nHzl9TW-?Cu*yOfm zrC3OcQs{LZJN9&R^*`e^+S=Xex1EO;L0YRI4#{SCg^tUk500TptrdLiNMDS`4$+KH z@`Zdik>5HOA8Y19K;k+AR_n}n0M%2b7ruHCoOz#yVrh+Uz5ghJ@iv%Z2C{V=CB!QJ zo}G`>l2Td*YOPRw>p>J#t$gM6zfthZc)gI`8_kzJAmZ-mwv(-&rHH=kWksL$@=&k! z@)%q_e0JBZ5ARLax8gqJejDg@i?f)oI@99p$3?UH=e-Vnn^}2wK-9_7YV$&H89%J6 zWYHM>o>(pR2k#;7A0<|W77*t+?Z_XffB1p;o0&)i@^}<)n8Q$kNCbSW1;G` zM!81X<~14EyyD+Syb82y*vkjsaU0gE@_q3uqT5n4UcxQPnyREw=vp*29!GTBU=t{} z2`p8W&Hm@J2fX7p3Aif_prfl66T#|OwDPp&yWWd`y9DiZZfb@aIMKEz6aVhFh*#2) zJN-t}fzdO)cbWTyPq0hi>p0z}739?%=)h-T+@K!0>ocGgJLoowA$FbB`Zlc5*H7^k zXunU!^Ut;luuMwqbSos^zbe9Fsd5ACxStXkE8w!~&b_jyU-Y*zL zQ!A9I2j(zZCR@9ssn--HMy6P6( ze$LJ8%o{fl5Tp@#vOx4p&u%AeUmdYy=!pIPT1(IJmM&o1mW zKa(el&V4@Uz1pc^EP-?Xlkgy2qxXt`R`|d^68$%SYIcUbsyyJ%J!BcHXGv=qt0!>u zW~`*p!PJ?cU1lw+Th9ldp-f3O5V4US^+P|W5^55uuIUsZ>4KEeR_2aWH;s^ff%tP3 z()YyA?5{KMSc|Aa*l_{C8)go6-wCyaCly+4;W<>S(N92TASMeA zm!>&O;#5`P^zKcvn$c^;Aq*`hp-J%##rzct_e)lgjfUlz@UVoS%MZDg2mHm^ZG(JC znqkno?w>u!{j8O$C3l)OQ|f^Bnly5!#L?h^i54N# zi9_DI(Pciv$lt7;|lVc!{0bkfa7k~Ir{z?CF^JR&P|L7 zrav#jLV4-#4TXOq3~VS*(8h}>03w+qA%7agSbnrNID}x8siKKJWy#sr&k)nK6m{V{ zd*^-;;e8ZYV614G~D(qI3^rkX(&-h?gY0y<~%nG*?WAK zsLb}~8@M?`SiON?Z?}%A%~i_>@jk^sere>(Bj5G&Zh)>wAIck?+857Vom-LoYgXdV zo=rKQl+OWtWJDBmkBXzR?`k}H+qTu${#EWK>C?0O&Ke2weK#9UmV17 z1s~yK6BdPN))S<*YT`n32c@giUZASqJdG6x+&1?yt&EwTXMoN z02GNY_h-BvoZ)&AK>Td-+T#RffrfV`t}h$IMgIK6EgO&WLu^5H4>`R%M&a(5!{)2P z5Kfowdul(UeKPvfA>IM}Qx(j%J9G*GEd%q*=plbC10$WT;kck6gcWv%1!FJD$A||x zG(JlEtb*L-JD!opUsP-)T9=Uz5+A%%(Wax z(+f1Xl`?d7(F9jKs>rt2ylAo|2Y8`f6>18(GmHGHT*x8vy2`E9^;xrOV%0w%4F29r z>E1_Me*{^!P^?G~dl)kFsHltxX-da-HYzK46xlzuF0=mZV5apCw*H(aHI~6w_>ib} zqXs3pH}_Hf_Rzz+y7Ma4;3?UWKFV2_5s1*xZ7;&g=N{gdv1SV~@W2WMJ^=-`6*MEdf zjqBv#*0TF^iUPTizLbU1mvL;15j@VECg}?)zD5eKNo9&d%(nGX|u{ zxF)~ebQuuNr%=~lsISu@;5DAnx8ZH&19J{f1cWaMgg1pCECYVXu%_J-3b39aMFxbn zzS1K|l~w5;qRf{1d)fx<#&<4=^+c$7rU~=a1S4gCoty@tUd7Q5Lam_r8X7U^7NP!` zgc*do3%A>JOr_DL1io`3)EvQ~VV=H?fg0hT(APPx%%IDaWIjJaovG-8hCwLR>ou4b zQu_sJixCK`y-grD8zx6nt+2jQt=o81 z--biV2SQCI-}w>h{iNtZDAm`AP#+y|rGw9@z`TXc~4=FORFzBRuy#~`lYX2P3&#Ig5uq`2Zx`#pUN$R(Rr2aNy zLd=+g^Z!EX1;uJLyNZfU#nBHGmxfU6qVlabbwTleaJx-gR2uzw3*R}R zSYed>soWk@b2NF~#_lG&Rk^#Se+r1rlO z?GAe+M5kX-Tz5*}-nkHB52_bFji6C2&O%BPKiG?R_&LQIeEJa%f8u*WeEJK%48E+x z-5Z}&W+r}_;w?V8X6fR~rmquMX8Kr5=JVs&7*b^B zo53;F>our_{=958;AS;v*yACZ-HR_cLB}*mj%XL;45u@wuqLz z^;pY5{T2hjjmq$7F}{scT+wZ&w7N%2@NBqa+(r4{8*hRK&cj{z z=uLR)-1ptUkKNmu-Bm`ocqBfekL1{F@%~m|ws^aP0G*cLLwq(G3f~-G&~4;(_R=y? z5wtk6(M;Or_~m_4D8i&L@a`{#B1{UiTj;MAMVJ&4X*2qLYf*$rVU~0RWPRG92$RC@ z@A@f25lSJ79I}_@FftY)!s=zW7=3LeYO(q~xHj$}8r*R{RtCD*v{IZ#;P+#}PC}O6 zd(qJ(^@eIM%3jy0#Ai}OQ}qyw&g*~+@U-5lr0Ll;rktmB;$aKBz?sMG)v3hRKD&Yz zlr}$^;)hEk&QEaF zIm^uNR;JXvPtQjBi#n^hWHFf0x?=Whyyj-bRAV2lW31>@#a*A+?cRkRW?MT#zgnZE zQHn-FHpwWFLFqF=qvuV{h9$|%%Icl&gG zZfvat#S<=NE~6qEN^m9PK_Es~B?SrR$VT~liATH6vsRv%Pjy{7;J&{J8WW(;V@S!@ z`Q3P&0xBNW*W5q2g)qp&cIM8bhX_<}zNg*{J&Lbo;9YA9mr2;vXPAp6NLLnf0qisjl$jc2^`LmPefBGyvYe2c#%kdOcf7276R!`-x0uj3Smu< zG)%uOnBOHT1EBP&J=AF6jojLB6NOCXJR8Epv7|Kl9 zC<*n210|qNT(MmqG>R&o%*v0=hf%cBOq7p9)Y>A{di|2{+K{nyg^{Z+G1GDiMo7pR zc1*Li+r74^(?pyw(wm_9%tGbdLr6v%H$mw)uI7{cpqvQJ<eyFNWTCSuT|)oNpKJIJ+hDN)`SC2-$ozY6Kz zJ~TJLewlRP$Cz|6?dv2_GV_)GXea2q+SHH9u=i50H&i65v|ZC>gz+y@jrguNzF6oR zXMBtCxnu4P!vu#;`(tpzKW?-ZTHif?ocjUjD*fe%tO$4{6VU?p@#} zTaWZ&;3KgBYr4TNCE!M9onuI&RqZX%31ZU$C=C(}zE$$&6*V|eAk~sW*$4W^V#0x3EII}I(C4#5>-vw=Aahk#9q#{m`*jP`2=f?y*!U^+)-JHREgF z1t|Z97jl-WqT#1@MOgi#&h4fXu&5ec-+WoWYrF>2Kwo$iyytZbQ{ku(U*3gqsI)%oy$Z^NeFG2Lm{C(lX5?8G%Jn*I9wvb&3?S zd_?k3{VUEqs_wlMAEFINwjnA=mM&}&&$q&OGZze$uyeX?#uHn_MU7ZaWI&`Ii#~#4 z@G6fEB=;25#O4rHpHp9i5iuZ~8#EJVZIrjg z>EH|TfGIAZh!yN2Ju~8(Ge4!Q7H2KtO5qLFW*)^>{9c35N>Y=}s*hVrQbzYCfiBWO zH=h4P;&Cq-j+yxpb1&;>^Ld2v@pMuG!tU zSgxaS6aZ@}JOko%qe6X?5sh&(;=}fYkSqs|vNjrA zWtn`1@vR94l9(kiwGW@$xI-zLgoxtSu2icXOs`XY7-g! zH&Mx^g#<+6S9$(shAj9n*e+XW+=Up3xL~Mf=!cuthpEVc_RppPvHWmWh7xHxf@2Zk@BykygS^(t{`vPttY5+91*tz6vO1c)`U0Hy~5HL#07jWzA= z-(=o+HL(vJA01w&Ki(mYo<+quTru}vt##)Y7g$z?ZT>rAmWGkNbRYM~^Qvdfn(a<6 zE=&(Aq0K_`ImD&o#d-B;ENLGOT4naU(bVUNG})wh7B4R9%C=ZVwwIND?gsCRIbPnj z?kauB)0ZYLt-ma`f`Lho-WI%ig`p1MMp0FH>3s)PSf(z4)SFVQYxUZWw%`EY>LyJVRjED%gPg@nBiR_4_Ph4pcK*@H4CL~bM0`J z_YNnRTKIck8oZeDeE%3xXn!stf!Zwn-1@AV@S4s^P4#fb$HsD**>{w_Iyl^Dx|n)} z-XzTp0`BNY<+846tK|3I-O4Jq>2KH8m>@gR^h~zEjp+fsE?YW zN>w>yn4}>^q_JJ0jj3yegYAjSyPyQx95x{079H|e1LxKkadi!iY!-T_vB;m{>U&FN z@1T*Cm|q=Rcn-LCiaaEholJ6L+1x5t$x02mFGGurpQ7sEN&pFN{&)0=cyV;+AM@Lu z&g^S5zxBnjd0fp7Vp+_MyN_8CUSc|7{yM7+?Bk-M@gkL!vACgcv6CAj!{0}diP>KI3>41Ni`7Rt@tQKGiXVb6#V`A(~24ZMaYgO|B$=J*t5RNOug~ID3)LJK)VY zP(I^WG_};Upsoy)F#m#cp zUdCj}tjywTRwZ4}NKGf5=}+oz<#>?^H{+x`_igfeIcxD@TVhhSTX`b9!epzMd&1j^ zU5_l1(C)S+d`U z5x+clcxf{atJr0LHTO5A?MwiK#Fw(%^}LQ#RsPm}f9|D~FUeX4Q|)hker&Dqbvsrj zq@R5ZrFkhLo`bY~o~Fvo(&ApH1EG2SP2?o5Ca6R33R|9$Yov!YGm~Z2hf7CFlU1L^ z^nRGY;5Yc)swqsXdys?#Uo_roymz<{OmC^0^GN8HrETJhx_kmr2m% z^5bx1BWapxbq_J`Kkfv!z4@2jbdrs9r0toWz`$o|%ksQPO=2{&#hSB%cL{A-{rCyc zS7#xY`7`r^hyQ5S&C~}pfU=Trq|c|i7mC8b(Qj&OeqB_WoB4Pt7&StcW%60 zr|!<>lwk0Z%h?PqDL^~7(|V=U^d-AP+T9T=0l#C-+?WWyg^n{X*J#VE?Yb^^b;`y1 zE>vap@ao~ohGFb$teh;p!^Z ziq+O{>2~~Z4Y|xQVX%@4)wAme5ygV8pYg`%;K6%Umgw8#h2<*D6o%D;vCx^IL8Q{D(WB?J0W_BJFQu-EW%qK^477 zg+c53f>`7_dbj!=_Bt;}x+42WXSiJB-BO_#(_q`jr8U9cJkh1;LWp29Iy|F7XJ>`|`@uvK$umZwCKL+cDP} zbsBLdm!IGwNjiZQxeVzyn*`Z@!4{D2O!3pgvqt+6@*}x#`@1f@cryYwx9yl)()N4P zQoD6v6gh$&yg4g@y~?G<-u0Wa6GLl)H5Um24CaW*h=<`&weGkjqVL1K!9#)CisZ3> zxP!x8f}P=ix8+hK8`+zT334?9D&t9I0 zWkue<;0%{bGB4FVs@58DiY-PA$8XjB4p`x1A)iOj*w)8qa45G{H~DG!*Tp2qOOoH; zK;04Fmvm(o8-4x6mXfHNRC7$KsIx%T8Z#FJ77)nmC_jO#Tv|W$6V{xCXN-PmUSCdw zGH7T`0EmXDhyVKvc~_AaKA^85bBV9R{5PNek7V-ud+{Nlk>E&yHNjC} zAVCR?U&J@&LfCTcC%W1mwp)uaK-?I!(3ZN0KCXOMJashre%xS+y=@Qi@Flk@-^=S( zrZ|~Npg8qO2g{~&x)^cKPGg9nQS}TsnOUUmNl4q13~^_5@%s@1lL`fH{Xm-ewyl@w z<>Jq1K;=(1sXvkUC+}(QQSKP&f>>e93&CtU%CM^497K@5CWx@S*b*vQ%S1U)vz`xs z&nbe+n>(k==O?|C0%WkHG-K4+TFA9Ex%-B@-r{=J2%RJp%YHUhnE=L_ZPhsPGG6>q)`M3Gu(=W)K)oUOC1fdoDM zpTJTiS(`A0Gyj&##?1@C;vX4m{>gzU8Vckf;(9Jdiv3;92Cv`K_gSNUN92Dfz3(an z(?nBiDYWfzziMpTzsKf@omrv&{9+Jmt2s__eI16l=1M(_jXePDJl7E`60tYqp46ea z5!jT!5x>B>lRd?9>fNqawpNal(1dpn)R6mfEN^t`xk#iU%p7&T$jm-937RM^hqa_j zeqa1WE|0c+VK^+yj}-KU;gH`AxK2$H8<~%68IONUG0MFphPtHG*YKdvN*qhM(PB@A zSnOBtCEA;0-mq+<1pl_-XjhXJ>z?M|E%|;Bzlw>aj$sx<*mGME_^*R3aUC}@^X-`s zC#a=^KUhMOOR)+%m;>O_sW~4U4e>9 zl#1}Rn3FmUy3w;RL%edS;q{}=zPp*Z71MwZ8y|Ds(K4IiMDdJfiEG$UfqJ-LY0hg~ zpNB^DoT2s8W7~yEDR)Fi_)@fq#8D!0ScVeG$h6LxEm=*~h6 zZACWmYijCw3t+p%0>lQxInrW{%C9R+Y>yA|Uh!va4_3iogzY`wIp{6aSaxIL^0Fm4 zT(|DMPhn=u(BPlCb;fps!v_{PK=O8OW-r`R$E)F(Q zGQy&K0*p-|dkm0zCz41tva?BwnCkvRB;z})T7Ri@!JGD`cHsuPSaK+ zc^j|RsiLm~A}!qdtxN7Ojg9bN?QZtl7+9r=U-aJa@60jwyQo&3!6b2z)u!VFjE*Nh zlKyCq=amqgjhd#sl5IJPpPGCwC%HSPyyL#dlgo<78(2kC z-(qU9x&u!ww#`~n!4TQ@p|vHn){*|L8zr=m(96;2A>B90)k~6)N&ah+Q(cj0((Bee zR_^C<_lr7pYQdV~IQUAwJoZ%>kR9}AeB5Qsi;Qg9c`Unnc1`d*giA;eTHmj=ep&HY z3`|}U{MSi59UwJc4Bsu1eG|KXol?B;83CZWh7p=q9i%wHp&h9sgmHc_h0ys(95TYo z)h4S6tPMuIWltNO`?`nTFp&m`w0)6KKO7d5BlZZg#QH%j=iulz=oH)Olq~l3CHfZXR?h@0A&Tds@y7W_Kf{ zbQY?OS~8{0!8GtRTTzNtRFh(OJuGd!ctj9+GlWwP?ac&USP_D04h6$x#wj{gyqF@Y zgYN=ZV{~_TwZi!?3cN5Zn);27ATsD4FD{HN>kZcL-e$n6vHluuNg|e^Jq7V0R9+tm zDkzG!tJuk5(|sfmf>EWGqt3b92^)1BOAbOQranzQcr+=eV94{aHUp--*0W)F z@W=@u`98o|9X$Foj7I&FaXupFB{h3$%@EPs}Qto0k~k{YLwsdj*NAEMyA2t3A0s=l0C@Gjkpmuk^50?G6uS z00v6^C@&7XIX~CdF$;m99{9|Ks3jh&uWg-5VIq6=Io^R_>tATxVOw_Fw)))G4-?yM zIkEDtSu7f~GMd^&@yIt$`7^WqO~rVyx6|IuDk4)_EPu5DWb#3X9wm*i0GrjAujNxH7JGa?izUQ%7Eafu}p{xxx9_M}` z=MLVm;6i!u=s|-?t3Lp)*LjtPSW2QPG?gRu*WOkC5r4rUEJ)rN-FC39{KfcX=J$no z6zOqv+W>E`cR*M9UaMyZaSCIGu!D4#R^#zd2^;pUGMl)>)S@aTS+3;cUB&;RuBll|@5;~bRj&TNWWFCuOI&^ucP@mu!A zocOQX4s@cJ0Y3H>4#R}?w67qm$7V?SzW3Vi!m$M*Ylt>>7Z+5BY+`h2PsnHq(5C?? z=7M^g37VE=p7SIFI}pQmH%Mli$k(nXX+q8O@joY&TQdM)8LkOTZA@H#7ANnAh)+o2 zG?&v_D)*C1=W&=APaJnEjroNc2bA?z5;6VzH=FmOQhb;cJU;>wF5es8L0fuP*o#o} zqhAO8UM*$KqMg|APB<#LCQw7o*#L*D4Wn=g=638J`-RBAo5F#v*DIU#T6l z73IWhXyI`qu!&dIaB!VhoxUFp#<;{Sl5AbCwBzx?I(5E^@QL0V;@{B}?XM*?udltU z?HBcf?rQs`Y0kFBhEo0+4}E7a?lsw*z0L z9^VN_S6vg+ftBxc$b(jdilB`Feet?K!_~#--b-e&ZV#A3bUckX#bmDy?xQRw`K9)p zyE=B5MYz^%j+wf*dgd@Yx@~9m&er@{p0BzxzF0ugP!ggJ1V6mau5-;xFVQRuEsno& zOvlk|?rZN1A5Ue(V%ovRA|GK(^W#&1!)|HJxi*ZyYXtTE!eQ?M&>*w7vDRkI_Qvce z`|NPWV7Q#gV$IU>=!DQ5cd?>peVfv-XoffV!l^m& z0c>sh+wt^+pQX(@-g_w?#eP;<7G#z?{A?xO+HQz^4l#e{Eg{ywfuK_kqq6jZk#D-! z8&8Yoe5CD~kc&e%By|);AmB)9^5ZvMjP2{ij_O=+k3VBM25MIgM z!rWjBra^0&4D$tN_lE4p_z#^u-(Kuv^FeUP=0twYUQ9&pU-8s=re?G1-HG3CR6|(v zwA3X}Ul-@jTa`9dnZ@o;W}O?Pa+-ZJJAGeS*kA?Qz*&(!WGg6)n2!1na1ZY zrjplid#AkrrToTE*zz?My%$yXC&IENI`3Y#7{*N5PFObf`p)0{yTjrIZd?2ridED9 ziz33}6J_eU7U&YchW;CHT!h76S*^qiQ8)n%xYX}v`wgNz!4swwo z5}!H>AW>+t%X8ZyXnzLznFE>ixPnR0b3OjQ+S9-Nj?VR1bme&Ik=`W!Hc~LF^pa@i z6rhG6NUmKzqA3@sN+4|(ktLmr2&J)({F^dr9Xa2M7^T3j^CUgC_ChdC!+ow7&2!bL zUV;|8^?X|5sJ4gtp+E313;V$9Jn!dt*h@U@y&>KLH4t!)w}-C9BE!c8F@}fc?M-%! zo%(68Ag*vz*_?x&2|Ji5R}-8(Yn%zQT9rlbQYUHGpkTf$x;aTN4I@{*pjp z!-7y1@)!f>J9;|_mPW;dDMY6}Ph8phV&YKJQMyK@V+VSvHwfV{FBDA8!Cai=zC5ao z+}9BRpk)^$&8!Ljhm#f+GmmyAn*@?bH1!2M7Jmzmt?(ZH^0swr2u>3xoKn7b)YS)P?vEj!bi9=1~6Jb1P)c{A34?^H6j(m$YJ zuR%iyS8$;=zS*{5Z@qfMj`ZrX#PH~YHM%g8Q*o2#5bJ1Y#PZNTO1s^koDvt(TCoZ2f3LIn5%#Z`9DX-YaL$5(yWlu;H?` z)+NWzk2*IKKhqqCg=s5D+eMQM{YEX3XP!8EuspJP<_RAN54i=w=b)a5ex3B~I)%A~ zgbqJP_x9H^!0m3lc+^@WB&MwGTM@<}rWm+=ucR^&?3)rD?@x4|9CQ8vHZ63Uo5$m295Pzwn!J` z!&bXFPa7fL2r_ujP4%n0Zw*O3V&pDKfDU$43}7K2UnNDw5&r0^#N++e+gd|0z{y>< zb*%ITQuQiVuz7Chu|We`20Yg?Wu=C@FX52Z_#U!vKbnE;+c>IY8`unRD@4M?5&V|~ z|2bX=IowG>$i2Z2nx4p~7aY zLS!a~Ve3}IR9ge$;pE@466@3mXG%;r=iY( zyTzy!(>l9reny(3PwSA-axoV;i#a)5uhI3@Gyt4>S3QGSev9Am5?nO(N8?copp>r~ zk6M9ezwzk64$rfA>Meh6Bf8rpMZBh55K6@mD0Uil5y* zr{EDB3S-J_jP?Ycy@B>r7;}}4(M+?)X~BjtW?=U`YH#ph7}KWyo4a&9+ff(BuNS77 zap)Oe6~-?oKDL&&^pXs6lS9Y3VvyF5L}!3uvYKF|Ird;-+CmDRboVMt+y_^vKQoH- z_#p?DJbsv$oH>o5u5hasdX-b$szqkbXL%N1UJMHU38bnjFmrz~sAliNnIo!j!@7%u zSHZH32H4D;rCb)4@|C`&j54K+Fr}=flwM68YNCrxw02+i;$Qa`KE1<&;fB6t z9~dDpl$gvI^X*;sPfheF6Rq8s?Vs0RX5)*&*G=?z6a7~WUx+8%q~)Bf2b69M+wfmR z^n%iKQ_5&l%4SMQE*}l~`#A}dGxIqQ*R%%rP^64`2Z9?8gED4fvk6;fFY$Ko>{u$|f`M8AE@>_hwbw*dC~AafC<-Q@kGdcOomuii@_3UivNd^(S9>WHj>=N@hE&s?fQ;hQ+6tLdVV(mE_{r$xo4 z$tIVP7rG_DW^6SV#trD6C9|Ni^L9G-3LIHUF#QeGYd@4upY6+lWHWJ|BIS1Gs*Yf_ ztlOn|6|!tC%@{Mt$OoGH?yoNVU-nnL`ej6r!Q0?4@5?pL!@)MzIl(WFewpu5^F3_7 z>&$nN`OY`rg?w9_V|-~Md8$q5!+iUlGoPn7;@h2jnKoR*HmO&e?;3q8&y-cMvA&mN zSVI%HIVqCepV>uo1!shH~>Yovr;nmA(enY|E>A>FL?R{pkP2EP^sj5+t3OLwQ zBW3xHdVwT(llf_w!w;`Ge0Yl;jjxj=*`zqqUxEjjW298qr&MrtFon|-HXItb6-v4f zzUOgLCm$#wL!NNuff9CXRqa)yvf}UKMuyGkR}HTY26tw5w!t}*>?)G2fGMG<(wBT+ zbp)S(&@{z)m?WH#?=LZXMCnr6XC@AiICkO&6WZ-HIn+972N{-K-z|gNw1-d~5B`p} zK^JF^Sh;f#khG8rp8YYD)2UDobX;C!>wKiE2-g`;WQ%ivFWDG@ROs^3+{(laEEUA$ zsbv&GZO+uoAZUv-Jxpup5et~olSs!6uCoD;0J(vrB3I0zo(UF{z*4dv5e5vYMdb1x z)Ug7~#g*X`z^V7r%kchlkv1(?;76Y4->bW&sHKMu7)}FJ^;Hy7>pO~-Sk7FUL1`mC z#5P@%jqQ_-r`;L^*BKqQdoKgg;>7U@FnUkK--`zYSB0VP&pAaWJQ^v>dvJfme8#|3yY_RQ%j}`$2s+5csD}qL_ac2@Pu!@oXp%XY={U!p^*_ij zoYeg$W&n!uKOn?wQUjAsnon%GH>&d_TE?&E2p813&&zkf`^qsO={=|osJ2i4N~qaB z-K}W5eX0>TH_hQ?v&Mk@JP@Yu^Fe7YnL9)m7=LRGnwp#qG$(Ba)H8$JIubU(Gczb{ zaJ+ShmiVRd8V_F~#?uqrv8w5W$jxwAWyI^n8%tVrxzbf`i?#Xyp~5c0HD=ql%X*35BmNT0-*_t<3~Bot@w~oI$ty6rn$?8m#^om zpWaSkCuquJb|lb{p1jaB>jFcHx!OxA2%4EJjTLy(PiQt^CBjB5qn> zi;IHISu&S}1Vin-H5lFS-kO(}9OM-ux^uA#%b~N$re$Qsb0wbGaiE@V+(HOUr!~qk zWu)L?=XBNwB|r_NPpC0W7wsZ|ph~E1<>}_KkhO79I{k>~P-{^G*I{<)7X+_9kLO zyp63h(LH*0l`Wo4qw;SxQ0$T5EZfTvKVqx<7XLeoEAqds(8Oba6(vc-$ujmq_nDd2CtK54FUsh z(cCo?!r8ZU=*nsHB1OY71+t>NW{CySn+v?|OD~HGbd85xuq3g9C|BP3X&%kmlg-Mi>?v9&FhJ5W1U^ zvll8fE&r9IJn~0PD__)n!)B@}lHVaJn%_bCjZHDV%gnv+u($Rd6}Uyoe_LnXA){KCqL5qos2t@-?pMl zb}v`g{yp!4?)&##d~Dj;ZWq>IABbJ^2)6T5<1XDNsXhTEUS$#6c-`I4V=F&`t$Z=T zqe)bxg#7of0+Xam(qj4XAo{$VTMW(?=38{zjoypNv%DyqB0hPRH)g+xgI8g*$9XR& z21mEm=J>a9rnk#`RhnhRMn4(V3*PSJz~x;4h>Q0Z-@t|1n$EpnEB{?I^)RJ`B~Q+j zJnkGNpH|8L)OJC5y6L4m%V(s*@*n9|KKtRk@^|9X?Ax^kdb@U4=Iz?Q-9|TB&U)tB zk+Dh&Ki$JVwQ`Sq=iupsY2K|(9VR`Z?>v7^G1gEb-p3=!YA^%WxTh2u~ z>A#XY*rC?R>#h5h@zvH`aMC;7`bmBy6@G$HZAQ)85x1(p-VRf6ru=oq*;Hd+9sYL` z+gFFz;NlFlF8S`bL^QhX;o=+;kwrg({TqVNh_=BYggW8#9242Xe+RA%{QZ=vQa8%> znu4p&YP6h5c>Jof{=+7^3udDUSEH-Wp0BkdNo8C6epBfG(%OEEVASEz3EwCxQ%AexWZfQ>-NyBZrZ;#*nJQvaf|48k#F9V}nnu*mB3 zcSj`*i1$LJamxQj>jZ5Q-e~yq${j zfL=|V-cHlZw0(I7lSH%jmpJOYlqtZ@=$#5Naocc}w)+#a2kZ)M+WwIc9qMGPuy4Sh zvC=+W{hpYKd5{<@a$RQtGV-9GcdInXVMF7@VKu@iRmM~zR?(O6i@^qZy%5(kK;TOZ zp}IBl&5@_q`Z+fMGcJCMUe4BD#FY>${TGw(q&pxd^X35L9SI; z=Fm!~#Os8N-ovJWA#CfC??4I*NQnztIK;Si6u(2~#znWismZyu_zXTW=qI}EIjL8) z$49me2`4A`);T}_r4!%Li|?GDz3~-1EFQ^&A2qkb^>%wX+fvu@_m7J@CjkXyYD8?I zJ?Yx(%tId5abK~8dbbff2)Nv zI_09r-REk`#L#`6gm*SLUS7Jd8@J!3j(Mjl-HGV3fYs89F86N(I_B`*JJ|Z~U=N45 zOUC)*mn5DJ;S&EDKrZp#l1_V%`s=etzF~oN5Nkr6wR6|tR=~vrnBBshdazbSUq{ir zh-e1)W=7|B!aD~*w+?hBUI@_;iU>I4y$H+ zt)B^-!E?S#5_`B?{hRs$v1J%v?p`R*6_U)KI;egesAUX4h1lxsBcip4PZv*=kvAXf zBX1Voch~1R-dmpsEh}HjEv_#uBX4IoYzMGC; z;N8z{&>S*lWHOcc(~=!I(N#}tN)$VrKa-u`;*21HfYIVe!N$5&H$joMD{VX^hj@i{ zrBpn|L}KfhAN9laEM2e_^kCl~Y6zYASf_^2J2*oPp+%Zb84V$$5)>>q*$SRsM2V1| zc|4vQ#};Bf)uHROl^udf$N7Bb(po;f?Uo>>LOY}5mw6^{xl=$1QD-2DpU$If&#Dcz zBW8T}s_3c+;mLOwMN{7n@c_zIWk5S6&7rIK?M=Q@f6S0^3 zNcQ-~Zc8f9RJqq@RM8+iAEmjiOTa6Op`cKt_2Wj^q#=M%hX{)!(s~OK(8(iCL# zo->)Vjmx8}s+4r}`jX*bmUL93sk;dYO^6L?pIC?(dJG{ovAtN~yPb2o#Mav2FlVPI z^dy%zLz#~g&Df}kOah}8iHQ=~Nr6IeC&YUZyGXJC_=?(oG&77;brCeZ8)gh?uTXVI zL5td&*cR$bC-#^c(}^v?B2#B!xAa}h=v%@h%-)?`&*V|bB zw6QYjDwj?YtBH4w4Pe(9Zrn0$>N+y0={i%)SLQEe3PUz8F@M-3ld0CWs%wnGx=x`9 ziSV`BaWZ#NtkiG1jU)K&7ifny^t&&7F6s;hd{T$3zp~Rjr@5zRj(VRb8P9H9SyLa4 z9fJVr!Hw~uu;k~&RWl>PJ91qwEenx;NF>5&s;{njN>dbr+<&{Ai7kam>`)m46o;Yt zy&vAD0_oQB_@g>xI*@KuIfSD&>KOol|Hk$x_m$S40iZJ3({L||jFDT}54ARtJMZ96 zPkt5l9h(Yn}phxjKJEF@nj5Pp1i)m?M=dn z`$7||vGQ)uK>E{_H?ojhN)!SZ~t zo0S>OUmL;QAX>#49Er3Ndj41xRi)DE1S>ttDpKl}Bm0n-N9b3Bu4dwIa5H_kipR zHqXlMHWiRJIl(-J8g&LR#WO&FyLZ`xggNw%jn=3y5>#K<`5>}IJhxF3Ls(QxbW0U7 ze`Z)!fqwj|oEH5`E0#oVO`d0_hC4IA1$mItK`P)?XQdl8j+}F8Tv>og%_S*Kr*xwR zKiw!?NH=O2t^H!JNth!w{WV~kp!rL&O9od3={;-;yxKyyL4_d37~&1l%K9yWHJis1 z>aEuRNjjyK4}HgV#;~)yery=LhT!@Lrw~#E%p5v+2bdk-bF9qwGK$j;C6ge%WJ<7< z084(%!1@67)YR!#adNyM>(?-T_I zeea<}v-|APhPRo*GFUvCnqbnRslg|peA>Dy^d$3l;>O3wOu1S{I3}C(>}vC zTo$qo+ScpQme)1R{}2gc$;|Go(;5LzFP;*7K{X$StBt00;)#4q&HWfN&1Lj8z4bGVEVU~Fcq zvGr|r$7SU3ubzF(=t@$p^?42hVNZuOFzsfgr%IE?SilxWE>n{XrHt^l44#_UW@t=I zOMWjhbM?iB%$$$=T%>+6DL==r)Lnb7s75(_)PK?$*47*dxmp%=9s*vm5eyQ`fA`zc zX8CvxS{O#w1n=La7N7}P!k9=C(ipvWtMWaAz^FpHcNVl%X|EFwZ*pm2B=J!ghb4ur z*Hcf6$*TC)cXX%SE}&C$TK}Lylf73*vg+3F@^No$?O;f(C4Mi<+p7_qORlyP6WC+} zuj}#j(NZ#b`|juF_2M6rC(d)fDET}bBlaAzELl6dmYW%VRo6v4o@+|HSG>@1vu&`} zlU@i)X%ZN^;8-WUj9-xc9JF;Fl(NrrYK(w=RwcvVEbZ04l_yqE;Q3h0qg(~-WHI-X z*vOv#i=kif`9f5PHsNyTJ`A=k$YoVXe9}3xw6>iK;i-2uBj0hCZ)HKa@f6fpCp=Fu z(%y@`C3=YRCT3OFR@e46-sZjH&OJ);ZsIVeUspa4uCGY`{vU?n*FarE?Lb1!lF~K? z?L>Qb!@go5&t1N{rE;_4U~v+M+{D`Ov2^eG%gyZ_NPtZ_g>;74G9KDFahP%3t0+h| z4{|G;lO2Pi&M#@u_Q!toqaU4m-P^S@$gXfJA5Sh{6N#oiLfyLV)Xcu48bM3qP<`5; zs7r2R8Ovk`Hw8DTq8Z1y(KPq?$Z_;1xqLI7Oiu;o3D(IC?(zfZ6$|_a<2Y9 zK68)Un+uD-MgY@Q@<-gnIyB{&ukPFxuD=wAiup9DA&326DBq_P6G`FCSfe#zkgY}i zGOb+w7l7ndZs&mAA3fDg>`mWafYpp(H%i4&7YndQ)Y%z_2HcwC-kP)Gi-iNCsRD`| zSx!#@Z3cqNk9vt_4D(W@^A8R3bFG_2N#-7hwGPjANkB&K8o(9VL#<7Um5jb^ zQ0D#FZt_24N}`7*>6%KrWUNZ!kn&A;3JE71O?{RKYl3$KuFSiZg}7XH0uw&H4GzC)_Q(nxVD=0To0m2+12L!^%Sbn!#XPUPk2=K-}yBg zbYnTBmqnb`ztLBSl~>su|2N_4#mRTl@g?qzEi2!#v*p(U#*E|TvoNYHQJ8nZfL{Q$ zG`qIbypT2} zvZ=7&ox4}u&4U8yjAPs)EOamBaWNdX)#UyWKnC~n#1&-41WJRU8Q!Hj zsOc5Dg^MoLL4^$s@2ELzRb<1%eEZ#jKRMZOTdDCJ#~GHo6o=O+5QQtBu;nFE8RmB% zj+I{wP0H=Sb82$92ly%;DRc%W;Xr*~P?%-SE%^sf^dLy!kgBHuSNakY$oX#|3p>Av z01=is6ydE`PSaF({c4;UD(P#qyar`f+FzTrW~iFfScQF;X+?6@kI1QsVYAkW%lNrD!4W{SV z0n}iIyC8`{rs0jPLzbjnx7Vn#sPURKFtx$OQXk-U>f}qSV{5`BHMPMz=A>sh#%@g| zhT$J3sxdFeU9U&X$!Ouq1Abf%2p@+ga=<^X^C!o z+1r)u_+<3U_tRTlJ6u(dL&58RV^VUEKGfdv;Y}=ayW=zm={iP#e>eStDU@YTJI9$) zt^R^-PI*UshSe~*0u2NEK3dnA`5@KXL(iaxk^wB7xq&jW!>SpSQ@n+w1*De&iYA=z zYym>yxTc3itj6CJVQ_3=7gWAMF_L;TYHo8BJ59*`H&82Mz}rke34=@-91RlZH!9RM zd1B+k!qR3~YlDfV!~(C$pyqlFvaseBx>pk`?vZ$QpoivE{er?%yJ`1@TvR2U@61#4 ztvr7PP87I<%Naj=@8PK`(4a|4yp|rz{I`h^qOAHFj^4{WrvO}^CcO3jZscBL{~~k#K9u!d=kHPHH2|Zf?JxWqhN-U1 z(Y%j3Z!sVHB|V2pY93bc8Z|@M6IO&!j!-eLw)oBz0U|tJbvDS;8J2m&<#AQacJZU+ z>9?A1kpR=iWPU0F{GZ7K(q2|M{BIMBT5@Mja#s!({_bys0iq+T#k3h3g-C}?*brf^ zk5wjTK7Q9ZBRbJwR)dBJA$7?nfhQ7mK15eroE*YP&h7PFTwar?jN6naw^Jdvldtdk z0u!Ru1L>aJdTXyxj)u4b8;ayMs|v5TDa0Samvb<_w2}r1$;uBTvP+xM1r;^&eYH05 zTFH6R%8XoRH4(@-FFoa`LlLyq6GM{Ai)rxJfQ?iyLWa;7<~CGUGP_=^m~Fg3Gz(C7 zVM#5%ZrG+W%s2?`tBC8aNve|p@kae0xy=0*eS&W&!XQ!Wvmj5Xj`Do)>1D*2K@nbl z8eXk+sXLld*cP0C6XJTx(T+@$P8-a``yjGF|feI1E-c4}`{>ovF_brYk> zQIy%5Z&o8iO?bYs`*HMR#BkdIrB2k-*e%&K!B-EJZy5q@W&vm`6sZnAwVKnQzrx$u0A3MeL|R{h#CGR!GWu*DHrOi*v8ceQ&+t%f zHeUmeiHAPv;RjFl;)jwaV&~%r;cE|sGI035J!0^Wv0-#8*SM8y-O7jE%17MFb#CPb zw{nwPxmkNDUO>rpXB>K{GB0^7>Q?T@D)Ju(lr|^N!t{O`Wa`TV=0}2k|0bDY{P*Nl z(gBH^VXe!b89yEYJ3H^W$60%hVWAdb2t||+iavM)zZl;DTfPGZLAsm`{Bj^Jp?ur7 zpD7?~TNem2@`wEEd!BEtJRySU;`ofD5>u~w2h&`8UQoyl8%9U-xnJsX zgWAU~=HHl*e&&|uGBC#83A$U<#2D4}%_9vNmPjk8I1g2bvc0~;a-n{tN#Ty9=ErM!4@lA+*HNzE^XPHZUB+%S^q|Ra(`ca7Yk$;>w)1HsWSV zt=?l|?OkuB`62%B%++sFV@IC#I}crN40m|ibecm~&om4>;%Wl9?@?(e3thzVWWDV^ zC>M+r>o291i9DpV}gq5&la6@(zI1SbX(P(Zt->};g_ zMVS$_px|UG<7Je#u%%nvYSor@*{$&ACJd>*9&Zl zxbuum>c!Lc>&)B~ZZ3W_EAA%jMNNiyS%BD+Ly1~_`7elsm=-1rqvb9<#NZp2x_Z_< zA7WH3GRviB@1+*@LOzs1?>C0t#jC*YoUq%fme%Rc7O?biH2lDm$|WwL(rq{MaNF+G z{HAPud2>AIYIVwS`jeTTBfHJd_`w;cr%#e!$_0|{Fu{H1$&SPj2_XEU7`Bw!oR#nI z_iD0YD;s6)aM#P&H?{%pxy3|rPvN_ixEknJ^2^!8M60@pS#ms zL^X`@3Mr>oT8US(@J<}LTPKQA0KD77{gjvK`PJ@_D18{QsGYpLtUjwXXygrbe zy;B60yN>qAIc99Lq${MmoCr)7#8T&oyB>hFL^iV9dfz;GLi-zvQ9ul5I(`n(nUJdl z31lo`4c?I$brRQ@=UIp=%l;VoVwZ6A0>yY8;pnRFtTocnYP{a)7+cQO7PKJyVj9!h zw?Bc)XlIjW?oUj=T0y{K+MBcAUm^Hfh@h14wxR~N)I(z;`eHC*otn# zZfEw^-!Ox^9) z3zjfmY5st7pg0pPRFKK99cJPw&W*%)^?LAl1bzZcn^MVrk_)>WutS!3K+39$-eh5ML7 zx@>V@ASh#t`*UDu^oj<4JzLx#1DP$ZjBr!==P=DBFb(AjO!2_@d+np{Q!34HW$}=` zc%7$pwc-Pj+xz)?O2>SYk12B_`9GHrf1fl))m8y?r)suw{1!xAK8Hhfqg5!QRb=fl zU`G0iG5q3q9rF;4GsQZOFTRM_XCIDvK8UGr0j>$rLi*0@O+cJY_rA)>I3WIn7iwR3 zCcm66Bx~5{J^C@Z5)0gXEpTiIeoG9`raG=15VADvBpw?WKLIxx@LugMWaCavV;6cp z_G|OIqEx$A{ksK5zv`qkeL%7|j-aI;4RzZieVY1`{m5yyH}}AqY27UhycA?y`MxJK z?KA7+f^PFYesIj`*GJ#!ov%IPIu`F1&GHuH%%?HRvP-9D7pYM%1Wl9Z6#U2csiQ_nZwT%F>+E5~(>cj>)ON(`gJOYbqr1EujJuNRj%`R=QGv>Z|WZfM5%KcRD zaHjV^hIrh8w)?Cf#_qAKci$Eo2Z|A7_wTQgEFG)wGJX`%RgoFXM;vVPMbZ*oe;3=_ zW%kGc;!NV6O&+}?kD`FzC1UrI|CMiQD)GqO!){_-!CdJSY;WQFN!Z@Thm*1W83fL- z<&0VuThqdnah!YyY*Y)|Bsq$$(wr@fGVjpm^z7Gy1B$-=34hQf2{xrb)6H0^(WDsXS_{|JB zSm4+LdMU@;*Rs`L1To3KP z(*8Ye5-ujSH~1I~^3(5h^cb&*c!|S|VyqJ&*WFuA!Nwz;x_K=QnBlCc;K09a0)&qW z(FjziZ5wouH!82UUA(yuE(ipk)C}6*M^lO>40v;~O`C+w5}%px>$}bO zwle>*LGGCQBsm3=Uw4yh?m)_q7n+T;^sC+L7z5b7MhsvNDIfl}`mX}mo>;(B$+6qY zLSY~BjrBT{4Nvg}>+i?b>-W^thMFb$^n|m$Uo)2r0^zEIsNu*V9ARXP>-uB%gvx~P zoXu56maTSrbPxWi_#|t&wfrU@o3H2WCqZ&YpEI;BtwEyPfc)r%k)0gZ^=#*I(o|TQqQlM1p0O&rIo?Vy zthC}pArpQ(U=(CIjSD4Wig#@JAD5|H8)jJ4`}u|-m_ZXttoC5`eWAq9fS3Qyn|h7F zSY$-T>CAh^z$OQmChjHxf3?{rqQ)D91$jKj3yUGcpQDw0^6o=RCPohh z!&##|NLtAD_%!6>S@MFZNo?ac2f_bq`?6n>UMyYjt_pWx`hTol<`KS?mGQS(;OD?~AIqzA1SK}ee z?-mh~<#!d*#qZ`3l;L-eX!60V_T`($@BW1^IsC59oQdDHGiNylf5z`N6F1B6?&5{> z?dlmDM#l5LCw4^9tohd2Ao2PjC1#IZM`y+!BK6OIlYj0vPc1HE>*sOQu-BH^<7B4X zKV-Vuho>y}+|E%E>Ky;PgNz$s+d2RE%BT0wE2Ojjxe&~)e~JJy{WBo*u@At>{WFR$ zx&8AYj99jRgiW@8_7IZoAHy?yHn5qXO#f^GR{w0{*Xy7E0Q#TyPh6=o`;k?=bnl;( zMxq*VnF4Ln9cc;#20(l6)0c)NbZ0ybmA;pn9iC8xHPD|~d39AN$HWf;#?xow`A1r; z^f+#^;fqJHo=2(AZ93S}j?<8sj+Jr*z#WRFHkq)sBr#thDJ>donZV*MvN;WnauQk; z6zTscQiEua-WKWYF{57>w2jq}+PGS|+G-Uy8ck&$kWrAo2VH52)P z&Ec}`%;8s2FOQlEez$PTc3`cza2+10c7M9s6trB_VwZU5UawmbRF8Uwk=>4c>|l$R z5jn>X&dtc1xlK!ECHM)Hh=zlsuxL8m;Y zz&Rx@rxPe~2&Yg-GAHUrs8c$4!xSMoX~qPgqU5AmpoTAncxT?ixz5D8J8+W6-MBh5 z$>%Zrf=%YA+-8PA4mSP)oAbz*cq1aaq!K^F9QO^;2RHD0jqYL!8a7UaaC+@~iG4b4 zie{cvWuJr+Z}1CqG8#X{qhen=HTU-jk3?xKKj*o zSEO(>Rirf->5I5|8&{8(Q^9c7Yc-^MCC*$Nxs{(XWZby+#br&4mV^nJ7Ir(o59wfA z7p>;PuwiIi*_c7qUZXj5@fSX%wV9@kA4zDEP}7nf!<#~hsdN(BKE)~KeH6kf@ko$?(R-qaGPO>)gL5m{|v76a%sO<12dM(sI_r$49@EA(Z} zN}i|LnG6C^s4@}aog)_ZKip^8bpr}nYxKQzqrP*ZUGV6wY|cD5*B#vurB4YT7YU}_ zsXkw&9Zfbw_|>N3AoX~00DicWkFDZUa^oHLT)=aCVlGelEK6>bMmV`~j6Jo8BsY%a ziGLnFn=oMFx8D{I*HEH~OkdWj0otMXdfw8b63fnow?Dw}#e2+ZqKDmmIKR@t)-`G< zi3eNRd~+x;v6^lRbGpPZkC`4OmD0yhT?0{YI;He}Hrz$*&Ob{#reS==5X+v5;qA{H zt1J4Ju5$h!jJRk=ZQ(xWH;g(-4Kj+b)bct;FD7+-ON}4F)(?PP1y5)E*!B6b!gx!5 za{O3q=J`ZDUElxDcalF9*#^Y zGkU=?yON~ojcOP7?p7P=UJI1|Viy$%CB8sX=QkWlB8FoHr8jB-oOFPQ^Gtlw1T18Z zRaas3XrlzBuj1m_i)Sh^if8zRF_g_Fq|cW$bG-4Tz0$j+j32`Xe7gW^IL2;oieG+g z6*DT7cpNxqP%6=8VP`GFw)34(-H#dCw?v9nJKe6BTf5c2^=fCRBI$%b$0Q=h7$j*} zA^|N}eoR9@l=yp16w5u+WAoV)&cKQ-hkA6i@<8ZnP2`|Qiv7Z!1~qMsdyZFn+U9$D zqdM%Q?(Q6RQfnmsiLT7f@lgCNVKUJ48GrNj88@KMP~ZNUAg{SD#;pJ-FwS~MZ}i59 zGkzSR5*0RnBKtuD<|h*xO7zyF)0xF_n+Rm|2h!#=uZOu;@god{!9>~1uQxmp7=JdM z)Owfx#eO}FIY@4tuOfOzbO8tQA}zEI&gAouUwXY$;~x99ItE8-nk(_nfuV=S$dOCp z7@h9(Q0a}L1^&#x^YbQSt$T%78kwt9+!1$(DepVRc z59P!$5~WijaZZDtl#nby1`}@>$s5z{M<5t)P>pfE>rdOCUoMiMZ{){R&qRn0$tL@Z z+=(T^M2X)q_E@|@2$L9|jh=OvyqT-0cE{H3IhHw^Q#y3$He zNR^S=8+gx zgG6$ThI`rDp@;176!iL`h0NQU?Cg_984F<|iG;kyUZ|!z?9NTmdK_M&i`D#Pk7?9~ zR^k`QAA_ehj+Rxmy|*%X-BxB3IK=LNbf?xrQ>b0r9P48|Uxp(~BreMxqdtASWuKa; zm`-Ba1nxXioM+1-R(cf41tqXKgE(%2NRoGA(LW5}oS~bx#o4)sD~9|d+HYqlpr2{U zVfQ;)Sy`5haEP(El@F&uyg(dH7vifu#7`OF-+#{#Uw-WKB5QT$lOYwwq!&Ef-iBqm z^H>3Pc)Z>D3HwcTgmc3JXX2RrE01F?m({&Z9gNMlh>WLt7$Ih^)@@qYQ5gp8y819TT%BJ=7|BeD7u*X{YtB& zi|jxLmE&$cccuUs-EQk3+48ilU3G_m+pbrf41uYn7r2bJ ze_)biyL9`+UIpsIHra$>Mowh+=Mw{gW*`2M;I@N08)TQ)9_Wl8EUvbVTw#suiJ1R* zWcP*cExwhJXD``ZEul?}so0|rAb2V58(ml(nJ9W~QtRHgRJ#B5j`rzHztZwip}O6Q zFV}W&Ld;{M;Kc{0V}oJLV}q*QZ(wHVbmG#W*vo@sp zDoOiBQ{N^psCxgJO7~kDrR*D`|5zFeMhh`ZjRoDi^ikWWnNkotj(tfiE(@lEazWZS&-Pse5~+ z23^k=bT8#?vc<|pAhLm4M^1AMMw8qdtGX#rqzO_XPk-BU0)!hQ@jGI^)zn2|A-4wm; z#$EjG5#E>x)yX$jyg`u(e^d+Cqt9q;RE=?e*-u*#Z8n{%aqiRhHcM|k6WHElp5CbF z;mEXWZEFknqh^9B=ix5hWAmZ*(p34XuruL~rq=wthqh8!*gcyqh$(LiQ{~H~fv{Z0 zkqe8O#=;4FDVp(O_P140I>I~< z@%lyzqsf+v)LEDEBFXb9{ivmSH?f3iq*#^FrAN7ydFCxurr23{N7Enj^ERm(94V)i z)V=vn^XCPyV(}^O84I?d6yH9gE7%K2EiTX}90#N~S~a(FkGu}>EFmrDV0e~Z6uroa z*HMVru`1#JU)Z^C5W=0$8HbK0zm?!H^7k7pB?nudbFj{#x^5(F1|Pm%X*d zMr9-H-wNZfpXuVTrJK>Icx#-p?JPj!2Kjyo_!{XP+d~)s%bRMIqFi}oHl;}1ZKSjV zk*gcKb8-cN$Oslx+!8ZA?_aK=AH=K#_gFmb+*nwzi36Q_h4mR@ulYR1i;d(ro|?>) zpCS5jwy|LbNG4p8BsUH=xY(YB_AJtKW2=P@0?thE8T!6v7SB@#hAQ!IEOoGovE#W* zi$=^Z2#CzM-d{_QZsHzZxiBkux=VLk{72k7W#^_pwAyKDL)? zipQI;5ECzO+CKofct9WCNv;{DJl~A=XB7v6cE}5pbJr4%O7QNiFtSiR#$87*;lD=T zs>ivH=v*6n>nVCqgn6QQ(A5gfq^?H$MzNKi%ly=8*7eG&u)CEVsOs6D(SS!>Vw7zU zJvf;QQBsrBFGy`y_6l1w-iPmwjH5kME6cwlp5Vo4r7(j~CS3Zf8#Tr#VEAkvknbiA2Jx%J|^|y<88^UVN@qSF6k++-cms60^OuL7i zW%ss%Uo)}oX0e#Mx4@2SIolD{7iVtx>CeE?5PT>f0HORz{6q_d7HaDJQCRQOf;DkgTjcI2#|}#xGi3cK)TR*=S98+ zQUwc!za72Y*)n|l%Xh$Z_7Pfn+c13mGIJ_=QE1aB3?Dg_G%tC@WLY?4`S{0pTkjX; zxvX8+Pjf4;**`A+9EA;5`* z5)X?T5pnAsB zAI^*#taRB;X0$$aLv)K&m2TU4jFZh)Idcw8ZzUBOEN>VT;kfv5xclnbW8WO zC=o}z@M>P;hA(3Zb)cguvg5i1BqxX#8W#4bmw6vWlTz*W86xr(9UfVU@XyE3OpJImi5E^3?^&4?}k3F>yoJw}oUknFHC;XM8Y8(D;JngrHM7 zPGMf7yZ69KipF!bW+0rpsn~A&cK*6ve&u6A=91HcIvS>~3pdyrY9_*zfHDQ9rLfAzTg z4L_M2#t0F@sFKZ&WL1%K%Vg&9BOfCKQuFkpwB_4cA)~uLG)-Q!?fIK%V=2`Jd+Vc% z2AJzw7{veRyn;_+jj+rvht6OR2g%!gbi9aA+3TSP<<#EvShe@X#`oM+KU05jH>J9n z&Eah&JKegk0yDu1xPG{O2gguaD5tRf=eM^#Ds11pzdvppu>9{8Z_Llz(p=K$AL)v$ zLuwh>W&5ASWFZyNRyOa(UF`(We#hlE+0bgwdVB8TiI;?i1N_EQdwCL}(Sn|`=URL2 zv1f}tSMl_B!Tl{v1+^z=;e8ukMd>v;s`0k;YZ3+@2r6L)&@ zRLTD~8|x4W?AXudZggQVRx1i)Z3R(u+wW_1lEjinaQ8~BbUMwd=TEWGmyvsX99b#f zvsJ$}s(rGGoBuKu{T!clpMWKFzv4HNI$4c$7!Jcr1PL)08$sfiT55b^L7-B`UE)8F z6oc)~3BL2M8_{q%u6k`7g!PNNq$q5Ci@e7g@3RB}F$q7X%UxTHAl*ywW*!jge z8a=tO0~pzwV-2d5vqIeHc(Fqts{_% z0Oo|NnJIDW09c1FfadlIBNgOK7!hyjot!YjB4SK<2VvahK~gLpcG)IV<-0YD{2e0) z%T>#pik&qIa6Wd9YKIoTX+*D*bm=!oM$d7qK^%H_GZAFR`#Dk^o-m?!G{gosKABz# z-{M~LIf~zCNJ3iFd|xG6@Vo7RdK(i(Dx?DJ3~?P35)#bASHsJ7^D7> zFiKc+C)C`}*D=-H@6Gdy|0|bplr)axwl#ukaQ4LU0FyjxS_;2gl)Pby$}wVs)*1MT zWn_Z>5|9fqcs{8Q8p%P8Q0v3==oNhP)j18yUmR?R{89N+&Tfi3K@}vvaSn{1vqs+?NAttgc-M|vqt5TTLa6%+yF}7Pg7i+P zf>t+$Uijer(03c_V9&pxY%-J25I?eoXms`pLWJyJ`Q`o>a&=$6kxobn6lcFw0p@G} z1yKU-5>lLF#G%bre49|bW)a{e=F%Dkue-_X*1P@OzsD~gJuHwDVNZDLRoy@E87HbD zM|~ufI8Iu}h)}hAUbDxpBTCTcYQNxb{k>QJuErPkSCf&~8mc|xVu0hgG#8X1AtoA0 z<(Y@IMLdre_u$1Mmg-CQS6{QfPn_WgE~}q7TV$LM4X|pJh_vL_IDlGi}i235oNuG!I{0gzIMbL2Xk>F zU%g4~qy(QC1Q#!}=r=Rd>~3M=#RZ?ajxA%`Z_GC`VdKCF3>}<*W9=HK*RlH#jFoXKL#Nc!?FQ7hviFguQ9v$rsb@knD#mx5PYrLhL z4o!m(;i5PakdrXpu*%E*7sRTLtYlDSRdyOc-s0wNX|!P#zgEj|AXN7xv2)kq$CcVU z8Jk_bf5x{S*LX!fy$~n@U5a#wN4XcHx#XI9R02u69opCw9Sp-bktYMdJJt#1og$cxq9$tgqIKyQ9Q;BD6JRAiK7l+BsfZf1gC{~5+(>mt@Xbm^hkUKG5KSC zcta__i3I0Ij7jI0Cc)XbnaIhFE0l!U_8d{1g-g6^xV!c^`FKM0E*uvIcPSG4oDcDj z;NL8sQrpFkLMy*RU`=X`ym8&~lH@JbsWk`m!V$_#&-IAVPnAJJQFJKy!QZhCAf16} zeP}Nrw-M|_R)ApU17bLDyMrgNx|oEL>>wGsD!b(Hq~yl+gd@^J0f)KR zPetNjLrNdVkaJ)8M?mOwE1y)=+2m4cw-|@&9wKAU!H(_FQUsmSO_F51On{$vWGy&) zL{iryb1fWC_pc2$nAt6*D=TaGt3}EzoU#}RS)8^$ip^XG8?I^OBiSz}drv&`g&8^G z84V{br-_Sc9p^C(gm{B8CCMZ{G10u2N?ug8h5Q=+CWy^SNmYaE2#PG}3H56lggPh9 zASTXc8YKP8{d$^7#A&6j)5!1i6K=jHTww_lE;wHkPSYcqdX}ec5NzDaiGv2A&AGJz znr)hO$p%$C*|5%@-u&|BovO=aT|DC{YkYq{z}Q#gI5-U3t0*wFJ?j%*pm`&!veMMU zld9nXOE+5sc(<54&yq?Q2RqQR}+A05+ zHhVfuF&iO5jUW0aB6AlSueh?R(~sHmdWUCOSCviJ4Is7BJbRGX3~!~bac{d_gGhDO z@YW~_>((~~x_^P85>C5#0jI>p!s#(<)VR%ZkNnt-BjdzG!VlYo!i;;SBFBw$Hs1`K z^HAm|jbIgch+A|q^lweye`d`!GcDB=dHuN{RQ=G@u?;r z1>mE)owRP{obv3FFv87`)Hq&S%_8jiIA}eEM2J5;f>c6=59Pu1$gUHR0T8b}F^7Qo z(gVagPAuvr-oU(?AF$&L(U};5wgBodXY4o;m_P6+mX%Hz@-ZDd;4OwdmVTyoF6FJ= z6(IQ(cA$p5+SmJ4svQ)Gs6H*zz549s6rUX~Z6lV(_4|fev3F$Cya0NZuqYo9*pBfG zVe6hS{ED4%`JkMt*k4&)4T98SlpkRk5!kaj75iO_i#JSpIG8V0@qWck$67P7qt&O> zNhGU+wz66uqGeFh5bx13*{zgIWT~zr`_3H4!AgWf&44_ke#&>Tg zyc9GY`2fceXDk}Xz*?j$e=;nM%zGs7Fkx9`wevCT^OhRtD76{w9j{*WMPziBq{@#w zZ!;j5WUG_xgb~RnFT^N>y{0B2g1rln|zC44j>Q#8$WG zx>mPO(?Fa7il@;)U?A4_w)P*si1**t_O-RsBJ0(>_uNABzL%`njA)fZ)2wDoaTl@` z2eN(xGRxwvxUG1`jSgTnE#I)cywxn2 zm$q<228xREy~*-=t$G!k-F76wNzeQ4FGBPG_knTpLA`V@TyC;IL0sQcvD1_ZUW`yAD- zEx48Q|3~}<`+oRQJgCqS^GeG?b$2Rm`OfÛF?D*0RKnsBGEZ?ho=CveCy^5vA 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

ekThY(w}?VU;Q z?HS;7fvvCUzi$5j= zNg$b?7CP@Ko(jmC5Gl!?<616<54AEeugChzc&EJ+m{t+YT=X{ z{+s%KKTx@rGRv(?K2y{}wF|+JqCzk_mQpkn6i$WZ@(2jIO76P(AOxa!mjedQTVk}} z26DH#9v2Q)SYTGJUEmIVIZmpTEv(}LGU~IW+&1NY*LI`wkv7+kd{uIX+kD-+?tM9T zs-E1KNs-TZ6=+(^(ZS-$tb8O&XjUc?n$=N4vm$&~l+X+k<(g{+x}-aWCRRQoT&X&K zC6Jw*IN9;b%I_7}fsdOQ<@w%Zp**WK<#|+59z6QX%rFwhyi$lyOo+FNajyuub^x>G z5&!Cle_mGe^9*uCXYFa3wUmaB5&xqn zms2aeAgZ-(%Q zNj8{GX)l!$>(ps6esr1^_ssw1cI7RE%mA;o0Sa_=S>+h@AY!9G%KBF6`T1ooPfeIHjGZys>s<_Sr{mv1A zPhIhe<@pMgCe&NU{M0J)`~qswS-ESGOw1 z;Heo7qRDNX!u+j8WTcs9*yWQGg~EF4O6u3_vM|GhS;cjfoH@=yTL9XMJ%=!?Xr!#o zpNV#EH@Z;YsKAjvz6%3K(tX46g)c{fgu{p!i${j6WCe6QMp3wTohRhlCtiYGySalK z&B0bAss**jHIq5M$K5G1Sl{0grKL&`4~M?T=FruyGF?{=3El^h%CVVO)jXA7B=Im@ zd$qJSS9688?#{&YG@lJW)2!TU^picR+d920x_=PLF*mIXite)VNQ&pO)p|F0x3b zw;*wPwHr2TN3PlelGbt<7raqfqEbn=Tc410+H0AZZa=!~RL8F9dyc10#<#ZU6vjvJ zzwy+r#s|IbVSLu$?&IsIk5X)RKrUGX!N%9v)5dp2Y(ed_w*9LM zp6s*QNV4%njp-B_g;aju)F?{ot=jMO4B|v)O7jQB0^d3e>XP*RCx-9W@c;L1fp6hy zz_+yC+DswB-~2HS-}nBW0=}1YM^2l)n0G2rZb1E!v>NwWw~+Log!1@$>(e`XhH{KZ z!GA3g_#VL^>@?te3Hu+_pC0~>s<#?cpE|?`5Il;oYxi=|rW?0A#^!b}1Ni!&qPbl- znK)i6Pi%Lg&q-k75^?$Pm))TJ6-oa|D37kU%sYC9au-~->ERNQr>(#y?xcL~(0Xe$ z)ko=lDq?@fdm`vcHq1GGw9CNTt@QZ7Pko~sR&V`=V8T5yZYdcaIseG`p2R{fP}zR+ zF=B%-b)S{lb>RD~z9gOYE{Czm(_Rsgw0D({cC*0} zd6JBG}CQPY*|tAtp`w zf+QOz|F$R@orm$Ql+vVRzCOzEMEM~ZMKmq(`}Fw#I{1HD4>aYU68~Qh|L+lm4#P4HBP6Muf}Z(1B0P>j!{i7wNRB`Q zV!5iT!gp}oQ3oA@!C~Zj?lxuAF0unT91OH10O8f<%r6^HM8 z+|KRBpB35s+4tc-68SR>vyzz<5lMcGG@u6-ZRV%lU|mPje-hT?>MiT*rv_`mYUp*I z?B`bDDbVY4>#dd49p%q#Ih%b959nbh9m5+tyNtKp@{n}e^!PmDznx%E30tqo4`qGk zoyvF$>aFK*vB$&tJ9#|6L*n0+(_H;YxACkc>9of)yxy8f!##1Dxeml=buukgBe>s# z2Jv-c)?QnjmcT`y7rit(6bYeRvQP)kv+Au6=fR@PVkhEwj%8UE^xya(wam;OG!&y6 z{kYN>Ux|Jl%F*#twJO?ma;UPs3Yl5u?kX-L*f|nqX5S@qTxRxdC3He&78g3Dl$qU# zw5(k=kZ9wkYp(=;mG-sJ3~ie&G{aD{9aZX>%_20*J9VMi2mk0YX}heykz`Mr>^Lce zW~Y8?IJ@3jJokiiS>V|#C>fLpn@mdOJ}z1v#+*7~CR1w$&qw}6)mp`ED@+C`o6DR8*rYdg)nJ(K%|W#g*b-!69%)rg39W8&I4h*lk^R zpv(O1wkDDkou7y)jr-2v`d@;H)2YwT2=u=VJ&@%XlzobW@6tSMRl7FKz zknfKoRM`e0XJ!9-=S{r>?n~6iEno-S%gdE}c)0`DT`?t8UEpt6A|l&vkNjS&@WBlz zgl!Cz6}fAq66XVyX>Od<_l^v4^DR~QG6P4?5-Uk90LRV-_sQM?H(9&?TNzB+2*9Od z+YYdDk2Uz?F1WJC8b*?x)n-=ccq+x7n%f>BLQt#qH_O2e6U$_Ct^Cu&kdgJ)H>n5+ z5M)k}#MT6;zz8j;k0KWn|C0J_6tVryoGQB3)LZY~B%R5Zp2TTAv_mk~efr(0t+!TC zqurgDlf6@0Jy&x7Pjx5HhE3dLOo3G!9o-a1kr>klia%u_5o=ZgrOj9IP3B9o8} zO&f)oeA@71!nGq|k*D54^Ra)SP8E}EH#?~H68>o9;>FX@UbIBJm4U?^mJO?-6>7TZ zb&+FWH>KVx%Z)NwR83hpW!=G|;4n3?q$$V$7kcpGZlaBG!@nXRvXHaH*r3)L`wyvM zH#H2EsALiUj&Pkof{t}7BM|Gcjz>si18$YbXK&(uMRmX#43aF4Dpc&eS-TkD zU>c;6aHeWeq4Y*jNDZLBa<@4QzmVZ<#Xb~8>Ar8A0Ki{@jY#n2kbjRq9hXK;yF&Mk zeu6)pl=*^!MpJ9(z6?n%Iuwqnz;;I|Kzz4YZw>q~N&$B3TX^fOAtXh2i$i9^(}AWP z4s@6P9Z3o=>~2%U7D>Q`B!VB~rp~Fi*47GLz=AlLF4#*EgCN|~$Q_SBdscs(MZ(Rn z;Q}7E=E#uQ3Z=2%h;9lm&1u+b7Y!UJKG{O9`#Bp0`wn8mfpo(ohM$Pal6Gh4^yNK` zYDDQb{I~)544Ey*}!l|TX{w{?cRpb*lk9+_?$M%vvGK3l=llC!1xrLR<1CkA9GtD`QdFV>-ml_ z!!HxjgF5KjEBK^S4C~TorXWez^=R)!RaJUTeX44DPOK@k+r0CFb@{%t#Ji`U%BK72 zDR^T&TW#}Afn|{6N^$GFC^zIf;>PJGHl2lT<$GgHLch+EiiX50dcdyeE-DH(9P^E0 zRN;|5=U-vxFDE}v`sUpHvi1WSIFMIuz9YVsDzR!UJp6iKOPbMO9ex8`t_i&1!0plz z^C~f)Z$7TVfQ~#|fz=%><$3g2FZ4w@UPMhF%>X_sr}#IgR4?2#-JD^-M{Vi9)oAGS zU#P2awm3jeyBcT9=hCx9xe;o)w&Oj11dgWpGdO8g&8WfwQzs6N%^m%>`X-DzdiJ}4 zrh|@U#l4!24Q@D6+R(Z9(gm5NO$QdoYW_LpV>Qc)vunPtqnRJ24cUv&ml9bE&$frN zBs!e$*g4C>H<@kb&R(vZ!Iimz)=1#>Na@bS!xvKL1|_Fg3A|Y zmb&s5jkN2|k7gTeXPcnl#reNVCPD7`Sw^u@mys%e476DGtW^2SlpTLT)c4=h5aqZR zbwR(QoLpp&=%}B}o<#lBO%TiVL11HDL?fX!`=!Kd*0X5* zlq;}>hbK2WU@QC+80w0g)hf*aKXPKKUW4+TcBRXyN;XuEnCX#{tuhpfO8Px27GR%56j z5o&Y8`w%bu{jKBGSZ%8xp^%K~*|8jGt30db_Rgs`cUZ6AN3ipk%S*R7gU11Zsk&oS zmqj)RY@XFVA#`3De`JHSAK4(#(WNa1Cbqh|w%|;X zSm3}o7_|3-SUPrZum@E#EH5<%<>InkHQN$PbA;0M% zs*jRBA)oh7ht^ac(=PqKosCOBsF^GQO@FmDn-E-0gu58DA>sI%R8Y})fuOcMkNGu7CC4^dls=5wT7_Ls-RC7*6 zs+V$X(P3@+t{P*G^%JUP(X0kX+%=(D;`{U-_HY7Fgv-qvvr4Y;mzlNMvR8QFblTZ5 zI{CNwWo7gupR2PMjaMEVTzSAIU#@olfKsmhWtrD;BzP{Ij`*qanB`>BPJuWC=$F+` z#%jJ4+ctXI?($@pQr_eQ`ocp_t+)O-O|*wuX+G{LWFa2nvyU&s+b^8%&5`{MQ^3`D z(GxzfPthCZE5?l(=Bo*A%(vQZ%rmB!;LUqfQlImJ_0nLRn0asD{yz=Met2O5#Jl%w zTD?`IGAg>7A%?SpL^cj3?BVCgpd^B{CYTKBPR@Tf*gH7q{z#AiyJ zRhAn=f&19u`$iVy%5f&!dY1?eu+iI8FXw7h?cU9AL;q<@A)280XXa5=AfbcZ3t>7^ zOQ9OCL)sfMQu7lD@Nl-A!SpjQ9i^SY$z+Y{_y@Di9o!yE?d82Hr6Z-OQlmSbQKd3_ zEcMf9DYYf*wk}m$GTzq{OP!rCWAg>mX7 zn>BvUInnqKDSkBNcqH!dUJ-}{ZurGGHI8wz=G%gEh-aRnsA@#qVm~2dY5HtA#QccI zz}>lAv0bGS>zZ#9&qbZquU}Luu_SypqWHX=2OAZ}cHAyMR)|hJvVI?*=EmLfJfyA~ zd0@qC!IJsi7;oRr;&W6qPGkwqDXaBnkc*83B3uSXoIpDsynPy$VK5)~jGbLgukiea|Rrjv;h$ zcxZHQrB`AsF7*_dZ`WIYu8>NEsM?_h6mLqvQf^+HqfQcEsguO{hbQWj#F>$WcEt;G zyjU)-qXL~X@Xs`^F7n}&kDKLVQsAGx{7qoKNyMbuY;$prd0(!PW>m3fjM`zgoxK&+ zAcvU1Zig{}>$^F)$gDhOj4_t*BiFn>&&XmQmEzgBXLJ~8&S!4S3d{ZQSPHwWshlzy z+~m#;d_BVvxGlrcmJTX8DBW9hkG!WuMMi0P#$xA!-e&L8w1s^*jY{rjJ-+)qavDl zNWJw0nK>4XPg<|a$&S5VRiNq8okY0codfL|39&Y_c)W-XW)_zzo}eJ*-KdOA&Ye5C0sE>v>Ic2dUR zBSVb@m*LYGNu|YCzBx&n?u4rjUrYHyU4CZqSlSq^N~sYua2fGZBgk`Jgv9Infy z56j3pDHdSbJhc2cuF`D*SKt8A^Elni+Ao;o?==5>(kgDp{;5nB6Ni<9HSU^PE!$ej zV(9p%Ox5uce-;sbTn9yW@PC3>NBTG)5D`wv*x(q>56%|FFG>YR@XhKM(b!tG^qj%o zpk|5x$fB|M%8rTLwYp#AsUJ}bEla5*D6LtutL=hM^Ttc`^aN3>w7-sIV+o)-XiUi# zI8K4WA2X)pvUSWSxE^{0?tFJL4e3T2mkwQ>lc^v0hbj-&RMohd)%f^8G)`I=s2$Ku zKY|`LNCp8iYDQ#QHAB3p5upI(fmVv6RRr;m4J7 zS#x0KyGke&JJ_-u%ptPfs7x zK@NxS+|sw5Eh4L+n6u>z9&}Of*&XlmL$V>_)7jpRW>djyRSVvHEisM?keF3D`kP0H zN$0;P4j33fsjWq&VKX-)HAwKTTiuHaVlj!$H!1{8n2zq8&wT8E$0tZ`nh&&~SxuCrnxEF174wiTqF%)R zg9<+UI zAK~Zbr{(7+t{QR#GT%lJ$#3)eT+7j^tdR#({L(9;hmW$3pCO0S3)~I>DfpqpdghU~ z;8F?;Tc{;<#PF88n@R4yeZ%!T#I58FsS?6e-Xct;UY6QLtP&l%Jsqc5Lt0`DkwwMc zG*7RDDhtY>!4A*3coM(naq6VaRYD3XW}6BW_W4Xf*d0>wAE6ea9)Tt;mn*h;hgGUN zQf1rE%b`)d`c7|DFtl#|P(bI)26X#IBVzszAfW+uGD<@}B4@hs}} z&yydCXbgGK6tyM!2L?9FyFPG_DsQ+i&IFJ+lP11w&h=)RZ`LCoZrK3z&FnQZ*%~L{ zoWUPPl=og>v*3us*O)X>SJ8IjRGXW12vU*i;xla`yQf;|06Z6fSGzq`U6ZOk)4L>b z^ikC?h-z;pLkI;W_$f1D3z*Kb`(WV;ysct9$Vud|L-ZPZ8p>36En>_W&%PKG4P-(| zwDs0EEbW;oi+JQ+l~Ey%Eq$yZCkup zX$}I|h);f5Upio})%u(gOvy5?8Sixn9V}3!u@MnVhT|GXtHZIdzaRo;B-0zi{rkVd z7nb~LS?r@C!qC8oT{wKR{0MB8MeBe)*doNkKZjReGhZ!w!&(Pj2;bEI6~d0DQG@xa zH{H4mwgZg2|02E=sZ}2E68Yedi&QH8$`dRHypuGPhYkM*a+bZn{Q|oHdV;1oIcHa%glw7 zli%cQ~;Ho@k^4j!@_zUx6o3j%WC;2^>%N6`MDdapt%qvO%(j*2oCGX_kkKEXP@<(!COH zKn)!g&>1(g!;ORZLtc!a%y;R%W&R@bhAGrCI3?%FUw~Ub4fD zBT_KwB}$RGVC3R6h|8vai-vI#3Qncz)H++O?6lRah^?J1V*6rF$qmfQwOJbEF(IXJ zHA14CG^b;kyg{_CTK$N7aVUwrxIPQQ!-KWbO%;lnAzTg#fz6WLv6zSw(sPIN{==*> zdoz-`bB7+71~>_O9S@7*EoM(hI6s=Z#Zc$3(z}pqPHAofU(Zq^NCgRFYOWcQ7L2KR zW=PsJCgd1X^UWQ-RI;gb*@Kmq7&{o_YswO)z?eV?2Z6LP0nM(=LZCCvm@wKN!h|s$ z3ura)gpA%{gk(e=7c+by!F-<&0QAHF0DEp?Gc%8^G(1vG-IEj}U0|=KPWlKz{OW#7=b7SR)9435vC+LpCD8q$HY}THbjd@!u|kqSj6# z^!Fj7c4o^AJWA1Ban6+gn$lpf_aN>P! zxr~*4t(;~cjU5j&c(s$+wleBW{lx|LPL`P1E{SqdPE6b>iE>g-O#Hnh%Aq(h@i9r1 zLvdo_N)qYzx6kLD9PI6PdguI(l#rb>DYafwm1Ty)54R`Ml}DaDyJUW@Z;U2=HHy_% z`;EOUVpe5m*z{iEdiV_UB|~i@njUU~uW|&pU|DxO+jmaj_)zHf@pJs6lbSv*9Q}aA zBrF%>5o0=_T296`yzYdb*O%HEUmrT`qR`ItBV@q1%Zx`?j4H}x{tQrCiXCq~<$z$ zld5xX417ZGM640`WU#Yko_Z*8whRa5nm^gf7@RGQ)I~Pm_06Arv5bVE3jq#+F>~a0 zfe1i2qCJ^}bj}th6~!cp>HGlsM4p$^@i7Q5g*VA^c0SWKii7qqX-66D{u2oB;By76 z3}^6t%3(Fc+YDm51=^1r6`U2UZ=4N-iRrqW?X0gs_@V#84|{qqSBp4PajKZMta%t8BjsWJ!c*# z*k#2k8Xht62*x(eSmsv2@*1sA{|0aO-o(Ch8f%Gwjy%InGct(`VYoM&S;&7#+Ra*) zMNIUZ;Q*B&p}C;^Br6pCnG0K-7 zS^9hr6?h#~kw+D|bE)Inu62AuFH*Lan~<~GU1hmxjHy};6Rc;pci=C_nLar>I?DVK zUOpS$<}YgMp)KeM}MU=;{pq zOV<0V){p-L7x^jAu^0RGi?w@su{ZI>PI)nZr0`MLI4#Q1iU`b(qU^D#C_0`-fiL&c?Q@1D^U&k-$LQ$k-Ss4}sigaK?8z&v-Ar_E0 zDZU~I43=>OMYtOfI{~JX~9&s8ixgrb@Ku z6{Wty{G}hzuUtSWs8*(5P@jkjm`X^9kU4WsF*=#SHWkUVnn#L%{eRW65bbs2JCjOR zRx|&kSWAOniM8-vxjeE^L+KWg3lzRIzPJMpQ(8r1s5-u{{DV`bP(o5EU=eI z!A?#}ea(qjX3Ni_H^h(2R&#^=kei<7!ZJhs5aHU0t%OO@FGi)hzzPEEwzv*>H*ImP z=ml2V3qaOU6AJD__v!W&c3F{fQX_<^yp%i$KHZ)RddR~|$)kkG7k10zL)@+2nQw(c zQjzuj2MG`wEpX8(6lh2+F!B@%jHZCOL1wPTykWLkJziv>`R_+?yVo9xToak=a4f#i zJC;7k;6rPqTV_Zm)+)Uazr9ELu&I2|Q3iuVoG6k(a_l=Z%!#wr0ilH?W)+zIs=ViPB*R^R?cr*nMkJ<;xy-Expkr!i2#nHba7s5R?ofEu2NL zmyp8Jprq1yY1F=yAl1h>AB|Z42TBxbJ6nE5PfTp&6~384sl(iDY}Wng7!Q;r_CrN> zDG{s+<=1P*W@*CI1=Q}FMS3V$Oscy!6dW(#7{BYUN%B>Nm;||mb>}_`u95yorR900 zDwltAJG`+l%F`w7KX! z4U%$0K_=S4(jCt4&IJJBTO$g6%&Ni}?y4%YJlD-KirkeExhu;g0H@5hHR@bOxJCxA zXT?n8`b~zB9_F@$fTk)oE3%!NA%QX>kM)pLv!y#03^jBOgMx1u>J4#ykoO1Q@S_b7 z42~?yq62_LH#!Oa)f^|HhJ|G7$OD?-Mz_h+$RW2%T6Tg(am?8QGop8_<)pJsUTAJs zB(5gAWUy}-EUh%B+uD1kZp;7IB1D6dE2J<6h(s3VM;7K`p%+=0W3CY_Hv3za7F%6n zcYI-CWMP41l}wQhf(Vg?S>|B7_5+-MXg}Q?2L=ihPcVpJDP{Ext1hpT&Qx~+&Bf8~ zeyDRMF2uIrJW4=15PeHoR-j4&_k8^1YqoqT{f%C*Q9YwG$R>mWQ{E%T`>j-=%KXw% z0QcAOC?+*mc_KplEfX5mJoFT~Te2K*XMYwdL8=TkjNFA0$;K?iY9! zyBqh?kqz=fX@Y7|1i|)9zA2^(5?E?*TN@rzs-U*u4hS9EGlzFjy%E~Q58{@fB2u%{CS~9vL3n7|y)~~D6kj4qPfL0@4NC#!Aqn3QWer+mQZ0MRdO9pvbT%0PH zbZ2ds+Ubckl?G5(s1VVI!$UVZmUF&PRi1rlBhQWzoxM5(H#DZT1y@tMunr;hBt48Q zth3&EMun<7&wOcsql_r;!L?*d&N2?|COG4h(89m^|EYT$@TjV5@q3aCBuHc;1Pu~3 zN~|cT(V!B88ibH20uurWkq>FBaqejEMVJA!fZ)t1r-!k&m0Rzv+}eL_>utTawATnC zu|br8pP*K;axJyo_DqLXR0>g3=l@%KpEGl255pC#YYR? z$&;*ORQo^}SQ|?l8Az1uK@hNF5COH)}Sa)$wG4~#eXH)ga5g&(dQ>n@k)wGBvS}FbG z5@5#J`%1+oo@lCS<{w^FA(zHPfS~|m+NZ4-@UQXZNwxD2uh=gFw~X0BIs+zh zDwcA`2h5n)EY`N0)z7FwpLvikj#yGUb!eGws$GO246|OBO$5M26f$L&#=)s#rmli5 z!Cl3(&ba;Z88Kr^e$N)6M^7c&!dXXl|s8{dOqE4fu5dvnuizO1gbREw|e1iI& z!>@hj+C{{k&P6J9x%v&M-*M{qR`u)WH`CXl3I`ER7PiXw+p5ha)|bwJrQX%l6!1b6 zY`LTn8&7%oum^ucuIgQz#gHJFZ^Q#6n>%kdVt4XjeKiW3Dgizu^LwEca>Kkp?7s6K z6uWP3@u({p=Gxs-m%4~y#H+~6;hlrnb6T$bl~cx#KL-$L`?4~)qvVyh*U@mQ)udX*K=(HEpkn$gL)#TI5v`cB)? z7NY##R-HAZnOT$WNpXoJvu59LwX~~WwcdDBRyCdh;xaPk+eTc*sR?m#{%+oTFwp3n zOp2JS;(o|e(=gT-{XGwDN1N;NvoSj3>LA~5fmVJDTCJF44 z@)Ze_E;0=53`JBMbY?78)SKMa`7Y(m^=j5$&&^8D>eX;jp4B?MW293$lc=KROV-m@ zi_M9=3xh8{3^Wi#|Jc|1qN^zuC}oR;nOQ4nSX+~_`x94uHLr4th^wdWSd@2`5H}?q zR6`2Y@Hl$RTrYL7iSnCThT2tdb9#@q32bZ2m0Ff2J`AQ*chz=C!xyiXlZ8A9KAT0f zrf2*%vqOfXU>BEN`P&^E$1e>)_d1U!BNpISX1{mDvwBjCwN7`e7gf8;7AqnH3KHJI zV3w5GP|R;&iAXUz7V&7yF$zU2G*^BaYynYT=p1}UgcoAyq-Xb05KGqU&P&XsWcrJ2 zPRTLp*AL~jJpK9?c|A4#`e$C<3r=|QPOxQ{{jJd{?XBG)ec^jx1znF(%VdoJx2;*1 z+91h@J*J)|#cwac7vvz_3dbc2+aK^$QqAzjnFz&1pP@!r4{)pB`c2|QBOITUnU8vq zeX*m!ITCva+>p-yiI?^oHQK(Y*dgnY_Xo<5x@e38VnN`y_MIh_*=bwUIWDe{wPtSZ zO~uu7yeYrk%!_QxZ?EkR|JCf2fgSVGo=*!tHRE^k9KR*6_T447#mD)ocg4M7I>zJY z@Wq#mr;09hh7Fw-pN^@Ad@@wgWU7?ZQ^h2A$UK*gD<>S(_H<5-qSYz4ZnH`v z`}6!Nlc*y|^=+Ecess4=6)icbB1>eSks_{-BJs`s2q!kBD~mhnYpuPi&3bT%W38<( z653Yt$GeXD^)_n`rQ8PY!2xq&(RW$|G1c6oZKSRed)Yzz*tq{u5?wa#D(4#{Hb1NM z`8EJrx*84w-Y}COP48p${#}9RGG*7={xy>7vSrt)caRE`a3Kp_4JKU3@!Gqh%?h0Q z1reLIVMZC$D4VO4Sz%4w$x!b-_TemjI$6?YjQ||uGxK$3n;8GwBd4)@l__V>L9sjW z2mX}1gLDzT)3#HvOAD8!O#ZVVMFf)A{AZSnuQ}=WI5OBZ)iq1F073*bif(3 z-uy3bhI0^GplCcYhgVhv-)K=-K?fnR_b-6x;Xs4Yv>;26M$6) z1Iod{$qOOdRz*2(q5UHHET5~DKtl~n3Eb?3%L zMK6cv*lDts!&v68o1wBN7t(cg*f=iUi@EU%1V>SwOsQ zedlGCuj`hN##cN)KKg6jCbn~PyVB@m$Z-t_J zf=gcCg&<7rb27BjSvjPluXhrnFFi+br&=baavcV1$A#37%-_1^M*r7{rV#%R060j= zVo-%O4d&k*pP0wVrM}176XHZJ5|?va5N~!4|4k505sft@Cy1x6*ITT%Ux@ti?(4)b z(R~PZmCnLPN;fLv*Jk~Bpwh*?t;VI$JQ}?CX1NHvv%U8D(3$3L-=>$^(I=FkrS@$a zh~|e6^*v$B+|iC6r$8m|igbM;c73CEhRS@K@*+JI*q!wZ3J-`R@{@m24(qtdiQ87? z4(Ay;IfgDKxn>~uz$Lwi<@ptzK0JxjW(j*^a#Pd1-pln^#Fx1ZJBe-ZhBj*`O%qFe zu2mxevdtdhAl!81B)tyJ;QrSD$f-US>U}d;Ss9S63L9#;Ie(xxXHyMSRmevvX}*T8 zPjW%y^4)YW$4imF&GJ(xV#Z)T24mH)&b8{cr{#=TaOO6p{p8%sOvC?;H>WN6IYiIh z7T=~FX-k`mnJ@ybro8SntQr8Rd=x+ktKwZ;bUYSoZksiLGU%L-Fh-HoK;HvDgO2*5xA3cs*8ax) zR}Ui26#KNf@)r9)WDi!(bQV?SigJ_>IP5+5s_q8cN#mr7V1B!SUyDg)kr^eaV5QN3 zx5CJb(o`$Sry#TrBZEv_CJ@W}fq1zCF_>?|1X8eEK`dznSg;_uH8{DSl07uy+^ed0 zfe$4|(*SeQXjN`3#mq^S1(QYx^M_3xi}7}FGKSkmLy0k?)SNUPuw}vg#8)^f^$Ypm zfDF{?H-K9ST;mMHc9VcgE2|Xj(FK#n3hXKu>{bPQLNG5Ovg>}kuU?_75#|gB!W9Z= zDdI^%xx8RfX|NLXN`eCu+hL?59~SBx#cMwN3<+@PMj4|EmBC?5#tu;2Kq_qxcvqum zoXJf@_(JRwj!a3soBsTz=0Lvdvw0}d$+vzHd|Ve&EidNTIK!MuR~dL0nOe@+&H%{@ z!Ov(d4dekd*&1x@Gd7`xnK8jh05GZ)gmF@S>ga;0RrKbtN#nRQ0QQY?ZD59sHDgm3 zEM#zuRs!$z+RbS_y4Nu$p!7%mE`qQryKw@%Uyii0YKb1F1XGQ>pc7i>%m3^J?#4}8GNN0yvgXhisC*48tJOU!x}eyRAW zkP&S)eD;zI7MhdG>Jk!)I#`)$LEh+1?4 z`WTyEcTD2@Go9M<5He6P03>k4wSZP?zbK;%-zrvfwy;`w3$6m6le3jOhvQmZnH-K0 z8fq4%qW`>{FIH#3t2K5E8HU1)^(y|)ducQTC z?uo0*g$Uc#1vL0Wb!~}1>N1!0!D(8}@t!Q54eFB4JCJbup4@Ax4iT4VPp;Napc(Mj zb4?{yF&emeCSQ#PuAK=qqoGRQMKc=4>kC6%Wo($BuduZkw~R9yDs@XD_tMfkQp<8$ znw*nbR_waCWTTOV#J_D+f?cZf2Wm3&F14&qG`anixELaG?8POMf3TVo_<#6}I8R&x z5@-6&st?6-Hnn6NhKiVEE~&z_-+V2#WNc(-erm~RV^X6PX8;{M%E-+2C07g*LebKr zu;%MU1OO0E4l_oZ4HFD?3Dul2R$t6BXH*&buHTGthPnc1&KPgRJJn`qSLo*ul zokiTYgO6FX`;;ufOE$;gtYs`(_x4C1r+M{VPqUyi4$ms^L@r0}Dsv9bib^;xif^Rx zW}O!`I7-o#culo%snf@CYF5me^a>w_{FD0REIaM6xEhVu@0WXtxJ3){?nsFY5Og z9PO$72DPRy`Z#M)J)Gq{h!$Nmp5st<`eLWC@Yrm$;jSn=-GVhf=(BPU9}@SiaiooK^hp{4QQ!89KtbOY=%#u5e$Y)joC7KsfhWJB5Ez_Xk*+;gTg(Ry>ysQ(d()Sdqrm302kd8XXo^UJzeb2X-He} zD4{jP0*QIM4q|UzJ&2B9=8xQ7fgDCw8mEh8<@QMicWdEGaU>!IoNZk=U!$Rd&2%{B z#4baBUIx4PFzlken`JGzc2qw$EjZrd<$_)K6Ng>81L<9wC`1mf5YqY?(J@#M9&BV* zK7|EUcqe}SGpt4SVJA&VOWLfn0UNL1EH}aH9~Mbd{iFPUlK+o$v)TGSdxu%S^W6Cd zO?;THe8Qaeq&a&d0c&vOCvNm+AF3(y-9MdvmKboepNdc0+!UYoF#jLr|C9WG94dPd zMZ#<#rNWP}6~w1SQ{jgrFQtt6JUnL9uT6y?O@%k6!cV5cPo%<+TQj~dGC%RJ__!H< z0`+ltt+_HPo;bG~_3Q8%J?){|&%@r@k3(TVR=*LSwhoA#03XYRG(bbDmzrl&!^7q@ zs(Nh9G^%>ktbdG1WKWKK9uK0_EKWoP(Bpzy{X+n?cKn+{WFSETUIUG351CYt$I+E# zo|PrFFD)Cmcp*yh1?qE4?Z=Btm*L@W=@9dsF>i`n#J5MzE>0F1^AB9O^1#TqjoG^? zTl>=Dq2$`Wv>5H&o-y-_B#(E@-jRE1X764$m|bfAfn{ESDD9nJgwlNFlV*5hczEp| z9pOh(Yr>_z=o+YHWaTTK&kxlG_!s7vWR|n+vZ0cB zpGx88zBH#C>$Lg%#^9%sm|{eN8~O2tI4}$!7%^>c@=V+}*6$y~j5#2lVfT&v=)(E? zjqu(P^wFDR@Rm4xGmTaK(=$SPsaN`ME4!;P`z^kVnEh7G>>m1!&goq`*qp!BnBQg2 ze=9l2oWEH;?l$JXAe|L{VVTc&-!4`{?aD6SeO>bK(&E7i!vXlDq(qnw6~qLhPeWwp zZY2gBBMc(p-L;?jVq#EG6F#7=PRx}X&Dl>PH>_P*sz&e4rNx3F%Vy;4QY<_^8S^or zYmM;ck?)L|kK4!6kt+|G;ZkGe3+BqhV^)?Z91k%OMuZR4zHf#%1EmOfm^m)x?*U`w zR%r{qJGYwiUohrxu6>h%98eqHy5wx;Em!UFD#_A2WDg{Zk0pqM%R87EwPBC~KjKl$ zE?HVMW_HQQupl+NWDH1$OGkz`a(b$ne`xV3%TCjkE~7F~qrL;R?}X2&4Ic;tVPoxV z$@48Ue7Gk3D*?1tPa)~UhZTYwv8>t!m;xe-i=NobBP6s`Xx5qaSWc* zt--(Ti+_gI$6@z+DGtroCNF7bE48%PTKQe2+PEUM6gNzh)rKK?JESVUbNFM6;+Z{1 zoAGH+mqw=~au-gH^!A0lNPFWKdRzOIs2sTYd%R;kewU;QrJv*wc`|2vryfl=(j7*qd?*iHP{fRH|D8s)m=sBUU-ra#U+=Ff30eZ zFVYE2+Z1j;$(&lO*U)PyYsbALXlqA#!Vw9-%Gwb=f=8zxY?H^vBg+4oH+-Gui(~^= z?uV=u>w8n}kxpr%M?C(iw%QUJdlXHDRGk*O32X13Ni;Uy&gzqFXL=Hilb(B8j>V}K zHSEuc%ZAz=p^43{zf!j%Wqrn$>*z)tzmeET{IfsV5*u>nXtjt4d=Fo5nY+L-cqz`& zV^!n!75WIW2?$HJQe64<6sj70>$e||^}{#oJqfio94BFS{6rRr z?W%Xp!OdBRLIkdOa3H$Pa#&NCEsV^$;iH~W6s%vtlhH9peq(pa?}oMfx_YkvBR=jd z|B4tXI6|VWIlTEpaLK79h%Dv-g0`*ZPkh==YZ#Ze&8aFz;H%Igvs1puV~hA5($lq{DM;@w=#AAMWFk_NwN&!J*U|wB7aV zm~Z~TfZVQ^o1*d9Iw=?!nDfz$2|%uN@tayy+}zq^#--M#;E0>04X48R={#_=X6G!) zyg{%dbE+dC4;_MaYcmC`-)^9R^*fDNBT4YlM(ieeP_LN6YCL4}$cfoODPw?X#$`ZA zryYTD6=J`%ew|E|+YaV&t8<_)rp%^eGI-{CsTRvoevPt%--xGsHP*vEjciXv-qGR( zu6n8Od`;G1f2xW|``C+Bo5e%4o+5D>9Tk|$E<_F)7|9WrDZ*7CdCf~~fteBs=|cHw zl%Fd3DT^cu!vElIWxz*oCvVJ3Dwd?HvXTZ%Qe{@sDUx(rR?;An+~?opk9i%vr#n(< z%~da+lVrIaISC#FuZ2DwLy3ymw(9ac?mB8UHA#>N2^OJFTzx~wWR%!lB7ldq5qzlg ze;8F<%wweR8ot~feO#R=&Sz=D;1onE+zS0U67)g*W=h#n$!k?PIC#q4N;weYRCJX! z>0fy6uY4K-DPOrout5F^0yx^|2n0*mWBo=1r?l{p)%%Em?6D5ZU-vDhj3J9^2i)2D ztbc^TwvNI!j^O5!oIK@Vv9i}iLb8dk(-lNh`6VD!J_Px`O+zpU@kK?U+8i8vbFg-9 zuwqW+x*}ivagy3OX+&RA4=?LbqwQRBy&so8;;01u;8^n=-=Wfvqw+*19XSR0E9L~cE~?pz&qARc74UL0rM?B+aw$ednh zSup>#-OEl1pUxzznbym(m(M-wgwg{#+|jZYZ^S?6jgeG-s2+P_42@H-V`q#Tv`~?- zHWj>NkjxQMI4vhS@!cQjlYy&6*_ma&kGALgO)9f+{mRnoWR~gm_&=u<1Cl%)XL`;J zXfw~4;?-*NnpNKL|I}O?DokBzjkyCy0BI#}TC3bArjyeEV)||V-QQA~SQVAcNN8sF zuy{T-<{uu{w^;A6Lz%PpaX^${x%+FUm4+`Pq~hYS97F35*3=g*KF@r< zpuR|C1>1&gkJQ7I?oQR#TZlBsae!D{OHY|nd)1Pa)W?Ok`ZDH2zEP#mX%|PX%L|V- z!v|}_Md1ogn&FWJvx|nktOee+vk!y^*G{v-1H0u^4fUzO6l?&C4T~)|-O0AKRo$nR zn0Mo+4i!%FYSm)+y=i6QWyBb9!pVc4ae^wWPJwou?a0AWq2QmgDf~v14`KJE%l?-i zA+`?xRtR||{R!LN+MMzKFWkrJTewsJ;kK3o>U?H2@MuAS?WUIB`o;$ZupoU6KsTY9ewS zh@`P#ATAg1#||KnUaeKE|NoZFGg*`4E9qF%SJwEYHaS~KQFnl)H3xUHh%zD!luHHm z<;rUtCZ*HLhE1!$v`Y5n*mzExqHyY*%mWun`E}LU|29qRvcc4-@>TDunc)qeuTCev z=x<;dzfN&$o@) z9lsyHSocz8sc)0_6c~We;C4fU5>gXWi4-T}u83ca*46Xt= zh-d`v&T7{Pce})d$!=F;;;;-xgI9QfS7iK_W)`pZ_lYKj>Gr@-Xu%$SF2o&E1}8`&F^XSqIS5o=jB zH`uGD;WsD2F-)~HpQ$p#y=bG^!H)>jZ|@bFY`J3F>9cy8(@w8)f+D~1E=OcnKuE_F zDm=!8a^I5IBLAQyCTBGaO5_61mIKU<2#Qtlg^mlLt>T4sFTMe=g3B7wLidP@*3j;x z>k=RE!eO)0dTs;W(hH$h<8gV=uOXZ-+C}E{gcp-G8%$l|d%XBI6_}sM`nfGwYwny2 zr;VXDyzCA560PqQtL}^7ihY~*2oLUaIBs*d@Z1Tp1;;UcyD^Xt>^c~Pzi!=*?htrI z<_xbwZxc5(uAuP8TxLcQ9?FZ5+euR$E1unUU-M_P;vAkyXBsEgo`h5?{v-`=zkEo z%c2YyRljjP3V>u8(s)kv-SvnC&`!+ohP>t{9CHS#P_J*I5{Ml!!~5yxP?7C7cN_hG z3XbaMA4JTQJRQJ;gWlw+H4D6<>Ee$k{MTT?T*2ykKq5OL!wF(WIsHSBn-AV*lV4zN zS7FHTFZ%RJ+^lelqtW~!#f?>7v(OlbzQDN3HPn3<2?yCFsyh4rhRS@5kaSKRn1WqL znP720TYo>n>6~JN+pHprab_MHX~(PgmBvzSuaOnX&dFWeX8q>Z_R&}l985KhTZY5Q zgp_p(Ay4}eg;YkaZP?KjXUOsYMtkvG^@p2rjaArTC`8Z|AYugZ>Ezxzw&6}oau-?^e))#NlHpQg-HWjKx9Xc;q zVIFGpZF;-C_M>IKNH-Tf3eimI1+Vk6?8E12uo!(H!2z@{`aKclDCfGtaS6E$7_6HE z!B6jSnlWZ^=F+*ZkT*@BW(yR}M@8mf++Ft^(5|@yVlBwO896mIK26THXC4>I5jxTL(l-^TtB=W^6J`7VhAVb0? zUvWrUDwIlO4d(8-a@hqjzWL&$K-Do#iExKf~_BiwFe0QtF@tWPLnuMIjiHOo=EMbQ+nu~*18&gXb7?Vod zYpx27Z%*G%NQ*e^lfauaEZt8#cmX07l#5CdKi5sh?k(P2)@uD4SGbX{mwCdM9|yl! z23lx^jazN<_LDeg61MP`-H<2TO4+QN|3O%{?Z>RFuh8hKHbv~LGl0YTdD@zX4@PZ* z962~nNePhDh$obDryWr7-s^}GiAyN#8C?5S|7R%_TfZWTfXau?{M>3teZSX^oNWPJ z*Mk&*6Z}^h8VUTqkNC9bF7qPBk-+b7@&6US_3gDH&FL|@?pA-e_IY1)tYmL2GN$bl znQD|CHQS17ZxKt8@ZH$Q)E}7X$JAvnku*~XLWz_S-YsD=!mn5X;ynP1I3M+gL(?J) z5$^h$tS*<$^lP! z4lem-34UVWDfq<}B6^6d-0$(l?i1XIvsvF;@S33874p^&UUH$-dB4->v) zQ*d-UTKrr&sOR2H6+?)uX`dgdU1ZzXEyb3n#5(hOIUtAUL{{z_8lH(eqp9Z0t{b8| z!he+;qVeKsvIPLfC~B{%4wbbuH3x?V{QtwjlZdLXTR&W^1WKog4`L3eb=%F`EJ5vn z?Jw@wOAz~N-5}&^`(6?5hiI9%8Y0v6w5i^4bOZ-_)*KWDKnpCy&-`P&spz6O+!nrE zxrZwPYqpGt!nWb)909EivS7&Jp%BKYHL&xio|42HKnH`H}6jeK^tFY=JU zB{BKq<730bz57kUW*yil2kRArh4scEv3o2_PR+FL_<*2KRSJ+FK!DKR+AF22tUSNi zF_iPnb$~|QZQ?D>={E6P5_0S4`{_2+WxL-HL`#0w2mTLcDELWtwDPmmE`+cmyZ1So z7z#`eXa>D9l)Ayc`%pDl<9HJ|CPk*`U?}%XF5BbLcKdQ~TNP(XWmTvI(Y4G^c zF3v);pO#j(S%26=OU3VYAOxINH7>dx^oi#VI~2a2ABWxT0!p>_LQp%lx9GIxmCTv;ACv<3RnwgksV%6a(+ zroBLz=MPYDb!zzjnMzJqBM?EZ%)AaX#^RK{OoDLz2hu7~sR*5-`gFKOZk|{u(whl! zs3*8dL4c0N3Q56#KyEtYDanQ&{wbM8$G=-dhqqXZuN)vAy;&3jE%~4x5hV?qs3{QZ z*gm3^MLD9VSm0`0{s#K*U`IME^?tu4R}V7RwEa@~1|54-ct;g90VU&O*t)9?SWK*R%b=W)xy8J-eJ zGj&?2r0urTmZ`K5n@*2YzSlhU5ditEx%%5gEFeYV41^nW%B8`1N(e7!8#$bW&K^_W zt1i{-=`mkM572APKUbXL-+fB(o(0JP&pjl4n;PzAa*OwZTNd~p?o#LUz+;R>phxzt zFTN+9!l9%Hhd1+!RtKME>UEL)uD??y;y78t2+2MYdqN(xx%Wd)NqE5K1N_1HnPjGxH{o*HYpz8(%|kryC%H-d(Fy$2@ZH~%)#Hnf z;bTi+^3|S_zyMZ&nD$BI?3h$HClwjO+=Vm@+@vhmz1>;Gt6Wtfcc z*NkuEcTk>Qk=Hyw82VTkiA#s)MLJ~^iEfaJ$v~!2k$z&I-K#qyRz{<7^uL>fAUy%g zl-(2lKS@uN*Q)7+y?2L<80NzL_`8UYn=T?mH4ur#@NTZ9J@QChd0uEZ*HDyPK(i)@ zaV|XP3vTnM+MBbgH&uMN7VD-Pgi2H(SyQ85XDUPzhrmK-u{oiH=z}}EUQt+e2l1t1n-EoC5c(OXqnMxadn|)Lx4}db(=79e1Uy01Tr=LM;=FdN%A|I?TDw-$Jy|;r(^An;#za_QbUsXdcxdJq8s-6EdGw2aYWc#f z*BH6H2E3A_1-5o-PnbI%^cdIit3 zuT=bmJw8uDmF}gOy@3Dak1}mbpB+Kl^;joQ^=(oeszMtmb?bO!xr#+?MGB!u75 zGP_=#({*mZ^`V>_BA*s5t+odWRu1kHYImB7@Fu^Ntj&-wneD{q!9BVV zQ6kfL!(Tb6`jJ21=Boby^|$uz-Lbm&#WDf^XnbeI%Mx z8CKl+OKdVt;1G#7;_BM@6exRwsj8ytx~A%14k!w1bV~hpFR5owXgK@5xK+XgT2NV9 zVr{zux`Cz3rBH{hQeDvpZ8_p)|+q%y)a`ouislW_Ab)Y9AJdXlmlK2@5f_&v2iV! zxZ?TS7o~#Ae`kYKX6NEx?1+cEl6T8Qt0Mq|kYiTh2&P&H*DBW=>z^dWoM=xo#3CvI zsqi2Imh%ZQP0ih2U-Vl*AoUD8H9SPmLPG`cB-}&iV*>e&P^pt)ux^FvFTv~PJN8SX z1Q#7())ga{=$5&hQk&#V0&Kxq?!qrtBaf+$#{rg}&$F{h%?Y}J>k@kzI|2gH4SoCh z#}idQCmUQ~GH0`_5#uJog9_4WAoZC&zx$nHyihMJso5Z%7`lVjsFk6j(86R|otGo@ zp7ku}D4VpqD(!EMpvoy%H9jFjD8({l#GWUAs8jgsk#vm9v|X9gZE}19t?;oqpTrQ= zzsJ}(`ooMHF!ybjUVSQi_Bva~42>4^N3kR+wWhL{?}eQAT;sZInc91!+ZABd7mU2W=T%jKRx;TE>su_7+XjAn~x9FIb$ zwIc~A4xe&la^;ZxPys^3ti3B^MC=^ZG3(k0Bz4A4AFkIN6yM(&bEX!IFcB+v9+I){ zJjgFf>VXZ31Vh-I<+ucK!ktQ3;Zw0UBolN$bS~;9&h6VW ziFec|?#W1v`jBpadW}!<4TlAVuFybpgJf`^3u1n3o_?x}UlLc|GwgH!Yu0yk@)>rr zKKj3Atx(CpQocx$+YZN4;ItNmP+sR;Ur?QDKp`)YBC20qVBL#RpxCkE5=9OExX7)Q z91Y!t~s4J-$Su zn9$&Q*E+E2R+jJ-d%2geb!-h3KWX#cNSs7MWSz^MD1^RY;3mghfM#XomQa0QGfvFb)cF6i#^z~RG^AgX;=%WTga=t$m=J9QxtUrx zb+=2*d|K9utzY6>fq2AJHbuFZ4G_$gRFA4C?zc{-Z1TojhzrAlL+DECuRIp4XTU_k zlHpdcE>fk!B@WLlM@Qv9UY%ytxg3`O%CLL zK6A8y%q>xsKAydCV}H~XTV}4#6;f(_-qBZtPfl+ zUEKRDJDD^iP?rI#m(v?uG-NpiPhFr@!OUuLqzR3{Fne<41bk_V&~Kt7jW#A08*L?t z)3PgetzXf5T&hkcc#xyg*1$oLkIRYGS-)S_73wB*Gp?>C>{d;9$#Lj*N%ASzN2h&4 z*WAN#ahvsh*{LPHZ*?EP1I3wKIg2*RidEGzQ;}qce67wh(R`Rp5a{uhd>R%1dJ);n zQdebXiQiisN#^0n6i_)DW@YItF(EVi^qPZ{5xiuyUUj??b41iN;>U`3y-dV1vuEw( zN?$jzH0f3eLtD!G5Sy5jHU4mA6~v;6u&AsM>uZG4L4Huwjv7s;iyVCx+Lvba#TWY! zFzq#us;}X~>Qv&_0G0rs@o43EXj_wPS|4BqAfg<5{q!U@l1c89_@R^*oT&KQ3;m9J zp<)6;$wp4~5HS*9dnCaRD6#5&N}XOqOE9>gU(q{giZ@Pl5rjtV`6B{@XyqJLTtbR& z)%hn8TeW0pcmjV)^A}$sx8fj?lPgEs<%+JN+~mqSNL8lL5Giz8xN!A~N}nfmsuMsPk-}PmZ#$}P%lkyNQHac!qDagqiX0t6j=muis#F2sPIdq7!hYr) z%Ij&Gcx)7uA|`ljGHv-M0E)#e{l;s`LR-M(#w<~zQLMnJPtAe-Vy7C{ZZ^y3SKg%)| ztjn$72d8QvAD$x>RAp5Vwkvp3eLHpq(_9rS%B`TzuAm$s>Ao5B04CV6!_+3sQy!m` z(6HxhLE_jI9XNwktcn@2LlibT_wsv0b$nImGVYdgZ6bUj-an0)#TOCzrqzQ(jSZ69 zR9|%E=BY|q*~gK%FM2MRtoc+~Kt3>>XLG$E8^7KL+-~Map4X9a#;li`_I$?e%*bW3 zH+Tmbu>&Lp=iRK~x7W-n`ofG00MvvV9^-ET)I*9T&p_hjdT*~O@x_v?z9!o{polH4 z&RNoIfq9MWCcelEL$gaC&Zh zjq1qF{{K|!y?Oj;3aAsBeYIGs@moLY_&gPl%d;+?93R~vb3RmE(b;q*~&F#rTEAJm@S+}k|BvvH^M^yu>@YU!cL*7Qe^07V;0C3K-u6RAO ztQE!bMHew(X=A*v@}i~e!6}KUywr3G-S$PrM&0^&WpC==MH%CZi7Q*2VXOMBOKw)? zL|Q7M0$5{tc#e>pGZCr^iW;UCJ2$jhAN~TdlKv7{+ZW4wUK1?KHSy{8MPEJ3g<=;k zHj0gjCwQ@u82O=EAF=0UxZf~4rCNjyKl!DcIYL+S_~~CHN9a-oSJUe=1N<9C-a0fd0Ka$-gG3RUU+t(K*JkhrrNph-rCAXTzsv2MP-%l_yS5sC0BXe0ojm%j&BQs*9?(z_|Gd8c| zDU>H8zE%+2dr$}*bk>9^3MWiZs5xE`Z^vF}WJz@;dOAuW) z`sY_DYG<{+>4Ro79c6rQJ{McW-`Z`^XGps64^t^L}N{(8vwz0X)1uBQ*zB05=1Se{UvC|Nefn5P=!;bf-=LT!XepaN6DHje|)OF1lngVUlqCm=h!2e4WNE@X;4}K-SAT~mu~!~OVN#pIvaXIcbeI70g3bu^4MSEPw*_8OoS3g z)v~~D)Dv2!mk3jhYemjfYxOtTw0RYgnT(j~;V!PjxZTQB$d)`3BVE^?Jg3bn{;OCK zONkamn2C*>wYyZEql^^@3@!-4iah{ASVQvW2@j8`WliK*8^scAWB);)vG7+-9*B#n zCN~PzJGDS~#{ZsLwzXNeiUwNqBb#L!JS&`!f{ep9DzZ@ud4=7zv0+0C57$x`Vqgk3 zqSqBP92#_{W(P)XXCVsF(2LXh6?>D@#u6J?g)ji`(fD{w*g1a?mw)5cg9O7^q}t|- z{VN%=+ZXxbp72dZr}VI~K?>Md$DiU^{9#Di&wlo^46{23yk+R~_>21zKI64SGN%%~ zfOpNuW3C&beO2Sq+U~F(>9B9~NGAz2&$9a>ioN&XtV*FlZLzy(y}B{+oLrs|FC^kS z(Hh4kt5%4XY+&pcB>AoV*aKpQ4JduJ0lPl+!F72evv>JopBJK_)pGjQ)@CgK#C%Gm zy#gWN^_1X#^dOJsdO7S=@3IE{IA5e4OU$Fmr6My|UC=3A;O=rgoqVwd5YO)Nlj$L1 zo1OM?x`(QMNe=}G*=;r9-zbB82-+>E1p<nP0b~fD(ye&e{aio^4s5Z8lR>JJ*@;mAS*}GOrg~c^s;eqn{jkY!ex>E^#X*NM?Bax(FZHSoFsR0jB_&>l*fKvn0r+5%>A1nh6JZs6L2oC%Na z9;Lvhf!~B)MzWaeg~I4rVEqcoK6^uz{mmYg$&8979(~5m(ZBW?1}dC?cWj00Zg zAoZ5&YTY4|(j8KBbWN1eTMZouU2NB~oLX|(kGY!_`(bRD1CEJzfYmBjGiRxdB#YtK z@n7IN`Z-z6CxR5bhh5K;{nYcxCVe~#Q-f})R#;wBA^gPTtT}zY@CX&`h3dHCViXp% zS-;2F%T%gPyRx@rLMLQq**XPZR05a8W1~eZ3m4Ht!_s$0N9elkvfiiEVo1D9FQGrj zxLzY=sA=cyu=tpoEU-9$YFGii%SL}k2S+*^`9`#qzwu(mqEuEBn?q7~h#8yA+u+zk z{Dv=g;7b~3`#&-x5Ff}l4$ShVN*M|Qyc6k>&UwJ`EUnN*$0%?k*GrMwca}|BTvQvA z49jYq?=nG0D%ANtYH{H;U2o-imYo?mtePh`R~>Al74%7Rn%xZnx*?Y&OnO?4SMtKF z4y)1~md%?zJX}!^u|?MXqbE=JlB}YS_gA!yqI&8j=h?{YC0|0k>$$ei3OO#1Bxs(V z5ib1#0TTD%McOVab0Ih|hjsjGsY1`WMy*(2O$(AM(zl2z=sM>XQP-MIdDXXwx*8+< zYa(4|+Y>{vsDTn>mVVJCXLp3DYASQxA}R-t*4CTxGI>_?-0YB%igeE5*Atovb(s!b zxzTRK1c2v`M#ocXG;IETt*mV2FG7J!{X(?n&A}n5Mcmu0;A9$6higx0aH?Y;by)v= z1nUEv#e$#dj<+$<)jU$d$0f6gaPhj)DI2GrfVGo)my9+G%*lD;ga~`VSqg$=&~v;F zJ1!z=@t%A&QtQDLXSG!&c@)^X$oA6YhE&H>Quzp#Jc~y_4fI=s)ceEf_fP+dJ64;4 z2jS&X=6^_Yczr4JYxTY{UFJnqW-afkk@8^uLZu0*^Z(s`$oC=WW(p`Rh~ zKXVfc8b{ZB1VtwSKIn9Zoj*4o7a5h+(M5x?(7#Cm9PBb zQ;*>R_33q}$7V3W6XOA<7Mf$&aF#5!vVc;iyVe<=2)94X;Zo8A<$WtJRh5@1P_;XJ z(c2+8X+`MGLVpynV0}V-TlH6?vJY_8II+!Yk{TtwzZ(C~FVvDq*Z5b~K)ObY7rVym z6S6w`t5KOexN5wP`ybz-MoI6l#;Tke)tR`iT$~kz?y+mDOWxLBRbsT^mb>AfE+kb+ zdVf{DxY6CXJ{BXvYi-lMKYxRPR5pmh`KP(gqqJC)IOxg}O*NR={~#wGeYtSARb9ne z77O6!HD3s4m2*zl?q89^$OZ58EvGBF|3;O8J27%;fk>I1V&>9nDm#}J>l-L&BKR;U z*6BLgR2tWQf`sG>Fs^E|&Jy4c102|`E!J~CKe;JA9=^a(X7P7q^?qL~otif58FB`; zQb!K;ZgN$2Oe>wM@!mlB&2rf=+sg)Sc8H!iuR+`umU*(`XDVZH@p7w>>t}7M(G-(S zV$`1rciLAs7pyFU-UYSqFS)S>+diUXikA+zv$Kqw<&4$yjew6_;4$Af zedhLUR(>On!K3#9Zs~NRko^@%=F5@a6^MOh=sk1$m~90+{4R6PF0AI5nIotS`^$pu z5`^Q1TVxg$7l2Um39$oz3wZJJIFrWZI#JL3#Ntps{=})jQO&CX39IptJt(w>|rcy=$?yFl4r^Ian!IKUHu-@$yo^8#ffV zpD?eo)OLx-F}1JL--C)yl>{$9F92w)Gy_T>BNpMoyjE-4LeUe3-BuqNkHJpi(QVdj z3Ty5!@v00SHnkjVTCEMYi=5%;`y-ExVs;(b?#1c;YhH6lWWN_QCE!Zv=3qgq75g&z z#O}2a%hH;H@PKEPq{7>3-63BvxYu6_!`}D`EP$U?SgxzA1cLddHL!{kKNcAzFlnr# zmojv;95ENuaPTK$c5FPQdd2$vW+8*_)daPjsEK-(Zwox1-y4$+7$eWI^e2vWu>O>`~1%aVo+7ZH!M{{m(vwj>+JBY?BK+%Ha zOM=Ra4iR(xRW_{B&RwmzfmT!0b?a%Q+X6N%(-0AbP&bDb*@H zg4nj4qgmhuzTvr)h{i%3WQvb%4(ulp*;R=o$$B^qALPRyZo%5_O*%sEdGWQBuXE%0 z4gE6*5IvP|v3;~;&t+9Tep*n`{nvdmmltFrJ?lYMZD>~byT&!spH2g&v{`onp+!iT zHht#GPM$fvEI!36-cCpDY{EJJ7w_AP)ys`FpB{3^$AHa+@SaEky{p-&&Jg&C zG(k@LxO3t;^hE%}w?k|GmYO?1b^dCuYXz$UWmEB@vblvG_%w3c3+_?N8UrywmR1C@ z1o%%NNEi`w#v<#Dp3g+i7k+`=^`;{Y%k$7}+#A9j*{X32#mMgZoe%|&gxoRTv2Hr> zSt|0)$4N*fy^-m2Qb&I~GR3!1Jy5w8>knt*|1yt<|K`Cy4kjB(0UmMi zh3$Il%_a#GNpMc63WcGm2e%6Nr}xS4@HxzoW6i2`i_p^VTP=$%>%L+-mbZ+s9$)gS^d~s=NvE4y#;W2jM zGATUFT^OfZehQuOr zK(M~ceKWJQ+;2U|gRO$iq1>5kj?PTSiPf%qWu~+4WrqxSQ2hpqrZH9GV%z$e`7ROM zKH+e7#OUbdFMgC``}k{g98|wO>eq``40O9ZpKuU}&eBSacqTG^*2*JHDwN0qS(*L} z#Pml1C*DMocch_6W?6%mSvGMT>-nPiLs6P)tS_Rzc;ncbWu>BFo5T0I$yl%p7BP$B z$%!q2vt(1(0rKdL)!&9fsCwc}<23+tVuia*&0R%khPM?b2Rsw~fUsX!mWb6bNaW+B zgr}B(>}%N|TLKsNlXfktl-zvR^^;cDCyjW-6Z#}}$DW`~kOYs>@gz@}5{Va*ye%G2 zNzth1Yo8~M^TbN7^XG*N2drj`PhO(g65C(Jdq8wYC4$5hV&u0E9z@@P#`_UqG+-qot2gTS`PO1PzBD@%QOlZP;+Mz!>EBH z3}B*ZtwD=>j@wkDC2&oj713f3lvl(NOEzmBe}ucA0ElA`_0`TqCBlU_vsf7$=k>NqX4I_!-w zXwNjn*g2EnU$4hmc)i@?OeI?!W;ec>bvdB0OUM|On zJy*dKeiXTF|A~(eNW}jMSnBvN#CrJPXE;3G4`!o|Oi^6jbm8h6$01P~VBWQY=S5YV zEC!fM%aX`E;13+^&*#=`znLy+vp!xTO-a7X&~28X zJN-(A?p^G3R_-^Cp0F>tZTSlTh>Oap<<{GOaz?MroI2jz_!PvK0iq2>wXeZkU77sI znb_{Z3g_v;s!p}4W86OL9#SwaOpoo~KUio8N; z^$U^Px=uW4k>77woH_HppU`Jse3BBRpnfYngeM^@%0BVkP{mz!m)Wp=+@eZz4ncRqp(B2ft>~^vF!$$V z9a^4%DT-77%humM!keK@qQ<6|-Dc}&csEq^seY>>PSZA9KPM@DBBz5OIei*@!fA#| z4cdz>0$L|SiL_x84 zkv@J-U1a_3j|^}RQPU}kzxyFUIe%KbB*wrW9+{-19CKxqZ;??h>yFiNXey`o|`jH+jN)Uk?-a8eRW^PzTMNfTxhS^ zAn?Mcs-vufI?6$XUT6qCDT2hvk0gOjS$fA48p^ds9;|PB81WxTFX6u-bW0HTO}B!M zKhVVhW*?{2;affiJQXsLRKDu2HJ{578m|agRGc~>NDNe12-PNambK0xGCcb0gan$y z<)Laj{@|$5R7=BbUc@~u!R7E6_Z$j;_1uWi3r!4cki%_?@TOg4?scrTvsrS^_cAC3 zEmoufz#9ZG1Y#c+Y5j>-9HMc%Lp0(q2qsHDx9LVq=CkH&)Q7wHfJGpQ${0aU2i3iu zst-eh?S8#F^|?clOtnl+y);tLn{O%>XH$m7IpONZ3Bhmf>~D(?jApt99+MqoJr4ZD z^r%86(x+U{;;+$JBEK=Nm!$}Yx}i$`9+_fvOpxRaqvf}wj9!JbS-|kg7u}j_g=ubX4*XENm0&W9-vYpZttlX8f&Lz*Y25m{yASM!qd$WlUj> zH}X|B2^NcA(qfZIVDg_IEM_drfgb58T7_+^WIUIQsSe3O_Q_-q9t74n9{%0qsq=(R zSreCRGDm}0XU$On>qrS+=DbPanzMFagRi#1)-O@9W6~uVl;c+^oa&GQe(RNg!#r{d zB0OJIb}{@c48JuE&zwHaP*vHWPP1-Tproj&K43*S|NCfOE^!vp*mPl9H>NLuFXaLV zrkbobK_YnZ$%6R(KT304I0%S`1VmLf2)mCp7Lq^RjK>rR`A+me=?4KZO}b*i1Y^PY z=H}pK0TBz@L&y-xv78oF#N#)SzbQD6w6P3ZJSOkFl<{IrIZn}wa*KAy=23Jj(A~z%URxS=1{O0$XL#!$L;YVY#2oV|%Ha5u0OT6S|$Id!i=vl=Hdm z_T=O)m58ihEDznWE`If9E>C`QkM*6GVF=WmGrzT#1;U~I$nzBh(3?`G6OKGz5-KpJ zl-IPakiQkdd=U#!I(dD(al8?i8fxYgLBAR?0F!ExtT*{9LggcM6G}pb-BZeCmDbFu zlIIF}HWdsUtA#JZnv&f9<{-irS#*95?fQZJS-zk+dhy`jQpqvFlECh3WH%M?)>!55 zvA8+bWkU#`9*{b%IY}j49c63~z{!zz{)r@O7ci2nX+@+{o;{&54EN+Iun6P=Nq8X! zxD;dvph>cMin;Clv}o6MXJLzXV{(@^(pBVVEb>ExD7OywGWq4^*1#G@i1%V?l%8(> zz^XoJrs_ik+5=?L`j1g=b>DJobj`ZTh_%|U$=}7N;(2jm~4~T0AR|8H}{jCo0bFElOIAkR#X(ozgN-h3f(c4 z($DGnFb4+58TQw>Ri$UA6}ws-Z-gpp7L+>bx>4Qn6Qvl_MhYOG?rJ9SN`NBZpBxONqvpQsCIz$>7Syf2@j*V(!%RV54 z|C{nww?gzP!oqCf^o%B_PT?bYY98q&`QEQK#}%<`n#nCo__3yVyqK>|fz|lulHdrk z?5%4qQ-&5*kxuzIG<*TXG(Wyx3Ydy8*h;aRzV7sxu|~j~YU?vs%QI01bk@2mdUBvy zS7uD9beemw`8HlW{(Jy^hRowdoO@{(pogv9HSyV3~D8Lv>xtAoe-9w+~<og$!5hZ<)(=UJU30Wce!b@P3NYG_AWaOX}^d$vlE+@t{^+j*%0OY5_r3`{|%9k zwywv4s;F7Kg61BXxI8~}0sek7aD|d3Cz_vgQJf6jb)%)169?ov=ft8dp2;4MQWXw5 zGI3#ExS$z#k9p03MbI}u*d$rZ4A{^#3u@f|C;;GDv=n&h3Y$Z?|1pvset%qgVtT05 zihP(oF;!xWL}!jE+^`oILV$EvfL~NkZ21`e%CBOBPsldopx5_hSov5P73WG15PIzt zUjAJ1n~Kyfa@&Cu3xBX+>Rf0Ge|**l?`YZ20Yn>P-I{1&V?%`lqVz(tAUl>$=EaOx9<3h?ibshVZU`32~M9VLE7IVJ;7yiF$m{09+@D`e?%lF=W(T5 z8owVt27h@c?9=O!|K4Kv0Me1)zOB1pzc_(AkLhF!M858refXlNpn+YZqI-n~n-8q! zotl!xM#Bn2y_xj~%x?-SW$ux?*OMa8isx8Q`07YcUg!$5buu?<^FNb4%V=mc8YUYJ zbw7^JlW>0dp;gfB8FQ?w zY>4xWhB-#VETdszWX7$)k$fL&aKBB?tWMQDD^Q3!+*Pxx3W*tx=2umL@{uVpYM0k2 zT)71Ws^^<66`d9DF<(KQ~{Ce5Wt6 zeh&{WVZ0y48)cEPa&-bLYEP>oM5*wjS(LR^5xCscBU6;{Y^ltZCF6{6G zf+Kay^TKnw>mRQKCaw!su8mK79H$7?IPrZ*o$t!b`WKA)ha@KXLn2x>>(|y9^=p&w zn7ns|NA%xew2vAhE7uV+!JPKUnsd3K4m-F4bU5P#)_f{LV_)hy&mf#|w&EUckKo^BjLBo*fR_WzXt8JN6f4*HMaG7OvSCPAuv_IpTwkt`2lp-f^Bfabi7=g3 zj}iId(VJzKLDerHCTi+Mfyd2UMuQ&#MmS@*TyE%nsh%P zOtDNyR0#Q@mE8|Ws=S}9nSt78rXhx7q6|UfK47&vJIL0ptH^YnFS_7#B+mK@hA-O0 zi@szLJR?!VOD1Qi)-l4p+|E&!Jj?Yt*FrFOy3$9rS?k)ADO%#_aAEUkx^TWCQNNQe zk}i0P5157H_#an zgc4LLpj4?+O?&b7j6*H96aqx%_g#CRGmkug_TKyX|M`5FoU_kv*yIRvNpO=k%Oc0%bDig}m4~hr|Z(VoPgnbg4&uu6%UzDXH!~df1Jcqm7S& z%c2ogS#*`WqE@|dZWiY`EHj~ewLgXVW&6c@HNBFNjZL67PCeGG22TGvE}O51Nr#W%mr)!HN5^$gqi1=(;QB~z=sHC@|HYO@Q#|NgY^;;Igcj?9 z1vDlCb?jXnE-jnp7XHC@m)lpa*qj`pV4>YWVV&P3iOlIdS&o*bFa>ngDKZZfqNV7X z-#(1mH_VwBdQ!FdPKa9yD+PM1+P4X|FvQ{;sJ@|)8W!2R2}J4QI(r&0EONMEEMG~5r^*iX zxuy4a!Vf*oA`CkHvPWVi6fK{A#HY+ocRt6E4OHr&H9T!`?x_ONt<|QYiu^!U>}-0U zK?!{nCD<}fCMm?^R=@(l)QR7qBth^b!eFRCp{Q3~><>sY;P71$Y93$17|QHzV)3erRf8m(I3q*F z6^t6OOtW7Z(^xM)s>!*U28D~tdK}vfbMdU(%JSlA-d8|zc{qg9`r^SXK&(|v36=I2 za?2ugQTmFJOP$FT<1k*j>=on8*hjoDSrxO*Etgp*{35teY5CY|r)l|YW~mh-iA4)I z<@g-_@&frae-S`~o+RuV@>azGp$=EvXrk=#EM)isl50O*J zRNsU#==Cl3=RT*-pS3s^|4p}c!vBBe$UP_+WtHxRBmXZ+Gm1&cd@vPd7|YiPq2JdV zUfP}r&Q1vs|4X97&kRR&&?3R*zh!k$0-C2ek5(%c*Y`9Zfh~1nsIiYpOOftDJSm-s zSqtZtN&ft|x!|Ry-VmH6vMKOD40XUL}aF|?I z6wL3ig{(Nl9-vPkA(LD7ta<|(dlvv4bOeV=SAVnmbC9W4qk*Y=^8>9+ zAOC<0=;Gsmr4$CSC{LNSEjn>+hbOD8M`%n}E+bOC@R{(DM9|AP*U+~bRx-rME6r7E zF+x0;#|j*syns#lMC3v(Pb%0>_n!uAPH$tMf}B7i{#T{Zh$CTFsvS-Udv_;K`jTIS zaa?lA&*#Nn@(0KMiV8~5^u5PVhNj>)QC87z#i3>QWOr{zf4&ugeK8d(ZX zeM%^Qns+%)R4H;K<%ceaj7$cZ%tS_(tfpG{>-_yimQSlyN~#RCPO22QYqLM8emp15 z)-R}I{Cv3nh}{B(Ynn$>0A|FdAlQ!wIiT@GCh|EP6@5)&x^p1mY$1f5T-zF1V?&4+ zE}o3FB5_1jYBzfhd=I@Wxgt^}_QurshSzJvsjpd9{*aEu zdHC0J>0R!za7&)An`O*c8w6Umi6Sx({Dhafz~!PeXmBhAY|9)8f0Q(IxmhN5M2cpJ z>3;yjJ?JOQ<|6YZMFRelW>JUFvHOwQlQu9t)cz5*$JcaI@KUGE9twVVBCwtV zBBpvtAj`*v*38vkOlR;hNjJ%H1{AMM7i_UXOcyi`oLzQBlKx9^Ms26 zu-*ye%E*RgSSS?&b|}pGnnuTIUrlwzTCPx7gQsAwrsl2vycAL%HKyPi1N4d@nd1qxeNMtP9m3z@_lt)hgfZg+D=ff zsx?3u>#L;R4~lPBCb5bKWS9Xuo3Sf$maBKnW}ZN zTMlt>JUt}{cJsq`j>(1lW4w`eX3bGa+FOcpxuvpXr{*TM&W@C2q+o13*SXYU{>!&i zh{8Q+JckgQJL8?p+Xv~jzgW zEj_?EBdQxm2Q+kCFnPmTxSsLl&_Lk94Byil5g6cOu9(<>nGu1U0lT<{BflNipbhHa zO@Ynvq@BH9vPa1t{Z%uMoXsy9t-EAK1O=2o-JI$+qN-<;+^rGmoZ>)}xCrj%B|Nn( zVfI(HZOTD2NgSUgxRTM|oSLiBUAf#Dx6>2HjH$U8)7sUrb|8(Js|35|qt63__1iie zG_@ytgkbK9eL|BM4sz}_!n|Rk5fwC=wNs2$f=P1%mjp+vhb4sKk%#b7>CJF+GC-=l zlgo)1B3~vGuukQjHqwYnUOU7&s#p2ki=CDHodn1QJhVn+e5AwV`ye>jm@vhdFwvmJ z2{(ps@Fk21OAOuEK!Y}Dj|L_W3r`!7FeZ;&cD_F2&i$)e4PYo4iYy_HWmDN2WxK-9 z2#tUY1fd$F$t*p7ShJ5H-Rk{>ilregFN*bz0m8NLfr;2xIlj=ZhN6LGjk$>g`_#2k zzh?9)62t){iL7z5*`P;m^Mbtk<&)gF+*B#}_;#xl>SN3ky(#39zmsyi%4~9p z(mMUk44F-(ok5x-v)SzAU%DuOAGBYLk)vK2p01oW5cH1~D~nCX!QfHzGb6MoeB0ji z1J%warkeK=*6}8)wJ$|J@GHf~=I)Jr;Axh~!L5-cG$;B6j>yBeHM8B41Y#=dQcj7Ta-L1S~lu^Bp)$3-=t*TnR>r1IN>Rm5Z&OiMg z4Ntpy(;suq@D`GDHkk*aO)slJHr4y0_lz(PsOQigv#HIvX9+b7z(QtH5f(CIjb%$I z5-$ipC4b?w#(g855lWf8?6wxYo<2O)yR9Y?oUxHU|4ZlogtsiIVqiL5_j6ADkvG~z z-Wc{d7DXa&aMv(xMe2T33L2~}SL-`r)ov^H3y_1O8w_(oy<5HeWEqMNHS0zpBNP)H z+`8k*qr$8T`PRuf)NON+kh(ax*Sc$)JrmEI8yX$qM>R?@H#(by|GbBW>da zB=~J}+?Z!Ia03~?*fSIiZ_72tjWI(j!&`Hi2x=O5pD?Bb&8DZRv=yk@b9E}*w8j-27H)dNrC3X{d*W(}p7lo|mL}~cLhS8jaX%?>^u_!*IHi^zHs1W%SV>XEM6inH!ZLt1+r7~s9pvcki z+cb)NT2W*J4GKm6?WcO$W5OjA`Lv=)#=;eTMYh9P3nlS1A(IP8gnM0Bd0&yrsVMa{ z5^KzNun@fGXL4Cu=$gVJ8kq+R+%~yA;ZT{| z%DbBFqW6ht^|Lj8nO1dyN(tN6cAL=L(}IsbJ(t9Xr+Gh3>vri@zi4%H)h2dZ?Z`fV zHC+%?F3v1_X<)!i?^<)_N^8pMqt4B}c#0)HX3gL1Q0dc}N*}XsAt}ic#fGjMYuH5S z=~E;*{M7z~d#%C}pFSB&WW8vS^`iaIKe1l)$NwD-$o`b|V#7}~qB7Qt!8Q25gc!aG z7C~7am*3PnA++L5-4s&xTGwN>t1nn5*NLelC6V$!UMD;aR$Il1)(Jlc$1cAmQq8|{ ziI@x5(QPPKj3-5rsWL+JePa zZ>i7!1j;%O|ilnGb+_MZ;m!kn#@FmO%#d_tjCTa zoNpPX`z>*slKp2)I8v${8Op0%6busKV<)vsq_ds1N?~_PI(Xn(K6CjeiKg=eNBzXC zW0U2^Yb+#{DBkB&WiN1`Td&Xsh~mLVQMU%`$WZ~Slx);$XtTAA%{=335dAC~mV#Dw zV#7EinQyZC;aXlG-8>S*c^San7w%KX((%dN2@oZtR$ba(( zy$b97Bh#l~x|1TOQnR)kk4&Ll^LTt*tGci%;MkgwBc_m(k1FkJs2tQdP8&UmRm9cSlaU4nMud5rv}9k;^*#vSz7{;hai5LL#h7 z*Y0pv#p1LRB&W_W=c$E6WmX=KoWzr|Iz0Q{cS)Dc$!qvaPRum-;}*8weBb=6r)ty| zQM{iLhjElt)8yvP9jogZ+`Gut7w_tVMTWY~uP@-)K0q=r0o5n&#wbG!9O@IlTFMaE zFUs7fQ&wdq(m73(&7ISPv35=qo|>5kpxMDe^_{OJ)d#Zc;$M_IC>?a?Dsw`bS!Az6 z6F4`iSYhIhYb-T16p!+QW(e|%1z;XP=6W{%Gfzt-2RF2Z*%sz6*I7ZNR~ zA(!XcTF*L{G0xpOu0Uq0QB!C%6nWNV8{Ve7b3_?7G8$1vGq=%U{JzQn@P z#KIEngz+gdZ}#howDER)sNOs>Nntz$jux1ap9V2l|Cq6_ueRI1) zrzszAMTeI^M0+e`Y$46w=#xuT{Uki^w;dB!?-@ZR0)@PQPej zKy9jJo<7E>C*Ee|19bGA3mYy z+>JrK#z^+WypzbB(qJv3Hu0R*-+J=x`c7wMLTQ^jyxx*fJTi!A$&Oul$~xL*y^O|1MAj(z)~g$Ed}Bv+M@` z5R)0T+o*mTu7W~nA7sxBWA8T6741#K$Jx&G5)bD|d|cjO-7alV!`zNT^#n|r>Z%p`zjjyY)*dJ?& z#L2-WXkxi4%wFpcT2ZfMb~h#-Y!Zwo{ruX>_FAP(rGdnPls*+cz7!bQvi1KZGI_T2 zaHmM?Ff^BcCn9W80ivTj(038czs=|9azrrp%`JI5SrHBIc5~)VbNUqXk>~knCB6av zyw6F6>oKSBghf?=QcFa@NXz;cu5=aR@p~J8YNORJ)M(K#v^`q=e2veXxdn)Pf0Iq5 zC$g35mNh+pTA7^di@w;LxgB2DSb1jf`ss<#bIGu~XV@4voA#PXUu&^v1+B2gH=^UR z4ey>tGb_9)yRm9>=pVzY_v|_nExJDZT6X+r0_e;1plbY$cYo2G?lX(NVfW+;)stsa ztzJ%KTszcnaK%ZhHoecrx8mw+Z2WtsciUJf2(5_eT|YMVC)5k!rfpmopTICNGL^H6 zLKkyM&YUs}NTBXAbKK~v@uNdU=D4v{-}$c*%yRz z8jbu{#Stxc)>{1UbjpB->>b13sxiGS(Sijv{ym*O=NuS*yk0)$F7Ww(-{m9Y59t0; z=YZL!z4g(@g%Hf@r>$8RX0c!E<%uledu%eIwIiHXud(L-(w0p1^?g#lM2a(;L;I+z zdmRYEQ>Tm5Y16NJ-F8KTWet@n-qvY~BlBQGvs5%~$3E7l7$>T1^#&Fc&gQ>MW#Q_* z;st4L8#6lU-OFxTMx*Erw;Gz3hLc%l^mH z{4*-R_CXYiwNY;y21Ymx7_H+L00e-w~+XP6 zTy;{kmo!+r%eqCo+Z8DF-z;eV^PgnZ+lTx6xqB-Pna5fEPg*bcLzhsmLVl6Ya;*>? z=iJSjrMenx5eCfq?z#YM2Bs##mIcMg(W{%nbnM^B31!NJz*FqL#K=U2Ae&0#N7P!- z{9URrx4xvj?8!vajxS8_UUPI~_`3T%5t&mmF9H|bgvmtY6Y&A$d1y7M;if(3dm=&# zjo}BbZ}LRKJO-}M07uSd+GKqTz+VI9QZG(@*n*uWwSE5{sqLOocE>U;VN^IGeXuWJ zHBf;9)7%`JuDJW&#K>e@GGbJ2jOGl)?yv$nTXpskmo^oEvRJ8$$P1Fx(!5WN2yb_w zf~~wPq$J`j%!PU;=7LOOzRba|5OV>s^hh8s9((7(3 z`dlY^-EDo7q$Is^h^k0-qB(c31Opt9sK`KoQK1-nMjG?-U!?BS8>~Y^x~1+?TMto# z9^!9yn4@ku%8SBIklzCA3!YOo6;`}%^shDN78q_(gYx4x+(ussGb286#>`M^tekLv zXtV>5O*pb4X*PHyjiK!DvFnU_+a>c8I&<%EQ@cw(=jzWz_UF}|KD&FGbxA1M<@6FL zdmY|0UoMIMINVY{Pj;rxnQ;1F^!;mOdb=@ZIoVc5aa9gCpDoo}nJ8zta{jxT^F!s! zI8+NilQ~N7RLP?4161iD47Jl#pxp<-e!!5EN- zY^=mCq?C$kbl{t^Xm2rQZd0!lsWsekI?H&}`ve|LLj@{X*1gzsitX+};M{{8?#LN_ zS@h}=H=giW|Bl}oHR-!`Vk(F9p2!?(!SESh1~|l7FL%&KqxltqJ~EC^;r)eCEHXOe zz&MJRTv_s>-a^EY^-*jep25?lZB*ci$d)4NeSz=Wk??V1;kNp>C%=dMkP|YtNwJ%_ zisBS&eve{mHkeKO^t2svXl!W~`ZnpV-g2pN;;iQ=Vud98w*jiCHnS5UFtx?X$Atyq zl4H*zm!48(9CrQGscbQo#eb1mtW3dhrh*}~Cmjq-6XZnS{^B3j36iGo2_)sQvw(yV zmVv-gA9b2L&s%4cjG8-YK?k1zH z$txfVU8n@vdgei+x}8Z>ALuimy}%Ij-RSk%PF!@^vF+M*G+HX>K={KkKVs*c_e$v^ z9Hdnjsom19=)KA8-j2}0;qQ@ujLMH%EpLP5C3+ni>6!o>7=L^r%oGm>hC4H71q#0K zmXRtPSP}LPe%CbE#4haHPSn?yY3veke;yk2dBWQMRc3fQ^5`NgOgf^Ixj~Tdx76ep z`hC;*d2BjABjt6ZkDnGvYnz(S#2Sm26exokc^YvkCQ00qvHA);qOCo~CxrqR=zl$( zWuc2N`}E~N$9qx{0q3wCPelZr#hWa6c1+4w#o@b(2#A?+Dx#lsR~AYbW0d`6u^DMI{} zTR+FO0}qNFkCv|-vF2Le)~Q9pqzmj+w-wf@C6c-isx#}#qs`^Bgo#frm8h9TzQAe3 zDzolAhy4oC**uY-kgc&&XYw@vJ8uLWloBuIQf*Ci>PV~URhjPh9fw}2oiMW1@4$1|02${CG7@|vk25NvAisLeHKwO%OCDDzWMdgk>NAS%QwjJ zTGg(*RDsipXnzBdnHOHGWYrv+Fe$|$g0sgFW`Ow-E;vU}4zC6T_{{hyu_n8u6lSKt zA##lS)1nG<(E{8jN99^x?13+eozDxX8s_t?n{cN5l&~PS2^cNGaz2a{M2;YBgib3| zX#@_xo0yklN#nu#0y?G!;wZjleZsw56$notNGu$d30b&tSQ@cpTJgW=P%gsL>jM>E zO2C(*xn3mnMC?%psq+32!E-Zu7F_Ho`0lWKWCYFy8 zq6-WVdh2sGhke2F(dM3vV60+Nxtu1#$FhRwhmWCJ3d`G$MAb*3ezw{1BxpQz2eAAX z;}UPA-s^qVMZ`K#p#&$?`{*dXn0C++!w+g{tCb zvVWR4EI!cgC(%$RmW%gH%BA}3X_nJU5`rCcFcmO_XISxvyQFtoD4a>R^=P*}a9Z>54|hrri=d_YANbU92<-ZajL&dh=e_ zn$NGxdf-Kx*=7~P10bOBA2nKg!AS)Ea$PP z^!vQ|g_zQ_za*usqNNt}lo^XgG-6MmSd?olBGm0fwb+$HiMMjaWcb$L#fsIx003bt zCs-of-y=_X{2&-EDvI|HxG@@8RK%*E6X-WD{J=0*@PdR?HV5KUj!SpIBuL2|obc_# zTpISEr!yb?Am~Zbu_og11wE2ol16cv_^`)5g3}>(1KF{!z(OQQ>S`0G<~pYHOR|2x zDwYaWn^`{>+c8a?fw{E7nm{$ycW#w|3Ffgl%E2FkPZ7s(u3-Pf!d&Dn!Bk_et3l0% zZY#ov-O>K)OcmOY<97Qj_r%SkBi%wNn(J+yc333txZAppUO*5%w}mbDBhr>SesqKi zMUgeNcCV$wT2fD)UOIgy^u;ua*XixA+Zz8LatgwbUMiMj)v{$SVk2N(gd)=<>Zxcy z2=|JE*^D(x48PNb(0M(z$F-Y}`XLXs&R55_HoyvA5M{??J;^v>75`nSquPxS*(bnm zUbdp~(||aTWy5ZnBFZEojnx&x0w`$?cd(b12J z*yyEDqRwXQaK+uWj+S&!fz$ftWV}z+UP{V)Nk$1#uNdJCd)Ng<<~y<`aqRzH3ahQ< zbM#yjN0)4z><6Wdc@-_Q=VpW#{U_T)Q8`?|ECnUioPf#2ql)CF7LhdM_}`7woY|Hjl?U0echQe1#`thZ0`!O5h(Q%%BieobzwN> z3SJS8Wd(=J&pEnCu@q7CsfrN4>sW7%r7z*fH%@f$u`r01dg1oAO5{f1*W$|{r!&^M zx+e-2wv+7{Jt~egNE>$wSab(-&c|s3J|YM{b^H>yc0T30;CDrj_+2sYl<-Rk+g=(V z@XJQEP4rpA-el=MfsPXds{smdpJba`@&3F({k-^ev013M&LhBpsKA}wCfkHu7Tu4O zqEA#yD8V04D@ErR_1u$DdsQm4cdF^!S&v$mlRBY+0I{d81(K7f2==vO?;|T4w~kU& z)YEK0d-+K|gGKZLCBGrW6q%C{3*-T@j!oM@#5u(BVb-RBpe!@edvYEoi5acpx2aGu zZ;`resOnM&Q_*eYvYuLLYo63s zrMT4}zR!nK&`qd*vk2ApqTi~HPMX=xsHkrieBOouD3Qwu*S3p;s5D%bJKM0qn#;bZ z>SU-Bc@Ddnxldtp+10~9Oi&K+)J>&nf!+<~-|(~^YHRH^0{q$7+@Lq)lgfP@gzpQt zl*6w1G@?fo&eibP{lztgb9lGcTKaE}YA$KX-b~V|q6PvRO*a6eGhX~>q6$yZHk>cc2LoGLz1!df{(YEnmM zltOB4g3qJB(WJIdZZfu|;j#;-Qly5`U?p{G61%pP&2zA5*|i1oSI#;WCMSRFm>iR^0A%=rtxwKnB?laF+rR6W+W}$X46MPblzV z({3|m2DTeh0Xxu|Co+R-yHq81-@2->8t7B5tyg!o(Su}dGTy1$k_(0iz)lo9>9L#v zy$HG3-HJ{tctr@0iClD%OytD@z6g}jM}-1O@3>HfmLXx&tei(2mLXp?%TOP(_;9MU zgc-xy1UG=xfOKIQh5n^NORbxrCG0^@$}BiPx}Dk-ErqXhr#QsLf~9;T2VWeT zxvxLL?c*138_J4YuR+~YjJA9Dm_e~i+w3H~lqBZxUce3je%GG0+ zf2@q(&)+^pUckxKkEl(JpP6Ii>j^J0BbR>(G$ki$U~x1u5}k<*9z&R#QQeQ73W+5r zeRqSOWF z#!Bk45fh!}4ve|U`uIG>7N(FY-Hc9~_>y8I?^ti@FP8|^(MN^$0%zT1t<|X|pFJkbK>Xj>aV>Y zlp6u89Ti$GQybmRTa-52$b{3v$uv+IDhd|crXbdpkIMFoP1jXss3Q?7O@vA?7)1Rg zTQ5r#2}t&wz^c7?J9;}0u~*ZNb!^R48gojiJDi3&Abjg6gxwNBW5VGFYO#_oHX|AO zlaxN{6{!RbWU;6+Q~U3Wxc@_y;ieK-XneS-)D;?oYODr*SyDYVdoY97oq|e%#r}E( z{*S1G6>^xPU{l@b+S+jRU#bJL6YmCg8I_ao&mDB2J9za-hog@yvVIw53}g``2t)z5 zM#|`g9tyOOqL^&O8uovpm~%&Kp1W++*~V+Py#>IO|0z)?j^! zLS3Dubw+t6eWet(n&F71IYZ%x%C-;nIuv%?Plrp>?M~PpF4RP>--vPvj%u(vW=~wSHwBo;gehRl&x;chGxhp}h`lI4m>cFh!MsVPeeu`+*H7zuM!C679QRVSXh)iD8rLxfT2%&SffNa`}KP8 zaXe7c@Du(S^9rnge2K&FN$&Y*?+3ya&gYsDoaYRDz*(;@JcjSo43Q!J@=3u&H}%Bd z7^|)EQGxnd>65IRxu5JDnx{reRkX+|-5E!La{n5c4~x0F-c$Rct5&RsO@67=#O1Pm z=WxFab{fVNUMF@spRYDMO$4v(DhYMb>8QHd^0#~@P%1AtHpi3}E+c}bFigzFv|?Lv zYEk5PJCOffuv`pxmPYdn10_+c7QyZSLpo|h{YCjOR3oHVbSSY%cW=@jdwi?PgONs^?QZRQPb>r!&a-}CNP@!si# z3zLe(0%yr?O3{r?G$;(I=v;bgNu(d1Pw!$b9naw$rt6Z`{S;u4-uP)pLc*aPes?I> zusWL#c0R1`Okc0c(Q41~>Es4$F7?a0!iE63MaiWT(>4Ulj)uEH0xe zp0d^Z-<8c}e|5wqO~k${2!B%0fajfTabChBj$*c`KRT!~Q}YG-pphi*L+0a(^-b$Z z!b-vSBhN`zbCtp%Sx3&6`5wH~T=g;^a#qP_Gup!M!07YxtWaze8dLC}Dn}v!?21=v z?5I0be1DEoEdzhv#8%KIx{7c1UafBA1ApsxBiXSw|Vo23&9bodTj zM;)i2f4io^ijuQJlqdgl{Tudq*HN3jJ{DP*-)parJ?Y;}ITq@9?w-^z&{-xi>f8FU zn!w$tfc_cz0>i#0si=GX+g=u42l3s@8C4C|HI%pI4EwU8axPODDtMs(lDx{0`|f;f zm&}jid0d|OaI#hibHeP!Qdi4U(|y)rWwzV*jo={6riO3h#$s*#;MaUL*4gsm00vI) z=7iky2O@{zIYvwn{i8)H7$%JBaTHxfRMs(Lm52dKLXc$!BVH{koK!Ht{4cc6VPoH9 zWz%eIIZxtrU6x$&4x$>dUc-A}XTd;JVciM_@}YuI_gXN>HxI|ImFhRDWiV7=uc~UT zO01RjJfW6Og1E@_I4<}M(km=cX4=HxyOfJ@twm(>Jd9oA`=gQdq;XF(qqtn7;~JXE z&u*JDV1Ynti7lmcy}Gwy$EwG}rLMyA^-AnqOIJOJ1K8w! z=TE{MI-P`|eb+R!Mpz5H6m%>$omMtV+B%)*Ca*OS$eor@Tbcos#LD=*hU z@}GpSf2@{Z{|wUoV`Ucp_E)67Z*DTwWXHWALuWiGdk|Ds+Cb4*t64mpUG_Sy5!svM zUM-h<-LO0(@`99EwVvNJly|Q^nA%`H@FCIw9A1b-4#*>7^QES#kdpP@Go7a?#K;xb zM0~WvrWCEo1h&7h%4xV&A50Cs0$O(VvhJ-Y7CDa8=Bb|-nf@?uF%j-zEfXo{US%C z0UKzwABACjP5k54>z#6qIJ~I0H?>hUgcCqU{1Wb$D{dHRx&I3_`g^^pGH_K-jZUp- z?SdZb2g*iRw-N7W?ZGIACe;>|p|X8i7;4nLuEw{l{t%Hx`dECFX~2>o!kxkxc~4$cP!2JaH&|D z%)pZxC_BRE%?;KUq(*N6UOkm*C5|nXMR@3Hhf=|msPWPWw(BnRi`c&@$YR+ve~r|1 z*YFdT_!8%z?{_2ucf@v(x#G|vZ&6lg2u!LF+wRx#Rtit+55pT#@p|7I%SZNoH=Y-M zJ;9|?6hv;rm+M)V-$<5ve5hn!9pWG?PqW;|O{#Ccz>B>ry(M-TFH%?4W>3V;b7SRvybK%{q9%lqr}-dH(aF8U`^2*| z`xiDe2+e;)qG#Qd>_&-^^tR-!dXt!uJcL_vovh{oG9L=|5x{zdw`RvZ;vE$otFFg9 zz=z6Sp-Pc@M~bvEG6iv$WiD`=y+K|6d)WoW9-=LA5#+!WJdJAb93mB&u0~_Z@%UNh zj*3Ik8m^{m-(y=t{~*usH}F1IFwIE!_3?9OUHhSpmd5xuPXx=YHY~^XFs7baEDW+D zICQyxm{6p1A0W*hCFP^ip~$=0|51l(D||c=I?L9!i6IY%ubyU;2OFkfe4#nbjl-Hi zi4ViRtEVU}_uw=*zbNOmbL{M)_+(sDkv)9d9#?ec0SOu6^B;H&T{#ZyCZhmPt85mP zrB#$9c{wjzXm_?hfXd1JX8#ki?3Kx~_wIABwWD}bh6SXR?_w1#{SDMMSZ}Z+jD>uetY-wrMV@4%=VCuKmfh|CzCh|jI5x5OchxeBS6wj!BKQLz& zk9%c~ct2#c;=S;hO~z<+2ER4Y=q&wbiT<-x{xB79)oknB)`+Cgu!M8rNo-+>+{BX+ zkqYEOj-mQvL>^M9E7k96eoa-@^K(_uh&)D8TIZv>uSzPBQaE~ljy_Zow(4i7>_Q@j$`B}wM&|I=-AJ3O7E6V?m&2Y+>-u~d;(V_R@vUTmD_