From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.5 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,NICE_REPLY_A,SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_1 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 0145DC2B9F4 for ; Thu, 17 Jun 2021 06:24:11 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 8245960FE8 for ; Thu, 17 Jun 2021 06:24:10 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 8245960FE8 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id F1A6B89A14; Thu, 17 Jun 2021 06:24:09 +0000 (UTC) Received: from mga12.intel.com (mga12.intel.com [192.55.52.136]) by gabe.freedesktop.org (Postfix) with ESMTPS id 5471B89A14; Thu, 17 Jun 2021 06:24:09 +0000 (UTC) IronPort-SDR: sjpIRBr+KfA3nBPKMOJVj6TloG336i5myg79efx2vaEbA4xqCJ5uk194fTXNp9dkvYGIMj8mWt cRVGROpUR2Dg== X-IronPort-AV: E=McAfee;i="6200,9189,10017"; a="186003111" X-IronPort-AV: E=Sophos;i="5.83,278,1616482800"; d="scan'208";a="186003111" Received: from orsmga006.jf.intel.com ([10.7.209.51]) by fmsmga106.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 16 Jun 2021 23:24:08 -0700 IronPort-SDR: IOO62kzadrtGEFt+BBVWnkBrFDQPRyvia2Jphkbw0nCesVgf/QApykL7OCusn6QUR8uO584FOt T7MUEzQKVfFA== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.83,278,1616482800"; d="scan'208";a="404560738" Received: from irvmail001.ir.intel.com ([10.43.11.63]) by orsmga006.jf.intel.com with ESMTP; 16 Jun 2021 23:24:06 -0700 Received: from [10.249.155.110] (mwajdecz-MOBL.ger.corp.intel.com [10.249.155.110]) by irvmail001.ir.intel.com (8.14.3/8.13.6/MailSET/Hub) with ESMTP id 15H6O5VO007482; Thu, 17 Jun 2021 07:24:05 +0100 Subject: Re: [PATCH 2/3] drm/i915/guc: Update firmware to v62.0.0 To: Daniele Ceraolo Spurio , Matthew Brost , intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org References: <20210616001302.84233-1-matthew.brost@intel.com> <20210616001302.84233-3-matthew.brost@intel.com> From: Michal Wajdeczko Message-ID: <3ccb7fb3-32a9-2bf1-a9df-080ac55ce726@intel.com> Date: Thu, 17 Jun 2021 08:24:04 +0200 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.11.0 MIME-Version: 1.0 In-Reply-To: Content-Type: text/plain; charset=utf-8 Content-Language: en-US Content-Transfer-Encoding: 8bit X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: john.c.harrison@intel.com Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" On 17.06.2021 03:41, Daniele Ceraolo Spurio wrote: > > > On 6/15/2021 5:13 PM, Matthew Brost wrote: >> From: Michal Wajdeczko >> >> Most of the changes to the 62.0.0 firmware revolved around CTB >> communication channel. Conform to the new (stable) CTB protocol. >> >> v2: >>   (Michal) >>    Add values back to kernel DOC for actions >>   (Docs) >>    Add 'CT buffer' back in to fix warning >> >> Signed-off-by: John Harrison >> Signed-off-by: Michal Wajdeczko >> Signed-off-by: Matthew Brost >> --- >>   .../gpu/drm/i915/gt/uc/abi/guc_actions_abi.h  | 107 ++++++ >>   .../gt/uc/abi/guc_communication_ctb_abi.h     | 126 +++++-- >>   .../gt/uc/abi/guc_communication_mmio_abi.h    |  65 ++-- >>   drivers/gpu/drm/i915/gt/uc/intel_guc.c        | 107 ++++-- >>   drivers/gpu/drm/i915/gt/uc/intel_guc_ads.c    |  45 +-- >>   drivers/gpu/drm/i915/gt/uc/intel_guc_ct.c     | 356 +++++++++--------- >>   drivers/gpu/drm/i915/gt/uc/intel_guc_ct.h     |   6 +- >>   drivers/gpu/drm/i915/gt/uc/intel_guc_fwif.h   |  75 +--- >>   drivers/gpu/drm/i915/gt/uc/intel_guc_log.c    |  29 +- >>   drivers/gpu/drm/i915/gt/uc/intel_guc_log.h    |   6 +- >>   drivers/gpu/drm/i915/gt/uc/intel_uc_fw.c      |  26 +- >>   11 files changed, 527 insertions(+), 421 deletions(-) >> >> diff --git a/drivers/gpu/drm/i915/gt/uc/abi/guc_actions_abi.h >> b/drivers/gpu/drm/i915/gt/uc/abi/guc_actions_abi.h >> index 90efef8a73e4..2d6198e63ebe 100644 >> --- a/drivers/gpu/drm/i915/gt/uc/abi/guc_actions_abi.h >> +++ b/drivers/gpu/drm/i915/gt/uc/abi/guc_actions_abi.h >> @@ -6,6 +6,113 @@ >>   #ifndef _ABI_GUC_ACTIONS_ABI_H >>   #define _ABI_GUC_ACTIONS_ABI_H >>   +/** >> + * DOC: HOST2GUC_REGISTER_CTB >> + * >> + * This message is used as part of the `CTB based communication`_ setup. >> + * >> + * This message must be sent as `MMIO HXG Message`_. >> + * >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + *  |   | Bits  | >> Description                                                  | >> + *  >> +===+=======+==============================================================+ >> >> + *  | 0 |    31 | ORIGIN = >> GUC_HXG_ORIGIN_HOST_                                | >> + *  |   >> +-------+--------------------------------------------------------------+ >> + *  |   | 30:28 | TYPE = >> GUC_HXG_TYPE_REQUEST_                                 | >> + *  |   >> +-------+--------------------------------------------------------------+ >> + *  |   | 27:16 | DATA0 = >> MBZ                                                  | >> + *  |   >> +-------+--------------------------------------------------------------+ >> + *  |   |  15:0 | ACTION = _`GUC_ACTION_HOST2GUC_REGISTER_CTB` = >> 0x4505        | >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + *  | 1 | 31:12 | RESERVED = >> MBZ                                               | >> + *  |   >> +-------+--------------------------------------------------------------+ >> + *  |   |  11:8 | **TYPE** - type for the `CT >> Buffer`_                         | >> + *  |   |       >> |                                                              | >> + *  |   |       |   - _`GUC_CTB_TYPE_HOST2GUC` = >> 0                             | >> + *  |   |       |   - _`GUC_CTB_TYPE_GUC2HOST` = >> 1                             | >> + *  |   >> +-------+--------------------------------------------------------------+ >> + *  |   |   7:0 | **SIZE** - size of the `CT Buffer`_ in 4K units >> minus 1      | >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + *  | 2 |  31:0 | **DESC_ADDR** - GGTT address of the `CTB >> Descriptor`_        | >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + *  | 3 |  31:0 | **BUFF_ADDF** - GGTT address of the `CT >> Buffer`_             | >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + * >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + *  |   | Bits  | >> Description                                                  | >> + *  >> +===+=======+==============================================================+ >> >> + *  | 0 |    31 | ORIGIN = >> GUC_HXG_ORIGIN_GUC_                                 | >> + *  |   >> +-------+--------------------------------------------------------------+ >> + *  |   | 30:28 | TYPE = >> GUC_HXG_TYPE_RESPONSE_SUCCESS_                        | >> + *  |   >> +-------+--------------------------------------------------------------+ >> + *  |   |  27:0 | DATA0 = >> MBZ                                                  | >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + */ >> +#define GUC_ACTION_HOST2GUC_REGISTER_CTB        0x4505 >> + >> +#define HOST2GUC_REGISTER_CTB_REQUEST_MSG_LEN        >> (GUC_HXG_REQUEST_MSG_MIN_LEN + 3u) >> +#define HOST2GUC_REGISTER_CTB_REQUEST_MSG_0_MBZ        >> GUC_HXG_REQUEST_MSG_0_DATA0 >> +#define HOST2GUC_REGISTER_CTB_REQUEST_MSG_1_MBZ        (0xfffff << 12) >> +#define HOST2GUC_REGISTER_CTB_REQUEST_MSG_1_TYPE    (0xf << 8) >> +#define   GUC_CTB_TYPE_HOST2GUC                0u >> +#define   GUC_CTB_TYPE_GUC2HOST                1u >> +#define HOST2GUC_REGISTER_CTB_REQUEST_MSG_1_SIZE    (0xff << 0) >> +#define HOST2GUC_REGISTER_CTB_REQUEST_MSG_2_DESC_ADDR    >> GUC_HXG_REQUEST_MSG_n_DATAn >> +#define HOST2GUC_REGISTER_CTB_REQUEST_MSG_3_BUFF_ADDR    >> GUC_HXG_REQUEST_MSG_n_DATAn >> + >> +#define HOST2GUC_REGISTER_CTB_RESPONSE_MSG_LEN        >> GUC_HXG_RESPONSE_MSG_MIN_LEN >> +#define HOST2GUC_REGISTER_CTB_RESPONSE_MSG_0_MBZ    >> GUC_HXG_RESPONSE_MSG_0_DATA0 >> + >> +/** >> + * DOC: HOST2GUC_DEREGISTER_CTB >> + * >> + * This message is used as part of the `CTB based communication`_ >> teardown. >> + * >> + * This message must be sent as `MMIO HXG Message`_. >> + * >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + *  |   | Bits  | >> Description                                                  | >> + *  >> +===+=======+==============================================================+ >> >> + *  | 0 |    31 | ORIGIN = >> GUC_HXG_ORIGIN_HOST_                                | >> + *  |   >> +-------+--------------------------------------------------------------+ >> + *  |   | 30:28 | TYPE = >> GUC_HXG_TYPE_REQUEST_                                 | >> + *  |   >> +-------+--------------------------------------------------------------+ >> + *  |   | 27:16 | DATA0 = >> MBZ                                                  | >> + *  |   >> +-------+--------------------------------------------------------------+ >> + *  |   |  15:0 | ACTION = _`GUC_ACTION_HOST2GUC_DEREGISTER_CTB` = >> 0x4506      | >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + *  | 1 | 31:12 | RESERVED = >> MBZ                                               | >> + *  |   >> +-------+--------------------------------------------------------------+ >> + *  |   |  11:8 | **TYPE** - type of the `CT >> Buffer`_                          | >> + *  |   |       >> |                                                              | >> + *  |   |       | see >> `GUC_ACTION_HOST2GUC_REGISTER_CTB`_                      | >> + *  |   >> +-------+--------------------------------------------------------------+ >> + *  |   |   7:0 | RESERVED = >> MBZ                                               | >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + * >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + *  |   | Bits  | >> Description                                                  | >> + *  >> +===+=======+==============================================================+ >> >> + *  | 0 |    31 | ORIGIN = >> GUC_HXG_ORIGIN_GUC_                                 | >> + *  |   >> +-------+--------------------------------------------------------------+ >> + *  |   | 30:28 | TYPE = >> GUC_HXG_TYPE_RESPONSE_SUCCESS_                        | >> + *  |   >> +-------+--------------------------------------------------------------+ >> + *  |   |  27:0 | DATA0 = >> MBZ                                                  | >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + */ >> +#define GUC_ACTION_HOST2GUC_DEREGISTER_CTB        0x4506 >> + >> +#define HOST2GUC_DEREGISTER_CTB_REQUEST_MSG_LEN        >> (GUC_HXG_REQUEST_MSG_MIN_LEN + 1u) >> +#define HOST2GUC_DEREGISTER_CTB_REQUEST_MSG_0_MBZ    >> GUC_HXG_REQUEST_MSG_0_DATA0 >> +#define HOST2GUC_DEREGISTER_CTB_REQUEST_MSG_1_MBZ    (0xfffff << 12) >> +#define HOST2GUC_DEREGISTER_CTB_REQUEST_MSG_1_TYPE    (0xf << 8) >> +#define HOST2GUC_DEREGISTER_CTB_REQUEST_MSG_1_MBZ2    (0xff << 0) >> + >> +#define HOST2GUC_DEREGISTER_CTB_RESPONSE_MSG_LEN    >> GUC_HXG_RESPONSE_MSG_MIN_LEN >> +#define HOST2GUC_DEREGISTER_CTB_RESPONSE_MSG_0_MBZ    >> GUC_HXG_RESPONSE_MSG_0_DATA0 >> + >> +/* legacy definitions */ >> + >>   enum intel_guc_action { >>       INTEL_GUC_ACTION_DEFAULT = 0x0, >>       INTEL_GUC_ACTION_REQUEST_PREEMPTION = 0x2, >> diff --git >> a/drivers/gpu/drm/i915/gt/uc/abi/guc_communication_ctb_abi.h >> b/drivers/gpu/drm/i915/gt/uc/abi/guc_communication_ctb_abi.h >> index d38935f47ecf..29fc93a8b5be 100644 >> --- a/drivers/gpu/drm/i915/gt/uc/abi/guc_communication_ctb_abi.h >> +++ b/drivers/gpu/drm/i915/gt/uc/abi/guc_communication_ctb_abi.h >> @@ -7,6 +7,110 @@ >>   #define _ABI_GUC_COMMUNICATION_CTB_ABI_H >>     #include >> +#include >> + >> +#include "guc_messages_abi.h" >> + >> +/** >> + * DOC: CT Buffer >> + * >> + * Circular buffer used to send / receive CTBs (H2G or G2H) > > nit: the CTB is not used to send CTBs, but to send messages. Can fix > while pushing. and to be more precisely, not H2G or G2H messages, but " to send generic `CTB Message`_ " as H2G or G2H (again more precisely `CTB HXG Message`_) is just a specific type of message > > For the rest I couldn't spot anything that didn't match what was already > reviewed, so: > > Reviewed-by: Daniele Ceraolo Spurio > > Daniele > >> + */ >> + >> +/** >> + * DOC: CTB Descriptor >> + * >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + *  |   | Bits  | >> Description                                                  | >> + *  >> +===+=======+==============================================================+ >> >> + *  | 0 |  31:0 | **HEAD** - offset (in dwords) to the last dword >> that was     | >> + *  |   |       | read from the `CT >> Buffer`_.                                  | >> + *  |   |       | It can only be updated by the >> receiver.                      | >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + *  | 1 |  31:0 | **TAIL** - offset (in dwords) to the last dword >> that was     | >> + *  |   |       | written to the `CT >> Buffer`_.                                 | >> + *  |   |       | It can only be updated by the >> sender.                        | >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + *  | 2 |  31:0 | **STATUS** - status of the >> CTB                               | >> + *  |   |       >> |                                                              | >> + *  |   |       |   - _`GUC_CTB_STATUS_NO_ERROR` = 0 (normal >> operation)        | >> + *  |   |       |   - _`GUC_CTB_STATUS_OVERFLOW` = 1 (head/tail too >> large)     | >> + *  |   |       |   - _`GUC_CTB_STATUS_UNDERFLOW` = 2 (truncated >> message)      | >> + *  |   |       |   - _`GUC_CTB_STATUS_MISMATCH` = 4 (head/tail >> modified)      | >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + *  |...|       | RESERVED = >> MBZ                                               | >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + *  | 15|  31:0 | RESERVED = >> MBZ                                               | >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + */ >> + >> +struct guc_ct_buffer_desc { >> +    u32 head; >> +    u32 tail; >> +    u32 status; >> +#define GUC_CTB_STATUS_NO_ERROR                0 >> +#define GUC_CTB_STATUS_OVERFLOW                (1 << 0) >> +#define GUC_CTB_STATUS_UNDERFLOW            (1 << 1) >> +#define GUC_CTB_STATUS_MISMATCH                (1 << 2) >> +    u32 reserved[13]; >> +} __packed; >> +static_assert(sizeof(struct guc_ct_buffer_desc) == 64); >> + >> +/** >> + * DOC: CTB Message >> + * >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + *  |   | Bits  | >> Description                                                  | >> + *  >> +===+=======+==============================================================+ >> >> + *  | 0 | 31:16 | **FENCE** - message >> identifier                               | >> + *  |   >> +-------+--------------------------------------------------------------+ >> + *  |   | 15:12 | **FORMAT** - format of the CTB >> message                       | >> + *  |   |       |  - _`GUC_CTB_FORMAT_HXG` = 0 - see `CTB HXG >> Message`_        | >> + *  |   >> +-------+--------------------------------------------------------------+ >> + *  |   |  11:8 | >> **RESERVED**                                                 | >> + *  |   >> +-------+--------------------------------------------------------------+ >> + *  |   |   7:0 | **NUM_DWORDS** - length of the CTB message (w/o >> header)      | >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + *  | 1 |  31:0 | optional (depends on >> FORMAT)                                 | >> + *  >> +---+-------+                                                              >> | >> + *  |...|       >> |                                                              | >> + *  >> +---+-------+                                                              >> | >> + *  | n |  31:0 >> |                                                              | >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + */ >> + >> +#define GUC_CTB_MSG_MIN_LEN            1u >> +#define GUC_CTB_MSG_MAX_LEN            256u >> +#define GUC_CTB_MSG_0_FENCE            (0xffff << 16) >> +#define GUC_CTB_MSG_0_FORMAT            (0xf << 12) >> +#define   GUC_CTB_FORMAT_HXG            0u >> +#define GUC_CTB_MSG_0_RESERVED            (0xf << 8) >> +#define GUC_CTB_MSG_0_NUM_DWORDS        (0xff << 0) >> + >> +/** >> + * DOC: CTB HXG Message >> + * >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + *  |   | Bits  | >> Description                                                  | >> + *  >> +===+=======+==============================================================+ >> >> + *  | 0 | 31:16 | >> FENCE                                                        | >> + *  |   >> +-------+--------------------------------------------------------------+ >> + *  |   | 15:12 | FORMAT = >> GUC_CTB_FORMAT_HXG_                                 | >> + *  |   >> +-------+--------------------------------------------------------------+ >> + *  |   |  11:8 | RESERVED = >> MBZ                                               | >> + *  |   >> +-------+--------------------------------------------------------------+ >> + *  |   |   7:0 | NUM_DWORDS = length (in dwords) of the embedded HXG >> message  | >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + *  | 1 |  31:0 |  >> +--------------------------------------------------------+  | >> + *  +---+-------+  >> |                                                        |  | >> + *  |...|       |  |  Embedded `HXG >> Message`_                               |  | >> + *  +---+-------+  >> |                                                        |  | >> + *  | n |  31:0 |  >> +--------------------------------------------------------+  | >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + */ >> + >> +#define GUC_CTB_HXG_MSG_MIN_LEN        (GUC_CTB_MSG_MIN_LEN + >> GUC_HXG_MSG_MIN_LEN) >> +#define GUC_CTB_HXG_MSG_MAX_LEN        GUC_CTB_MSG_MAX_LEN >>     /** >>    * DOC: CTB based communication >> @@ -60,28 +164,6 @@ >>    * - **flags**, holds various bits to control message handling >>    */ >>   -/* >> - * Describes single command transport buffer. >> - * Used by both guc-master and clients. >> - */ >> -struct guc_ct_buffer_desc { >> -    u32 addr;        /* gfx address */ >> -    u64 host_private;    /* host private data */ >> -    u32 size;        /* size in bytes */ >> -    u32 head;        /* offset updated by GuC*/ >> -    u32 tail;        /* offset updated by owner */ >> -    u32 is_in_error;    /* error indicator */ >> -    u32 reserved1; >> -    u32 reserved2; >> -    u32 owner;        /* id of the channel owner */ >> -    u32 owner_sub_id;    /* owner-defined field for extra tracking */ >> -    u32 reserved[5]; >> -} __packed; >> - >> -/* Type of command transport buffer */ >> -#define INTEL_GUC_CT_BUFFER_TYPE_SEND    0x0u >> -#define INTEL_GUC_CT_BUFFER_TYPE_RECV    0x1u >> - >>   /* >>    * Definition of the command transport message header (DW0) >>    * >> diff --git >> a/drivers/gpu/drm/i915/gt/uc/abi/guc_communication_mmio_abi.h >> b/drivers/gpu/drm/i915/gt/uc/abi/guc_communication_mmio_abi.h >> index be066a62e9e0..bbf1ddb77434 100644 >> --- a/drivers/gpu/drm/i915/gt/uc/abi/guc_communication_mmio_abi.h >> +++ b/drivers/gpu/drm/i915/gt/uc/abi/guc_communication_mmio_abi.h >> @@ -7,46 +7,43 @@ >>   #define _ABI_GUC_COMMUNICATION_MMIO_ABI_H >>     /** >> - * DOC: MMIO based communication >> + * DOC: GuC MMIO based communication >>    * >> - * The MMIO based communication between Host and GuC uses software >> scratch >> - * registers, where first register holds data treated as message header, >> - * and other registers are used to hold message payload. >> + * The MMIO based communication between Host and GuC relies on special >> + * hardware registers which format could be defined by the software >> + * (so called scratch registers). >>    * >> - * For Gen9+, GuC uses software scratch registers 0xC180-0xC1B8, >> - * but no H2G command takes more than 8 parameters and the GuC FW >> - * itself uses an 8-element array to store the H2G message. >> + * Each MMIO based message, both Host to GuC (H2G) and GuC to Host (G2H) >> + * messages, which maximum length depends on number of available scratch >> + * registers, is directly written into those scratch registers. >>    * >> - *      +-----------+---------+---------+---------+ >> - *      |  MMIO[0]  | MMIO[1] |   ...   | MMIO[n] | >> - *      +-----------+---------+---------+---------+ >> - *      | header    |      optional payload       | >> - *      +======+====+=========+=========+=========+ >> - *      | 31:28|type|         |         |         | >> - *      +------+----+         |         |         | >> - *      | 27:16|data|         |         |         | >> - *      +------+----+         |         |         | >> - *      |  15:0|code|         |         |         | >> - *      +------+----+---------+---------+---------+ >> + * For Gen9+, there are 16 software scratch registers 0xC180-0xC1B8, >> + * but no H2G command takes more than 4 parameters and the GuC firmware >> + * itself uses an 4-element array to store the H2G message. >>    * >> - * The message header consists of: >> + * For Gen11+, there are additional 4 registers 0x190240-0x19024C, which >> + * are, regardless on lower count, preferred over legacy ones. >>    * >> - * - **type**, indicates message type >> - * - **code**, indicates message code, is specific for **type** >> - * - **data**, indicates message data, optional, depends on **code** >> - * >> - * The following message **types** are supported: >> - * >> - * - **REQUEST**, indicates Host-to-GuC request, requested GuC action >> code >> - *   must be priovided in **code** field. Optional action specific >> parameters >> - *   can be provided in remaining payload registers or **data** field. >> - * >> - * - **RESPONSE**, indicates GuC-to-Host response from earlier GuC >> request, >> - *   action response status will be provided in **code** field. Optional >> - *   response data can be returned in remaining payload registers or >> **data** >> - *   field. >> + * The MMIO based communication is mainly used during driver >> initialization >> + * phase to setup the `CTB based communication`_ that will be used >> afterwards. >>    */ >>   -#define GUC_MAX_MMIO_MSG_LEN        8 >> +#define GUC_MAX_MMIO_MSG_LEN        4 >> + >> +/** >> + * DOC: MMIO HXG Message >> + * >> + * Format of the MMIO messages follows definitions of `HXG Message`_. >> + * >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + *  |   | Bits  | >> Description                                                  | >> + *  >> +===+=======+==============================================================+ >> >> + *  | 0 |  31:0 |  >> +--------------------------------------------------------+  | >> + *  +---+-------+  >> |                                                        |  | >> + *  |...|       |  |  Embedded `HXG >> Message`_                               |  | >> + *  +---+-------+  >> |                                                        |  | >> + *  | n |  31:0 |  >> +--------------------------------------------------------+  | >> + *  >> +---+-------+--------------------------------------------------------------+ >> >> + */ >>     #endif /* _ABI_GUC_COMMUNICATION_MMIO_ABI_H */ >> diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc.c >> b/drivers/gpu/drm/i915/gt/uc/intel_guc.c >> index f147cb389a20..6661dcb02239 100644 >> --- a/drivers/gpu/drm/i915/gt/uc/intel_guc.c >> +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc.c >> @@ -219,24 +219,19 @@ static u32 guc_ctl_log_params_flags(struct >> intel_guc *guc) >>         BUILD_BUG_ON(!CRASH_BUFFER_SIZE); >>       BUILD_BUG_ON(!IS_ALIGNED(CRASH_BUFFER_SIZE, UNIT)); >> -    BUILD_BUG_ON(!DPC_BUFFER_SIZE); >> -    BUILD_BUG_ON(!IS_ALIGNED(DPC_BUFFER_SIZE, UNIT)); >> -    BUILD_BUG_ON(!ISR_BUFFER_SIZE); >> -    BUILD_BUG_ON(!IS_ALIGNED(ISR_BUFFER_SIZE, UNIT)); >> +    BUILD_BUG_ON(!DEBUG_BUFFER_SIZE); >> +    BUILD_BUG_ON(!IS_ALIGNED(DEBUG_BUFFER_SIZE, UNIT)); >>         BUILD_BUG_ON((CRASH_BUFFER_SIZE / UNIT - 1) > >>               (GUC_LOG_CRASH_MASK >> GUC_LOG_CRASH_SHIFT)); >> -    BUILD_BUG_ON((DPC_BUFFER_SIZE / UNIT - 1) > >> -            (GUC_LOG_DPC_MASK >> GUC_LOG_DPC_SHIFT)); >> -    BUILD_BUG_ON((ISR_BUFFER_SIZE / UNIT - 1) > >> -            (GUC_LOG_ISR_MASK >> GUC_LOG_ISR_SHIFT)); >> +    BUILD_BUG_ON((DEBUG_BUFFER_SIZE / UNIT - 1) > >> +            (GUC_LOG_DEBUG_MASK >> GUC_LOG_DEBUG_SHIFT)); >>         flags = GUC_LOG_VALID | >>           GUC_LOG_NOTIFY_ON_HALF_FULL | >>           FLAG | >>           ((CRASH_BUFFER_SIZE / UNIT - 1) << GUC_LOG_CRASH_SHIFT) | >> -        ((DPC_BUFFER_SIZE / UNIT - 1) << GUC_LOG_DPC_SHIFT) | >> -        ((ISR_BUFFER_SIZE / UNIT - 1) << GUC_LOG_ISR_SHIFT) | >> +        ((DEBUG_BUFFER_SIZE / UNIT - 1) << GUC_LOG_DEBUG_SHIFT) | >>           (offset << GUC_LOG_BUF_ADDR_SHIFT); >>         #undef UNIT >> @@ -376,29 +371,27 @@ void intel_guc_fini(struct intel_guc *guc) >>   /* >>    * This function implements the MMIO based host to GuC interface. >>    */ >> -int intel_guc_send_mmio(struct intel_guc *guc, const u32 *action, u32 >> len, >> +int intel_guc_send_mmio(struct intel_guc *guc, const u32 *request, >> u32 len, >>               u32 *response_buf, u32 response_buf_size) >>   { >> +    struct drm_i915_private *i915 = guc_to_gt(guc)->i915; >>       struct intel_uncore *uncore = guc_to_gt(guc)->uncore; >> -    u32 status; >> +    u32 header; >>       int i; >>       int ret; >>         GEM_BUG_ON(!len); >>       GEM_BUG_ON(len > guc->send_regs.count); >>   -    /* We expect only action code */ >> -    GEM_BUG_ON(*action & ~INTEL_GUC_MSG_CODE_MASK); >> - >> -    /* If CT is available, we expect to use MMIO only during >> init/fini */ >> -    GEM_BUG_ON(*action != >> INTEL_GUC_ACTION_REGISTER_COMMAND_TRANSPORT_BUFFER && >> -           *action != >> INTEL_GUC_ACTION_DEREGISTER_COMMAND_TRANSPORT_BUFFER); >> +    GEM_BUG_ON(FIELD_GET(GUC_HXG_MSG_0_ORIGIN, request[0]) != >> GUC_HXG_ORIGIN_HOST); >> +    GEM_BUG_ON(FIELD_GET(GUC_HXG_MSG_0_TYPE, request[0]) != >> GUC_HXG_TYPE_REQUEST); >>         mutex_lock(&guc->send_mutex); >>       intel_uncore_forcewake_get(uncore, guc->send_regs.fw_domains); >>   +retry: >>       for (i = 0; i < len; i++) >> -        intel_uncore_write(uncore, guc_send_reg(guc, i), action[i]); >> +        intel_uncore_write(uncore, guc_send_reg(guc, i), request[i]); >>         intel_uncore_posting_read(uncore, guc_send_reg(guc, i - 1)); >>   @@ -410,30 +403,74 @@ int intel_guc_send_mmio(struct intel_guc *guc, >> const u32 *action, u32 len, >>        */ >>       ret = __intel_wait_for_register_fw(uncore, >>                          guc_send_reg(guc, 0), >> -                       INTEL_GUC_MSG_TYPE_MASK, >> -                       INTEL_GUC_MSG_TYPE_RESPONSE << >> -                       INTEL_GUC_MSG_TYPE_SHIFT, >> -                       10, 10, &status); >> -    /* If GuC explicitly returned an error, convert it to -EIO */ >> -    if (!ret && !INTEL_GUC_MSG_IS_RESPONSE_SUCCESS(status)) >> -        ret = -EIO; >> +                       GUC_HXG_MSG_0_ORIGIN, >> +                       FIELD_PREP(GUC_HXG_MSG_0_ORIGIN, >> +                              GUC_HXG_ORIGIN_GUC), >> +                       10, 10, &header); >> +    if (unlikely(ret)) { >> +timeout: >> +        drm_err(&i915->drm, "mmio request %#x: no reply %x\n", >> +            request[0], header); >> +        goto out; >> +    } >>   -    if (ret) { >> -        DRM_ERROR("MMIO: GuC action %#x failed with error %d %#x\n", >> -              action[0], ret, status); >> +    if (FIELD_GET(GUC_HXG_MSG_0_TYPE, header) == >> GUC_HXG_TYPE_NO_RESPONSE_BUSY) { >> +#define done ({ header = intel_uncore_read(uncore, guc_send_reg(guc, >> 0)); \ >> +        FIELD_GET(GUC_HXG_MSG_0_ORIGIN, header) != GUC_HXG_ORIGIN_GUC >> || \ >> +        FIELD_GET(GUC_HXG_MSG_0_TYPE, header) != >> GUC_HXG_TYPE_NO_RESPONSE_BUSY; }) >> + >> +        ret = wait_for(done, 1000); >> +        if (unlikely(ret)) >> +            goto timeout; >> +        if (unlikely(FIELD_GET(GUC_HXG_MSG_0_ORIGIN, header) != >> +                       GUC_HXG_ORIGIN_GUC)) >> +            goto proto; >> +#undef done >> +    } >> + >> +    if (FIELD_GET(GUC_HXG_MSG_0_TYPE, header) == >> GUC_HXG_TYPE_NO_RESPONSE_RETRY) { >> +        u32 reason = FIELD_GET(GUC_HXG_RETRY_MSG_0_REASON, header); >> + >> +        drm_dbg(&i915->drm, "mmio request %#x: retrying, reason %u\n", >> +            request[0], reason); >> +        goto retry; >> +    } >> + >> +    if (FIELD_GET(GUC_HXG_MSG_0_TYPE, header) == >> GUC_HXG_TYPE_RESPONSE_FAILURE) { >> +        u32 hint = FIELD_GET(GUC_HXG_FAILURE_MSG_0_HINT, header); >> +        u32 error = FIELD_GET(GUC_HXG_FAILURE_MSG_0_ERROR, header); >> + >> +        drm_err(&i915->drm, "mmio request %#x: failure %x/%u\n", >> +            request[0], error, hint); >> +        ret = -ENXIO; >> +        goto out; >> +    } >> + >> +    if (FIELD_GET(GUC_HXG_MSG_0_TYPE, header) != >> GUC_HXG_TYPE_RESPONSE_SUCCESS) { >> +proto: >> +        drm_err(&i915->drm, "mmio request %#x: unexpected reply %#x\n", >> +            request[0], header); >> +        ret = -EPROTO; >>           goto out; >>       } >>         if (response_buf) { >> -        int count = min(response_buf_size, guc->send_regs.count - 1); >> +        int count = min(response_buf_size, guc->send_regs.count); >>   -        for (i = 0; i < count; i++) >> +        GEM_BUG_ON(!count); >> + >> +        response_buf[0] = header; >> + >> +        for (i = 1; i < count; i++) >>               response_buf[i] = intel_uncore_read(uncore, >> -                                guc_send_reg(guc, i + 1)); >> -    } >> +                                guc_send_reg(guc, i)); >>   -    /* Use data from the GuC response as our return value */ >> -    ret = INTEL_GUC_MSG_TO_DATA(status); >> +        /* Use number of copied dwords as our return value */ >> +        ret = count; >> +    } else { >> +        /* Use data from the GuC response as our return value */ >> +        ret = FIELD_GET(GUC_HXG_RESPONSE_MSG_0_DATA0, header); >> +    } >>     out: >>       intel_uncore_forcewake_put(uncore, guc->send_regs.fw_domains); >> diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc_ads.c >> b/drivers/gpu/drm/i915/gt/uc/intel_guc_ads.c >> index 9abfbc6edbd6..b82145652d57 100644 >> --- a/drivers/gpu/drm/i915/gt/uc/intel_guc_ads.c >> +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc_ads.c >> @@ -24,10 +24,6 @@ >>    *      +---------------------------------------+ >>    *      | guc_gt_system_info                    | >>    *      +---------------------------------------+ >> - *      | guc_clients_info                      | >> - *      +---------------------------------------+ >> - *      | guc_ct_pool_entry[size]               | >> - *      +---------------------------------------+ >>    *      | padding                               | >>    *      +---------------------------------------+ <== 4K aligned >>    *      | private data                          | >> @@ -39,8 +35,6 @@ struct __guc_ads_blob { >>       struct guc_ads ads; >>       struct guc_policies policies; >>       struct guc_gt_system_info system_info; >> -    struct guc_clients_info clients_info; >> -    struct guc_ct_pool_entry ct_pool[GUC_CT_POOL_SIZE]; >>   } __packed; >>     static u32 guc_ads_private_data_size(struct intel_guc *guc) >> @@ -59,38 +53,15 @@ static u32 guc_ads_blob_size(struct intel_guc *guc) >>              guc_ads_private_data_size(guc); >>   } >>   -static void guc_policy_init(struct guc_policy *policy) >> -{ >> -    policy->execution_quantum = POLICY_DEFAULT_EXECUTION_QUANTUM_US; >> -    policy->preemption_time = POLICY_DEFAULT_PREEMPTION_TIME_US; >> -    policy->fault_time = POLICY_DEFAULT_FAULT_TIME_US; >> -    policy->policy_flags = 0; >> -} >> - >>   static void guc_policies_init(struct guc_policies *policies) >>   { >> -    struct guc_policy *policy; >> -    u32 p, i; >> - >> -    policies->dpc_promote_time = POLICY_DEFAULT_DPC_PROMOTE_TIME_US; >> -    policies->max_num_work_items = POLICY_MAX_NUM_WI; >> - >> -    for (p = 0; p < GUC_CLIENT_PRIORITY_NUM; p++) { >> -        for (i = 0; i < GUC_MAX_ENGINE_CLASSES; i++) { >> -            policy = &policies->policy[p][i]; >> - >> -            guc_policy_init(policy); >> -        } >> -    } >> - >> +    policies->dpc_promote_time = >> GLOBAL_POLICY_DEFAULT_DPC_PROMOTE_TIME_US; >> +    policies->max_num_work_items = GLOBAL_POLICY_MAX_NUM_WI; >> +    /* Disable automatic resets as not yet supported. */ >> +    policies->global_flags = GLOBAL_POLICY_DISABLE_ENGINE_RESET; >>       policies->is_valid = 1; >>   } >>   -static void guc_ct_pool_entries_init(struct guc_ct_pool_entry >> *pool, u32 num) >> -{ >> -    memset(pool, 0, num * sizeof(*pool)); >> -} >> - >>   static void guc_mapping_table_init(struct intel_gt *gt, >>                      struct guc_gt_system_info *system_info) >>   { >> @@ -178,17 +149,9 @@ static void __guc_ads_init(struct intel_guc *guc) >>         base = intel_guc_ggtt_offset(guc, guc->ads_vma); >>   -    /* Clients info  */ >> -    guc_ct_pool_entries_init(blob->ct_pool, ARRAY_SIZE(blob->ct_pool)); >> - >> -    blob->clients_info.clients_num = 1; >> -    blob->clients_info.ct_pool_addr = base + ptr_offset(blob, ct_pool); >> -    blob->clients_info.ct_pool_count = ARRAY_SIZE(blob->ct_pool); >> - >>       /* ADS */ >>       blob->ads.scheduler_policies = base + ptr_offset(blob, policies); >>       blob->ads.gt_system_info = base + ptr_offset(blob, system_info); >> -    blob->ads.clients_info = base + ptr_offset(blob, clients_info); >>         /* Private Data */ >>       blob->ads.private_data = base + guc_ads_private_data_offset(guc); >> diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.c >> b/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.c >> index 8f7b148fef58..43409044528e 100644 >> --- a/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.c >> +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.c >> @@ -103,61 +103,66 @@ void intel_guc_ct_init_early(struct intel_guc_ct >> *ct) >>   static inline const char *guc_ct_buffer_type_to_str(u32 type) >>   { >>       switch (type) { >> -    case INTEL_GUC_CT_BUFFER_TYPE_SEND: >> +    case GUC_CTB_TYPE_HOST2GUC: >>           return "SEND"; >> -    case INTEL_GUC_CT_BUFFER_TYPE_RECV: >> +    case GUC_CTB_TYPE_GUC2HOST: >>           return "RECV"; >>       default: >>           return ""; >>       } >>   } >>   -static void guc_ct_buffer_desc_init(struct guc_ct_buffer_desc *desc, >> -                    u32 cmds_addr, u32 size) >> +static void guc_ct_buffer_desc_init(struct guc_ct_buffer_desc *desc) >>   { >>       memset(desc, 0, sizeof(*desc)); >> -    desc->addr = cmds_addr; >> -    desc->size = size; >> -    desc->owner = CTB_OWNER_HOST; >>   } >>   -static void guc_ct_buffer_reset(struct intel_guc_ct_buffer *ctb, >> u32 cmds_addr) >> +static void guc_ct_buffer_reset(struct intel_guc_ct_buffer *ctb) >>   { >> -    guc_ct_buffer_desc_init(ctb->desc, cmds_addr, ctb->size); >> +    ctb->broken = false; >> +    guc_ct_buffer_desc_init(ctb->desc); >>   } >>     static void guc_ct_buffer_init(struct intel_guc_ct_buffer *ctb, >>                      struct guc_ct_buffer_desc *desc, >> -                   u32 *cmds, u32 size) >> +                   u32 *cmds, u32 size_in_bytes) >>   { >> -    GEM_BUG_ON(size % 4); >> +    GEM_BUG_ON(size_in_bytes % 4); >>         ctb->desc = desc; >>       ctb->cmds = cmds; >> -    ctb->size = size; >> +    ctb->size = size_in_bytes / 4; >>   -    guc_ct_buffer_reset(ctb, 0); >> +    guc_ct_buffer_reset(ctb); >>   } >>   -static int guc_action_register_ct_buffer(struct intel_guc *guc, >> -                     u32 desc_addr, >> -                     u32 type) >> +static int guc_action_register_ct_buffer(struct intel_guc *guc, u32 >> type, >> +                     u32 desc_addr, u32 buff_addr, u32 size) >>   { >> -    u32 action[] = { >> -        INTEL_GUC_ACTION_REGISTER_COMMAND_TRANSPORT_BUFFER, >> -        desc_addr, >> -        sizeof(struct guc_ct_buffer_desc), >> -        type >> +    u32 request[HOST2GUC_REGISTER_CTB_REQUEST_MSG_LEN] = { >> +        FIELD_PREP(GUC_HXG_MSG_0_ORIGIN, GUC_HXG_ORIGIN_HOST) | >> +        FIELD_PREP(GUC_HXG_MSG_0_TYPE, GUC_HXG_TYPE_REQUEST) | >> +        FIELD_PREP(GUC_HXG_REQUEST_MSG_0_ACTION, >> GUC_ACTION_HOST2GUC_REGISTER_CTB), >> +        FIELD_PREP(HOST2GUC_REGISTER_CTB_REQUEST_MSG_1_SIZE, size / >> SZ_4K - 1) | >> +        FIELD_PREP(HOST2GUC_REGISTER_CTB_REQUEST_MSG_1_TYPE, type), >> +        FIELD_PREP(HOST2GUC_REGISTER_CTB_REQUEST_MSG_2_DESC_ADDR, >> desc_addr), >> +        FIELD_PREP(HOST2GUC_REGISTER_CTB_REQUEST_MSG_3_BUFF_ADDR, >> buff_addr), >>       }; >>   -    /* Can't use generic send(), CT registration must go over MMIO */ >> -    return intel_guc_send_mmio(guc, action, ARRAY_SIZE(action), NULL, >> 0); >> +    GEM_BUG_ON(type != GUC_CTB_TYPE_HOST2GUC && type != >> GUC_CTB_TYPE_GUC2HOST); >> +    GEM_BUG_ON(size % SZ_4K); >> + >> +    /* CT registration must go over MMIO */ >> +    return intel_guc_send_mmio(guc, request, ARRAY_SIZE(request), >> NULL, 0); >>   } >>   -static int ct_register_buffer(struct intel_guc_ct *ct, u32 >> desc_addr, u32 type) >> +static int ct_register_buffer(struct intel_guc_ct *ct, u32 type, >> +                  u32 desc_addr, u32 buff_addr, u32 size) >>   { >> -    int err = guc_action_register_ct_buffer(ct_to_guc(ct), desc_addr, >> type); >> +    int err; >>   +    err = guc_action_register_ct_buffer(ct_to_guc(ct), type, >> +                        desc_addr, buff_addr, size); >>       if (unlikely(err)) >>           CT_ERROR(ct, "Failed to register %s buffer (err=%d)\n", >>                guc_ct_buffer_type_to_str(type), err); >> @@ -166,14 +171,17 @@ static int ct_register_buffer(struct >> intel_guc_ct *ct, u32 desc_addr, u32 type) >>     static int guc_action_deregister_ct_buffer(struct intel_guc *guc, >> u32 type) >>   { >> -    u32 action[] = { >> -        INTEL_GUC_ACTION_DEREGISTER_COMMAND_TRANSPORT_BUFFER, >> -        CTB_OWNER_HOST, >> -        type >> +    u32 request[HOST2GUC_DEREGISTER_CTB_REQUEST_MSG_LEN] = { >> +        FIELD_PREP(GUC_HXG_MSG_0_ORIGIN, GUC_HXG_ORIGIN_HOST) | >> +        FIELD_PREP(GUC_HXG_MSG_0_TYPE, GUC_HXG_TYPE_REQUEST) | >> +        FIELD_PREP(GUC_HXG_REQUEST_MSG_0_ACTION, >> GUC_ACTION_HOST2GUC_DEREGISTER_CTB), >> +        FIELD_PREP(HOST2GUC_DEREGISTER_CTB_REQUEST_MSG_1_TYPE, type), >>       }; >>   -    /* Can't use generic send(), CT deregistration must go over >> MMIO */ >> -    return intel_guc_send_mmio(guc, action, ARRAY_SIZE(action), NULL, >> 0); >> +    GEM_BUG_ON(type != GUC_CTB_TYPE_HOST2GUC && type != >> GUC_CTB_TYPE_GUC2HOST); >> + >> +    /* CT deregistration must go over MMIO */ >> +    return intel_guc_send_mmio(guc, request, ARRAY_SIZE(request), >> NULL, 0); >>   } >>     static int ct_deregister_buffer(struct intel_guc_ct *ct, u32 type) >> @@ -261,7 +269,7 @@ void intel_guc_ct_fini(struct intel_guc_ct *ct) >>   int intel_guc_ct_enable(struct intel_guc_ct *ct) >>   { >>       struct intel_guc *guc = ct_to_guc(ct); >> -    u32 base, cmds; >> +    u32 base, desc, cmds; >>       void *blob; >>       int err; >>   @@ -277,23 +285,26 @@ int intel_guc_ct_enable(struct intel_guc_ct *ct) >>       GEM_BUG_ON(blob != ct->ctbs.send.desc); >>         /* (re)initialize descriptors */ >> -    cmds = base + ptrdiff(ct->ctbs.send.cmds, blob); >> -    guc_ct_buffer_reset(&ct->ctbs.send, cmds); >> - >> -    cmds = base + ptrdiff(ct->ctbs.recv.cmds, blob); >> -    guc_ct_buffer_reset(&ct->ctbs.recv, cmds); >> +    guc_ct_buffer_reset(&ct->ctbs.send); >> +    guc_ct_buffer_reset(&ct->ctbs.recv); >>         /* >>        * Register both CT buffers starting with RECV buffer. >>        * Descriptors are in first half of the blob. >>        */ >> -    err = ct_register_buffer(ct, base + ptrdiff(ct->ctbs.recv.desc, >> blob), >> -                 INTEL_GUC_CT_BUFFER_TYPE_RECV); >> +    desc = base + ptrdiff(ct->ctbs.recv.desc, blob); >> +    cmds = base + ptrdiff(ct->ctbs.recv.cmds, blob); >> +    err = ct_register_buffer(ct, GUC_CTB_TYPE_GUC2HOST, >> +                 desc, cmds, ct->ctbs.recv.size * 4); >> + >>       if (unlikely(err)) >>           goto err_out; >>   -    err = ct_register_buffer(ct, base + ptrdiff(ct->ctbs.send.desc, >> blob), >> -                 INTEL_GUC_CT_BUFFER_TYPE_SEND); >> +    desc = base + ptrdiff(ct->ctbs.send.desc, blob); >> +    cmds = base + ptrdiff(ct->ctbs.send.cmds, blob); >> +    err = ct_register_buffer(ct, GUC_CTB_TYPE_HOST2GUC, >> +                 desc, cmds, ct->ctbs.send.size * 4); >> + >>       if (unlikely(err)) >>           goto err_deregister; >>   @@ -302,7 +313,7 @@ int intel_guc_ct_enable(struct intel_guc_ct *ct) >>       return 0; >>     err_deregister: >> -    ct_deregister_buffer(ct, INTEL_GUC_CT_BUFFER_TYPE_RECV); >> +    ct_deregister_buffer(ct, GUC_CTB_TYPE_GUC2HOST); >>   err_out: >>       CT_PROBE_ERROR(ct, "Failed to enable CTB (%pe)\n", ERR_PTR(err)); >>       return err; >> @@ -321,8 +332,8 @@ void intel_guc_ct_disable(struct intel_guc_ct *ct) >>       ct->enabled = false; >>         if (intel_guc_is_fw_running(guc)) { >> -        ct_deregister_buffer(ct, INTEL_GUC_CT_BUFFER_TYPE_SEND); >> -        ct_deregister_buffer(ct, INTEL_GUC_CT_BUFFER_TYPE_RECV); >> +        ct_deregister_buffer(ct, GUC_CTB_TYPE_HOST2GUC); >> +        ct_deregister_buffer(ct, GUC_CTB_TYPE_GUC2HOST); >>       } >>   } >>   @@ -354,24 +365,6 @@ static void write_barrier(struct intel_guc_ct *ct) >>       } >>   } >>   -/** >> - * DOC: CTB Host to GuC request >> - * >> - * Format of the CTB Host to GuC request message is as follows:: >> - * >> - *      +------------+---------+---------+---------+---------+ >> - *      |   msg[0]   |   [1]   |   [2]   |   ...   |  [n-1]  | >> - *      +------------+---------+---------+---------+---------+ >> - *      |   MESSAGE  |       MESSAGE PAYLOAD                 | >> - *      +   HEADER   +---------+---------+---------+---------+ >> - *      |            |    0    |    1    |   ...   |    n    | >> - *      +============+=========+=========+=========+=========+ >> - *      |  len >= 1  |  FENCE  |     request specific data   | >> - *      +------+-----+---------+---------+---------+---------+ >> - * >> - *                   ^-----------------len-------------------^ >> - */ >> - >>   static int ct_write(struct intel_guc_ct *ct, >>               const u32 *action, >>               u32 len /* in dwords */, >> @@ -384,20 +377,22 @@ static int ct_write(struct intel_guc_ct *ct, >>       u32 size = ctb->size; >>       u32 used; >>       u32 header; >> +    u32 hxg; >>       u32 *cmds = ctb->cmds; >>       unsigned int i; >>   -    if (unlikely(desc->is_in_error)) >> +    if (unlikely(ctb->broken)) >>           return -EPIPE; >>   -    if (unlikely(!IS_ALIGNED(head | tail, 4) || >> -             (tail | head) >= size)) >> +    if (unlikely(desc->status)) >>           goto corrupted; >>   -    /* later calculations will be done in dwords */ >> -    head /= 4; >> -    tail /= 4; >> -    size /= 4; >> +    if (unlikely((tail | head) >= size)) { >> +        CT_ERROR(ct, "Invalid offsets head=%u tail=%u (size=%u)\n", >> +             head, tail, size); >> +        desc->status |= GUC_CTB_STATUS_OVERFLOW; >> +        goto corrupted; >> +    } >>         /* >>        * tail == head condition indicates empty. GuC FW does not support >> @@ -413,22 +408,25 @@ static int ct_write(struct intel_guc_ct *ct, >>           return -ENOSPC; >>         /* >> -     * Write the message. The format is the following: >> -     * DW0: header (including action code) >> -     * DW1: fence >> -     * DW2+: action data >> +     * dw0: CT header (including fence) >> +     * dw1: HXG header (including action code) >> +     * dw2+: action data >>        */ >> -    header = (len << GUC_CT_MSG_LEN_SHIFT) | >> -         GUC_CT_MSG_SEND_STATUS | >> -         (action[0] << GUC_CT_MSG_ACTION_SHIFT); >> +    header = FIELD_PREP(GUC_CTB_MSG_0_FORMAT, GUC_CTB_FORMAT_HXG) | >> +         FIELD_PREP(GUC_CTB_MSG_0_NUM_DWORDS, len) | >> +         FIELD_PREP(GUC_CTB_MSG_0_FENCE, fence); >>   -    CT_DEBUG(ct, "writing %*ph %*ph %*ph\n", >> -         4, &header, 4, &fence, 4 * (len - 1), &action[1]); >> +    hxg = FIELD_PREP(GUC_HXG_MSG_0_TYPE, GUC_HXG_TYPE_REQUEST) | >> +          FIELD_PREP(GUC_HXG_REQUEST_MSG_0_ACTION | >> +             GUC_HXG_REQUEST_MSG_0_DATA0, action[0]); >> + >> +    CT_DEBUG(ct, "writing (tail %u) %*ph %*ph %*ph\n", >> +         tail, 4, &header, 4, &hxg, 4 * (len - 1), &action[1]); >>         cmds[tail] = header; >>       tail = (tail + 1) % size; >>   -    cmds[tail] = fence; >> +    cmds[tail] = hxg; >>       tail = (tail + 1) % size; >>         for (i = 1; i < len; i++) { >> @@ -443,14 +441,15 @@ static int ct_write(struct intel_guc_ct *ct, >>        */ >>       write_barrier(ct); >>   -    /* now update desc tail (back in bytes) */ >> -    desc->tail = tail * 4; >> +    /* now update descriptor */ >> +    WRITE_ONCE(desc->tail, tail); >> + >>       return 0; >>     corrupted: >> -    CT_ERROR(ct, "Corrupted descriptor addr=%#x head=%u tail=%u >> size=%u\n", >> -         desc->addr, desc->head, desc->tail, desc->size); >> -    desc->is_in_error = 1; >> +    CT_ERROR(ct, "Corrupted descriptor head=%u tail=%u status=%#x\n", >> +         desc->head, desc->tail, desc->status); >> +    ctb->broken = true; >>       return -EPIPE; >>   } >>   @@ -477,7 +476,9 @@ static int wait_for_ct_request_update(struct >> ct_request *req, u32 *status) >>        * up to that length of time, then switch to a slower sleep-wait >> loop. >>        * No GuC command should ever take longer than 10ms. >>        */ >> -#define done INTEL_GUC_MSG_IS_RESPONSE(READ_ONCE(req->status)) >> +#define done \ >> +    (FIELD_GET(GUC_HXG_MSG_0_ORIGIN, READ_ONCE(req->status)) == \ >> +     GUC_HXG_ORIGIN_GUC) >>       err = wait_for_us(done, 10); >>       if (err) >>           err = wait_for(done, 10); >> @@ -532,21 +533,21 @@ static int ct_send(struct intel_guc_ct *ct, >>       if (unlikely(err)) >>           goto unlink; >>   -    if (!INTEL_GUC_MSG_IS_RESPONSE_SUCCESS(*status)) { >> +    if (FIELD_GET(GUC_HXG_MSG_0_TYPE, *status) != >> GUC_HXG_TYPE_RESPONSE_SUCCESS) { >>           err = -EIO; >>           goto unlink; >>       } >>         if (response_buf) { >>           /* There shall be no data in the status */ >> -        WARN_ON(INTEL_GUC_MSG_TO_DATA(request.status)); >> +        WARN_ON(FIELD_GET(GUC_HXG_RESPONSE_MSG_0_DATA0, >> request.status)); >>           /* Return actual response len */ >>           err = request.response_len; >>       } else { >>           /* There shall be no response payload */ >>           WARN_ON(request.response_len); >>           /* Return data decoded from the status dword */ >> -        err = INTEL_GUC_MSG_TO_DATA(*status); >> +        err = FIELD_GET(GUC_HXG_RESPONSE_MSG_0_DATA0, *status); >>       } >>     unlink: >> @@ -583,21 +584,6 @@ int intel_guc_ct_send(struct intel_guc_ct *ct, >> const u32 *action, u32 len, >>       return ret; >>   } >>   -static inline unsigned int ct_header_get_len(u32 header) >> -{ >> -    return (header >> GUC_CT_MSG_LEN_SHIFT) & GUC_CT_MSG_LEN_MASK; >> -} >> - >> -static inline unsigned int ct_header_get_action(u32 header) >> -{ >> -    return (header >> GUC_CT_MSG_ACTION_SHIFT) & GUC_CT_MSG_ACTION_MASK; >> -} >> - >> -static inline bool ct_header_is_response(u32 header) >> -{ >> -    return !!(header & GUC_CT_MSG_IS_RESPONSE); >> -} >> - >>   static struct ct_incoming_msg *ct_alloc_msg(u32 num_dwords) >>   { >>       struct ct_incoming_msg *msg; >> @@ -630,17 +616,18 @@ static int ct_read(struct intel_guc_ct *ct, >> struct ct_incoming_msg **msg) >>       unsigned int i; >>       u32 header; >>   -    if (unlikely(desc->is_in_error)) >> +    if (unlikely(ctb->broken)) >>           return -EPIPE; >>   -    if (unlikely(!IS_ALIGNED(head | tail, 4) || >> -             (tail | head) >= size)) >> +    if (unlikely(desc->status)) >>           goto corrupted; >>   -    /* later calculations will be done in dwords */ >> -    head /= 4; >> -    tail /= 4; >> -    size /= 4; >> +    if (unlikely((tail | head) >= size)) { >> +        CT_ERROR(ct, "Invalid offsets head=%u tail=%u (size=%u)\n", >> +             head, tail, size); >> +        desc->status |= GUC_CTB_STATUS_OVERFLOW; >> +        goto corrupted; >> +    } >>         /* tail == head condition indicates empty */ >>       available = tail - head; >> @@ -659,7 +646,7 @@ static int ct_read(struct intel_guc_ct *ct, struct >> ct_incoming_msg **msg) >>       head = (head + 1) % size; >>         /* message len with header */ >> -    len = ct_header_get_len(header) + 1; >> +    len = FIELD_GET(GUC_CTB_MSG_0_NUM_DWORDS, header) + >> GUC_CTB_MSG_MIN_LEN; >>       if (unlikely(len > (u32)available)) { >>           CT_ERROR(ct, "Incomplete message %*ph %*ph %*ph\n", >>                4, &header, >> @@ -667,6 +654,7 @@ static int ct_read(struct intel_guc_ct *ct, struct >> ct_incoming_msg **msg) >>                     size - head : available - 1), &cmds[head], >>                4 * (head + available - 1 > size ? >>                     available - 1 - size + head : 0), &cmds[0]); >> +        desc->status |= GUC_CTB_STATUS_UNDERFLOW; >>           goto corrupted; >>       } >>   @@ -689,65 +677,36 @@ static int ct_read(struct intel_guc_ct *ct, >> struct ct_incoming_msg **msg) >>       } >>       CT_DEBUG(ct, "received %*ph\n", 4 * len, (*msg)->msg); >>   -    desc->head = head * 4; >> +    /* now update descriptor */ >> +    WRITE_ONCE(desc->head, head); >> + >>       return available - len; >>     corrupted: >> -    CT_ERROR(ct, "Corrupted descriptor addr=%#x head=%u tail=%u >> size=%u\n", >> -         desc->addr, desc->head, desc->tail, desc->size); >> -    desc->is_in_error = 1; >> +    CT_ERROR(ct, "Corrupted descriptor head=%u tail=%u status=%#x\n", >> +         desc->head, desc->tail, desc->status); >> +    ctb->broken = true; >>       return -EPIPE; >>   } >>   -/** >> - * DOC: CTB GuC to Host response >> - * >> - * Format of the CTB GuC to Host response message is as follows:: >> - * >> - *      +------------+---------+---------+---------+---------+---------+ >> - *      |   msg[0]   |   [1]   |   [2]   |   [3]   |   ...   |  [n-1]  | >> - *      +------------+---------+---------+---------+---------+---------+ >> - *      |   MESSAGE  |       MESSAGE PAYLOAD                           | >> - *      +   HEADER   +---------+---------+---------+---------+---------+ >> - *      |            |    0    |    1    |    2    |   ...   |    n    | >> - *      +============+=========+=========+=========+=========+=========+ >> - *      |  len >= 2  |  FENCE  |  STATUS |   response specific data    | >> - *      +------+-----+---------+---------+---------+---------+---------+ >> - * >> - *                   ^-----------------------len-----------------------^ >> - */ >> - >>   static int ct_handle_response(struct intel_guc_ct *ct, struct >> ct_incoming_msg *response) >>   { >> -    u32 header = response->msg[0]; >> -    u32 len = ct_header_get_len(header); >> -    u32 fence; >> -    u32 status; >> -    u32 datalen; >> +    u32 len = FIELD_GET(GUC_CTB_MSG_0_NUM_DWORDS, response->msg[0]); >> +    u32 fence = FIELD_GET(GUC_CTB_MSG_0_FENCE, response->msg[0]); >> +    const u32 *hxg = &response->msg[GUC_CTB_MSG_MIN_LEN]; >> +    const u32 *data = &hxg[GUC_HXG_MSG_MIN_LEN]; >> +    u32 datalen = len - GUC_HXG_MSG_MIN_LEN; >>       struct ct_request *req; >>       unsigned long flags; >>       bool found = false; >>       int err = 0; >>   -    GEM_BUG_ON(!ct_header_is_response(header)); >> - >> -    /* Response payload shall at least include fence and status */ >> -    if (unlikely(len < 2)) { >> -        CT_ERROR(ct, "Corrupted response (len %u)\n", len); >> -        return -EPROTO; >> -    } >> - >> -    fence = response->msg[1]; >> -    status = response->msg[2]; >> -    datalen = len - 2; >> - >> -    /* Format of the status follows RESPONSE message */ >> -    if (unlikely(!INTEL_GUC_MSG_IS_RESPONSE(status))) { >> -        CT_ERROR(ct, "Corrupted response (status %#x)\n", status); >> -        return -EPROTO; >> -    } >> +    GEM_BUG_ON(len < GUC_HXG_MSG_MIN_LEN); >> +    GEM_BUG_ON(FIELD_GET(GUC_HXG_MSG_0_ORIGIN, hxg[0]) != >> GUC_HXG_ORIGIN_GUC); >> +    GEM_BUG_ON(FIELD_GET(GUC_HXG_MSG_0_TYPE, hxg[0]) != >> GUC_HXG_TYPE_RESPONSE_SUCCESS && >> +           FIELD_GET(GUC_HXG_MSG_0_TYPE, hxg[0]) != >> GUC_HXG_TYPE_RESPONSE_FAILURE); >>   -    CT_DEBUG(ct, "response fence %u status %#x\n", fence, status); >> +    CT_DEBUG(ct, "response fence %u status %#x\n", fence, hxg[0]); >>         spin_lock_irqsave(&ct->requests.lock, flags); >>       list_for_each_entry(req, &ct->requests.pending, link) { >> @@ -763,9 +722,9 @@ static int ct_handle_response(struct intel_guc_ct >> *ct, struct ct_incoming_msg *r >>               err = -EMSGSIZE; >>           } >>           if (datalen) >> -            memcpy(req->response_buf, response->msg + 3, 4 * datalen); >> +            memcpy(req->response_buf, data, 4 * datalen); >>           req->response_len = datalen; >> -        WRITE_ONCE(req->status, status); >> +        WRITE_ONCE(req->status, hxg[0]); >>           found = true; >>           break; >>       } >> @@ -786,14 +745,16 @@ static int ct_handle_response(struct >> intel_guc_ct *ct, struct ct_incoming_msg *r >>   static int ct_process_request(struct intel_guc_ct *ct, struct >> ct_incoming_msg *request) >>   { >>       struct intel_guc *guc = ct_to_guc(ct); >> -    u32 header, action, len; >> +    const u32 *hxg; >>       const u32 *payload; >> +    u32 hxg_len, action, len; >>       int ret; >>   -    header = request->msg[0]; >> -    payload = &request->msg[1]; >> -    action = ct_header_get_action(header); >> -    len = ct_header_get_len(header); >> +    hxg = &request->msg[GUC_CTB_MSG_MIN_LEN]; >> +    hxg_len = request->size - GUC_CTB_MSG_MIN_LEN; >> +    payload = &hxg[GUC_HXG_MSG_MIN_LEN]; >> +    action = FIELD_GET(GUC_HXG_EVENT_MSG_0_ACTION, hxg[0]); >> +    len = hxg_len - GUC_HXG_MSG_MIN_LEN; >>         CT_DEBUG(ct, "request %x %*ph\n", action, 4 * len, payload); >>   @@ -855,29 +816,12 @@ static void >> ct_incoming_request_worker_func(struct work_struct *w) >>           queue_work(system_unbound_wq, &ct->requests.worker); >>   } >>   -/** >> - * DOC: CTB GuC to Host request >> - * >> - * Format of the CTB GuC to Host request message is as follows:: >> - * >> - *      +------------+---------+---------+---------+---------+---------+ >> - *      |   msg[0]   |   [1]   |   [2]   |   [3]   |   ...   |  [n-1]  | >> - *      +------------+---------+---------+---------+---------+---------+ >> - *      |   MESSAGE  |       MESSAGE PAYLOAD                           | >> - *      +   HEADER   +---------+---------+---------+---------+---------+ >> - *      |            |    0    |    1    |    2    |   ...   |    n    | >> - *      +============+=========+=========+=========+=========+=========+ >> - *      |     len    |            request specific data                | >> - *      +------+-----+---------+---------+---------+---------+---------+ >> - * >> - *                   ^-----------------------len-----------------------^ >> - */ >> - >> -static int ct_handle_request(struct intel_guc_ct *ct, struct >> ct_incoming_msg *request) >> +static int ct_handle_event(struct intel_guc_ct *ct, struct >> ct_incoming_msg *request) >>   { >> +    const u32 *hxg = &request->msg[GUC_CTB_MSG_MIN_LEN]; >>       unsigned long flags; >>   -    GEM_BUG_ON(ct_header_is_response(request->msg[0])); >> +    GEM_BUG_ON(FIELD_GET(GUC_HXG_MSG_0_TYPE, hxg[0]) != >> GUC_HXG_TYPE_EVENT); >>         spin_lock_irqsave(&ct->requests.lock, flags); >>       list_add_tail(&request->link, &ct->requests.incoming); >> @@ -887,15 +831,53 @@ static int ct_handle_request(struct intel_guc_ct >> *ct, struct ct_incoming_msg *re >>       return 0; >>   } >>   -static void ct_handle_msg(struct intel_guc_ct *ct, struct >> ct_incoming_msg *msg) >> +static int ct_handle_hxg(struct intel_guc_ct *ct, struct >> ct_incoming_msg *msg) >>   { >> -    u32 header = msg->msg[0]; >> +    u32 origin, type; >> +    u32 *hxg; >>       int err; >>   -    if (ct_header_is_response(header)) >> +    if (unlikely(msg->size < GUC_CTB_HXG_MSG_MIN_LEN)) >> +        return -EBADMSG; >> + >> +    hxg = &msg->msg[GUC_CTB_MSG_MIN_LEN]; >> + >> +    origin = FIELD_GET(GUC_HXG_MSG_0_ORIGIN, hxg[0]); >> +    if (unlikely(origin != GUC_HXG_ORIGIN_GUC)) { >> +        err = -EPROTO; >> +        goto failed; >> +    } >> + >> +    type = FIELD_GET(GUC_HXG_MSG_0_TYPE, hxg[0]); >> +    switch (type) { >> +    case GUC_HXG_TYPE_EVENT: >> +        err = ct_handle_event(ct, msg); >> +        break; >> +    case GUC_HXG_TYPE_RESPONSE_SUCCESS: >> +    case GUC_HXG_TYPE_RESPONSE_FAILURE: >>           err = ct_handle_response(ct, msg); >> +        break; >> +    default: >> +        err = -EOPNOTSUPP; >> +    } >> + >> +    if (unlikely(err)) { >> +failed: >> +        CT_ERROR(ct, "Failed to handle HXG message (%pe) %*ph\n", >> +             ERR_PTR(err), 4 * GUC_HXG_MSG_MIN_LEN, hxg); >> +    } >> +    return err; >> +} >> + >> +static void ct_handle_msg(struct intel_guc_ct *ct, struct >> ct_incoming_msg *msg) >> +{ >> +    u32 format = FIELD_GET(GUC_CTB_MSG_0_FORMAT, msg->msg[0]); >> +    int err; >> + >> +    if (format == GUC_CTB_FORMAT_HXG) >> +        err = ct_handle_hxg(ct, msg); >>       else >> -        err = ct_handle_request(ct, msg); >> +        err = -EOPNOTSUPP; >>         if (unlikely(err)) { >>           CT_ERROR(ct, "Failed to process CT message (%pe) %*ph\n", >> diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.h >> b/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.h >> index cb222f202301..1ae2dde6db93 100644 >> --- a/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.h >> +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.h >> @@ -31,13 +31,15 @@ struct intel_guc; >>    * @lock: protects access to the commands buffer and buffer descriptor >>    * @desc: pointer to the buffer descriptor >>    * @cmds: pointer to the commands buffer >> - * @size: size of the commands buffer >> + * @size: size of the commands buffer in dwords >> + * @broken: flag to indicate if descriptor data is broken >>    */ >>   struct intel_guc_ct_buffer { >>       spinlock_t lock; >>       struct guc_ct_buffer_desc *desc; >>       u32 *cmds; >>       u32 size; >> +    bool broken; >>   }; >>     @@ -59,7 +61,7 @@ struct intel_guc_ct { >>       struct tasklet_struct receive_tasklet; >>         struct { >> -        u32 last_fence; /* last fence used to send request */ >> +        u16 last_fence; /* last fence used to send request */ >>             spinlock_t lock; /* protects pending requests list */ >>           struct list_head pending; /* requests waiting for response */ >> diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc_fwif.h >> b/drivers/gpu/drm/i915/gt/uc/intel_guc_fwif.h >> index e9a9d85e2aa3..617ec601648d 100644 >> --- a/drivers/gpu/drm/i915/gt/uc/intel_guc_fwif.h >> +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc_fwif.h >> @@ -81,10 +81,8 @@ >>   #define   GUC_LOG_ALLOC_IN_MEGABYTE    (1 << 3) >>   #define   GUC_LOG_CRASH_SHIFT        4 >>   #define   GUC_LOG_CRASH_MASK        (0x3 << GUC_LOG_CRASH_SHIFT) >> -#define   GUC_LOG_DPC_SHIFT        6 >> -#define   GUC_LOG_DPC_MASK            (0x7 << GUC_LOG_DPC_SHIFT) >> -#define   GUC_LOG_ISR_SHIFT        9 >> -#define   GUC_LOG_ISR_MASK            (0x7 << GUC_LOG_ISR_SHIFT) >> +#define   GUC_LOG_DEBUG_SHIFT        6 >> +#define   GUC_LOG_DEBUG_MASK            (0xF << GUC_LOG_DEBUG_SHIFT) >>   #define   GUC_LOG_BUF_ADDR_SHIFT    12 >>     #define GUC_CTL_WA            1 >> @@ -247,32 +245,14 @@ struct guc_stage_desc { >>     /* Scheduling policy settings */ >>   -/* Reset engine upon preempt failure */ >> -#define POLICY_RESET_ENGINE        (1<<0) >> -/* Preempt to idle on quantum expiry */ >> -#define POLICY_PREEMPT_TO_IDLE        (1<<1) >> - >> -#define POLICY_MAX_NUM_WI 15 >> -#define POLICY_DEFAULT_DPC_PROMOTE_TIME_US 500000 >> -#define POLICY_DEFAULT_EXECUTION_QUANTUM_US 1000000 >> -#define POLICY_DEFAULT_PREEMPTION_TIME_US 500000 >> -#define POLICY_DEFAULT_FAULT_TIME_US 250000 >> - >> -struct guc_policy { >> -    /* Time for one workload to execute. (in micro seconds) */ >> -    u32 execution_quantum; >> -    /* Time to wait for a preemption request to completed before >> issuing a >> -     * reset. (in micro seconds). */ >> -    u32 preemption_time; >> -    /* How much time to allow to run after the first fault is observed. >> -     * Then preempt afterwards. (in micro seconds) */ >> -    u32 fault_time; >> -    u32 policy_flags; >> -    u32 reserved[8]; >> -} __packed; >> +#define GLOBAL_POLICY_MAX_NUM_WI 15 >> + >> +/* Don't reset an engine upon preemption failure */ >> +#define GLOBAL_POLICY_DISABLE_ENGINE_RESET                BIT(0) >> + >> +#define GLOBAL_POLICY_DEFAULT_DPC_PROMOTE_TIME_US 500000 >>     struct guc_policies { >> -    struct guc_policy >> policy[GUC_CLIENT_PRIORITY_NUM][GUC_MAX_ENGINE_CLASSES]; >>       u32 submission_queue_depth[GUC_MAX_ENGINE_CLASSES]; >>       /* In micro seconds. How much time to allow before DPC >> processing is >>        * called back via interrupt (to prevent DPC queue drain starving). >> @@ -286,6 +266,7 @@ struct guc_policies { >>        * idle. */ >>       u32 max_num_work_items; >>   +    u32 global_flags; >>       u32 reserved[4]; >>   } __packed; >>   @@ -311,29 +292,13 @@ struct guc_gt_system_info { >>       u32 generic_gt_sysinfo[GUC_GENERIC_GT_SYSINFO_MAX]; >>   } __packed; >>   -/* Clients info */ >> -struct guc_ct_pool_entry { >> -    struct guc_ct_buffer_desc desc; >> -    u32 reserved[7]; >> -} __packed; >> - >> -#define GUC_CT_POOL_SIZE    2 >> - >> -struct guc_clients_info { >> -    u32 clients_num; >> -    u32 reserved0[13]; >> -    u32 ct_pool_addr; >> -    u32 ct_pool_count; >> -    u32 reserved[4]; >> -} __packed; >> - >>   /* GuC Additional Data Struct */ >>   struct guc_ads { >>       struct guc_mmio_reg_set >> reg_state_list[GUC_MAX_ENGINE_CLASSES][GUC_MAX_INSTANCES_PER_CLASS]; >>       u32 reserved0; >>       u32 scheduler_policies; >>       u32 gt_system_info; >> -    u32 clients_info; >> +    u32 reserved1; >>       u32 control_data; >>       u32 golden_context_lrca[GUC_MAX_ENGINE_CLASSES]; >>       u32 eng_state_size[GUC_MAX_ENGINE_CLASSES]; >> @@ -344,8 +309,7 @@ struct guc_ads { >>   /* GuC logging structures */ >>     enum guc_log_buffer_type { >> -    GUC_ISR_LOG_BUFFER, >> -    GUC_DPC_LOG_BUFFER, >> +    GUC_DEBUG_LOG_BUFFER, >>       GUC_CRASH_DUMP_LOG_BUFFER, >>       GUC_MAX_LOG_BUFFER >>   }; >> @@ -414,23 +378,6 @@ struct guc_shared_ctx_data { >>       struct guc_ctx_report preempt_ctx_report[GUC_MAX_ENGINES_NUM]; >>   } __packed; >>   -#define __INTEL_GUC_MSG_GET(T, m) \ >> -    (((m) & INTEL_GUC_MSG_ ## T ## _MASK) >> INTEL_GUC_MSG_ ## T ## >> _SHIFT) >> -#define INTEL_GUC_MSG_TO_TYPE(m)    __INTEL_GUC_MSG_GET(TYPE, m) >> -#define INTEL_GUC_MSG_TO_DATA(m)    __INTEL_GUC_MSG_GET(DATA, m) >> -#define INTEL_GUC_MSG_TO_CODE(m)    __INTEL_GUC_MSG_GET(CODE, m) >> - >> -#define __INTEL_GUC_MSG_TYPE_IS(T, m) \ >> -    (INTEL_GUC_MSG_TO_TYPE(m) == INTEL_GUC_MSG_TYPE_ ## T) >> -#define INTEL_GUC_MSG_IS_REQUEST(m)    >> __INTEL_GUC_MSG_TYPE_IS(REQUEST, m) >> -#define INTEL_GUC_MSG_IS_RESPONSE(m)    >> __INTEL_GUC_MSG_TYPE_IS(RESPONSE, m) >> - >> -#define INTEL_GUC_MSG_IS_RESPONSE_SUCCESS(m) \ >> -     (typecheck(u32, (m)) && \ >> -      ((m) & (INTEL_GUC_MSG_TYPE_MASK | INTEL_GUC_MSG_CODE_MASK)) == \ >> -      ((INTEL_GUC_MSG_TYPE_RESPONSE << INTEL_GUC_MSG_TYPE_SHIFT) | \ >> -       (INTEL_GUC_RESPONSE_STATUS_SUCCESS << INTEL_GUC_MSG_CODE_SHIFT))) >> - >>   /* This action will be programmed in C1BC - SOFT_SCRATCH_15_REG */ >>   enum intel_guc_recv_message { >>       INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED = BIT(1), >> diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc_log.c >> b/drivers/gpu/drm/i915/gt/uc/intel_guc_log.c >> index c36d5eb5bbb9..ac0931f0374b 100644 >> --- a/drivers/gpu/drm/i915/gt/uc/intel_guc_log.c >> +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc_log.c >> @@ -197,10 +197,8 @@ static bool guc_check_log_buf_overflow(struct >> intel_guc_log *log, >>   static unsigned int guc_get_log_buffer_size(enum guc_log_buffer_type >> type) >>   { >>       switch (type) { >> -    case GUC_ISR_LOG_BUFFER: >> -        return ISR_BUFFER_SIZE; >> -    case GUC_DPC_LOG_BUFFER: >> -        return DPC_BUFFER_SIZE; >> +    case GUC_DEBUG_LOG_BUFFER: >> +        return DEBUG_BUFFER_SIZE; >>       case GUC_CRASH_DUMP_LOG_BUFFER: >>           return CRASH_BUFFER_SIZE; >>       default: >> @@ -245,7 +243,7 @@ static void guc_read_update_log_buffer(struct >> intel_guc_log *log) >>       src_data += PAGE_SIZE; >>       dst_data += PAGE_SIZE; >>   -    for (type = GUC_ISR_LOG_BUFFER; type < GUC_MAX_LOG_BUFFER; >> type++) { >> +    for (type = GUC_DEBUG_LOG_BUFFER; type < GUC_MAX_LOG_BUFFER; >> type++) { >>           /* >>            * Make a copy of the state structure, inside GuC log buffer >>            * (which is uncached mapped), on the stack to avoid reading >> @@ -463,21 +461,16 @@ int intel_guc_log_create(struct intel_guc_log *log) >>        *  +===============================+ 00B >>        *  |    Crash dump state header    | >>        *  +-------------------------------+ 32B >> -     *  |       DPC state header        | >> +     *  |      Debug state header       | >>        *  +-------------------------------+ 64B >> -     *  |       ISR state header        | >> -     *  +-------------------------------+ 96B >>        *  |                               | >>        *  +===============================+ PAGE_SIZE (4KB) >>        *  |        Crash Dump logs        | >>        *  +===============================+ + CRASH_SIZE >> -     *  |           DPC logs            | >> -     *  +===============================+ + DPC_SIZE >> -     *  |           ISR logs            | >> -     *  +===============================+ + ISR_SIZE >> +     *  |          Debug logs           | >> +     *  +===============================+ + DEBUG_SIZE >>        */ >> -    guc_log_size = PAGE_SIZE + CRASH_BUFFER_SIZE + DPC_BUFFER_SIZE + >> -            ISR_BUFFER_SIZE; >> +    guc_log_size = PAGE_SIZE + CRASH_BUFFER_SIZE + DEBUG_BUFFER_SIZE; >>         vma = intel_guc_allocate_vma(guc, guc_log_size); >>       if (IS_ERR(vma)) { >> @@ -675,10 +668,8 @@ static const char * >>   stringify_guc_log_type(enum guc_log_buffer_type type) >>   { >>       switch (type) { >> -    case GUC_ISR_LOG_BUFFER: >> -        return "ISR"; >> -    case GUC_DPC_LOG_BUFFER: >> -        return "DPC"; >> +    case GUC_DEBUG_LOG_BUFFER: >> +        return "DEBUG"; >>       case GUC_CRASH_DUMP_LOG_BUFFER: >>           return "CRASH"; >>       default: >> @@ -708,7 +699,7 @@ void intel_guc_log_info(struct intel_guc_log *log, >> struct drm_printer *p) >>         drm_printf(p, "\tRelay full count: %u\n", log->relay.full_count); >>   -    for (type = GUC_ISR_LOG_BUFFER; type < GUC_MAX_LOG_BUFFER; >> type++) { >> +    for (type = GUC_DEBUG_LOG_BUFFER; type < GUC_MAX_LOG_BUFFER; >> type++) { >>           drm_printf(p, "\t%s:\tflush count %10u, overflow count %10u\n", >>                  stringify_guc_log_type(type), >>                  log->stats[type].flush, >> diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc_log.h >> b/drivers/gpu/drm/i915/gt/uc/intel_guc_log.h >> index 11fccd0b2294..ac1ee1d5ce10 100644 >> --- a/drivers/gpu/drm/i915/gt/uc/intel_guc_log.h >> +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc_log.h >> @@ -17,12 +17,10 @@ struct intel_guc; >>     #ifdef CONFIG_DRM_I915_DEBUG_GUC >>   #define CRASH_BUFFER_SIZE    SZ_2M >> -#define DPC_BUFFER_SIZE        SZ_8M >> -#define ISR_BUFFER_SIZE        SZ_8M >> +#define DEBUG_BUFFER_SIZE    SZ_16M >>   #else >>   #define CRASH_BUFFER_SIZE    SZ_8K >> -#define DPC_BUFFER_SIZE        SZ_32K >> -#define ISR_BUFFER_SIZE        SZ_32K >> +#define DEBUG_BUFFER_SIZE    SZ_64K >>   #endif >>     /* >> diff --git a/drivers/gpu/drm/i915/gt/uc/intel_uc_fw.c >> b/drivers/gpu/drm/i915/gt/uc/intel_uc_fw.c >> index df647c9a8d56..9f23e9de3237 100644 >> --- a/drivers/gpu/drm/i915/gt/uc/intel_uc_fw.c >> +++ b/drivers/gpu/drm/i915/gt/uc/intel_uc_fw.c >> @@ -48,19 +48,19 @@ void intel_uc_fw_change_status(struct intel_uc_fw >> *uc_fw, >>    * firmware as TGL. >>    */ >>   #define INTEL_UC_FIRMWARE_DEFS(fw_def, guc_def, huc_def) \ >> -    fw_def(ALDERLAKE_S, 0, guc_def(tgl, 49, 0, 1), huc_def(tgl,  7, >> 5, 0)) \ >> -    fw_def(ROCKETLAKE,  0, guc_def(tgl, 49, 0, 1), huc_def(tgl,  7, >> 5, 0)) \ >> -    fw_def(TIGERLAKE,   0, guc_def(tgl, 49, 0, 1), huc_def(tgl,  7, >> 5, 0)) \ >> -    fw_def(JASPERLAKE,  0, guc_def(ehl, 49, 0, 1), huc_def(ehl,  9, >> 0, 0)) \ >> -    fw_def(ELKHARTLAKE, 0, guc_def(ehl, 49, 0, 1), huc_def(ehl,  9, >> 0, 0)) \ >> -    fw_def(ICELAKE,     0, guc_def(icl, 49, 0, 1), huc_def(icl,  9, >> 0, 0)) \ >> -    fw_def(COMETLAKE,   5, guc_def(cml, 49, 0, 1), huc_def(cml,  4, >> 0, 0)) \ >> -    fw_def(COMETLAKE,   0, guc_def(kbl, 49, 0, 1), huc_def(kbl,  4, >> 0, 0)) \ >> -    fw_def(COFFEELAKE,  0, guc_def(kbl, 49, 0, 1), huc_def(kbl,  4, >> 0, 0)) \ >> -    fw_def(GEMINILAKE,  0, guc_def(glk, 49, 0, 1), huc_def(glk,  4, >> 0, 0)) \ >> -    fw_def(KABYLAKE,    0, guc_def(kbl, 49, 0, 1), huc_def(kbl,  4, >> 0, 0)) \ >> -    fw_def(BROXTON,     0, guc_def(bxt, 49, 0, 1), huc_def(bxt,  2, >> 0, 0)) \ >> -    fw_def(SKYLAKE,     0, guc_def(skl, 49, 0, 1), huc_def(skl,  2, >> 0, 0)) >> +    fw_def(ALDERLAKE_S, 0, guc_def(tgl, 62, 0, 0), huc_def(tgl,  7, >> 5, 0)) \ >> +    fw_def(ROCKETLAKE,  0, guc_def(tgl, 62, 0, 0), huc_def(tgl,  7, >> 5, 0)) \ >> +    fw_def(TIGERLAKE,   0, guc_def(tgl, 62, 0, 0), huc_def(tgl,  7, >> 5, 0)) \ >> +    fw_def(JASPERLAKE,  0, guc_def(ehl, 62, 0, 0), huc_def(ehl,  9, >> 0, 0)) \ >> +    fw_def(ELKHARTLAKE, 0, guc_def(ehl, 62, 0, 0), huc_def(ehl,  9, >> 0, 0)) \ >> +    fw_def(ICELAKE,     0, guc_def(icl, 62, 0, 0), huc_def(icl,  9, >> 0, 0)) \ >> +    fw_def(COMETLAKE,   5, guc_def(cml, 62, 0, 0), huc_def(cml,  4, >> 0, 0)) \ >> +    fw_def(COMETLAKE,   0, guc_def(kbl, 62, 0, 0), huc_def(kbl,  4, >> 0, 0)) \ >> +    fw_def(COFFEELAKE,  0, guc_def(kbl, 62, 0, 0), huc_def(kbl,  4, >> 0, 0)) \ >> +    fw_def(GEMINILAKE,  0, guc_def(glk, 62, 0, 0), huc_def(glk,  4, >> 0, 0)) \ >> +    fw_def(KABYLAKE,    0, guc_def(kbl, 62, 0, 0), huc_def(kbl,  4, >> 0, 0)) \ >> +    fw_def(BROXTON,     0, guc_def(bxt, 62, 0, 0), huc_def(bxt,  2, >> 0, 0)) \ >> +    fw_def(SKYLAKE,     0, guc_def(skl, 62, 0, 0), huc_def(skl,  2, >> 0, 0)) >>     #define __MAKE_UC_FW_PATH(prefix_, name_, major_, minor_, patch_) \ >>       "i915/" \ > From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.5 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,NICE_REPLY_A,SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_1 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 1A13DC48BE5 for ; Thu, 17 Jun 2021 06:24:13 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id AEF3060FE8 for ; Thu, 17 Jun 2021 06:24:12 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org AEF3060FE8 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=intel-gfx-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 9720B6E03E; Thu, 17 Jun 2021 06:24:11 +0000 (UTC) Received: from mga12.intel.com (mga12.intel.com [192.55.52.136]) by gabe.freedesktop.org (Postfix) with ESMTPS id 5471B89A14; Thu, 17 Jun 2021 06:24:09 +0000 (UTC) IronPort-SDR: sjpIRBr+KfA3nBPKMOJVj6TloG336i5myg79efx2vaEbA4xqCJ5uk194fTXNp9dkvYGIMj8mWt cRVGROpUR2Dg== X-IronPort-AV: E=McAfee;i="6200,9189,10017"; a="186003111" X-IronPort-AV: E=Sophos;i="5.83,278,1616482800"; d="scan'208";a="186003111" Received: from orsmga006.jf.intel.com ([10.7.209.51]) by fmsmga106.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 16 Jun 2021 23:24:08 -0700 IronPort-SDR: IOO62kzadrtGEFt+BBVWnkBrFDQPRyvia2Jphkbw0nCesVgf/QApykL7OCusn6QUR8uO584FOt T7MUEzQKVfFA== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.83,278,1616482800"; d="scan'208";a="404560738" Received: from irvmail001.ir.intel.com ([10.43.11.63]) by orsmga006.jf.intel.com with ESMTP; 16 Jun 2021 23:24:06 -0700 Received: from [10.249.155.110] (mwajdecz-MOBL.ger.corp.intel.com [10.249.155.110]) by irvmail001.ir.intel.com (8.14.3/8.13.6/MailSET/Hub) with ESMTP id 15H6O5VO007482; Thu, 17 Jun 2021 07:24:05 +0100 To: Daniele Ceraolo Spurio , Matthew Brost , intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org References: <20210616001302.84233-1-matthew.brost@intel.com> <20210616001302.84233-3-matthew.brost@intel.com> From: Michal Wajdeczko Message-ID: <3ccb7fb3-32a9-2bf1-a9df-080ac55ce726@intel.com> Date: Thu, 17 Jun 2021 08:24:04 +0200 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.11.0 MIME-Version: 1.0 In-Reply-To: Content-Language: en-US Subject: Re: [Intel-gfx] [PATCH 2/3] drm/i915/guc: Update firmware to v62.0.0 X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" CgpPbiAxNy4wNi4yMDIxIDAzOjQxLCBEYW5pZWxlIENlcmFvbG8gU3B1cmlvIHdyb3RlOgo+IAo+ IAo+IE9uIDYvMTUvMjAyMSA1OjEzIFBNLCBNYXR0aGV3IEJyb3N0IHdyb3RlOgo+PiBGcm9tOiBN aWNoYWwgV2FqZGVjemtvIDxtaWNoYWwud2FqZGVjemtvQGludGVsLmNvbT4KPj4KPj4gTW9zdCBv ZiB0aGUgY2hhbmdlcyB0byB0aGUgNjIuMC4wIGZpcm13YXJlIHJldm9sdmVkIGFyb3VuZCBDVEIK Pj4gY29tbXVuaWNhdGlvbiBjaGFubmVsLiBDb25mb3JtIHRvIHRoZSBuZXcgKHN0YWJsZSkgQ1RC IHByb3RvY29sLgo+Pgo+PiB2MjoKPj4gwqAgKE1pY2hhbCkKPj4gwqDCoCBBZGQgdmFsdWVzIGJh Y2sgdG8ga2VybmVsIERPQyBmb3IgYWN0aW9ucwo+PiDCoCAoRG9jcykKPj4gwqDCoCBBZGQgJ0NU IGJ1ZmZlcicgYmFjayBpbiB0byBmaXggd2FybmluZwo+Pgo+PiBTaWduZWQtb2ZmLWJ5OiBKb2hu IEhhcnJpc29uIDxKb2huLkMuSGFycmlzb25ASW50ZWwuY29tPgo+PiBTaWduZWQtb2ZmLWJ5OiBN aWNoYWwgV2FqZGVjemtvIDxtaWNoYWwud2FqZGVjemtvQGludGVsLmNvbT4KPj4gU2lnbmVkLW9m Zi1ieTogTWF0dGhldyBCcm9zdCA8bWF0dGhldy5icm9zdEBpbnRlbC5jb20+Cj4+IC0tLQo+PiDC oCAuLi4vZ3B1L2RybS9pOTE1L2d0L3VjL2FiaS9ndWNfYWN0aW9uc19hYmkuaMKgIHwgMTA3ICsr KysrKwo+PiDCoCAuLi4vZ3QvdWMvYWJpL2d1Y19jb21tdW5pY2F0aW9uX2N0Yl9hYmkuaMKgwqDC oMKgIHwgMTI2ICsrKysrLS0KPj4gwqAgLi4uL2d0L3VjL2FiaS9ndWNfY29tbXVuaWNhdGlvbl9t bWlvX2FiaS5owqDCoMKgIHzCoCA2NSArKy0tCj4+IMKgIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2d0 L3VjL2ludGVsX2d1Yy5jwqDCoMKgwqDCoMKgwqAgfCAxMDcgKysrKy0tCj4+IMKgIGRyaXZlcnMv Z3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Y19hZHMuY8KgwqDCoCB8wqAgNDUgKy0tCj4+IMKg IGRyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Y19jdC5jwqDCoMKgwqAgfCAzNTYg KysrKysrKysrLS0tLS0tLS0tCj4+IMKgIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVs X2d1Y19jdC5owqDCoMKgwqAgfMKgwqAgNiArLQo+PiDCoCBkcml2ZXJzL2dwdS9kcm0vaTkxNS9n dC91Yy9pbnRlbF9ndWNfZndpZi5owqDCoCB8wqAgNzUgKy0tLQo+PiDCoCBkcml2ZXJzL2dwdS9k cm0vaTkxNS9ndC91Yy9pbnRlbF9ndWNfbG9nLmPCoMKgwqAgfMKgIDI5ICstCj4+IMKgIGRyaXZl cnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Y19sb2cuaMKgwqDCoCB8wqDCoCA2ICstCj4+ IMKgIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX3VjX2Z3LmPCoMKgwqDCoMKgIHzC oCAyNiArLQo+PiDCoCAxMSBmaWxlcyBjaGFuZ2VkLCA1MjcgaW5zZXJ0aW9ucygrKSwgNDIxIGRl bGV0aW9ucygtKQo+Pgo+PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMv YWJpL2d1Y19hY3Rpb25zX2FiaS5oCj4+IGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvYWJp L2d1Y19hY3Rpb25zX2FiaS5oCj4+IGluZGV4IDkwZWZlZjhhNzNlNC4uMmQ2MTk4ZTYzZWJlIDEw MDY0NAo+PiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9hYmkvZ3VjX2FjdGlvbnNf YWJpLmgKPj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvYWJpL2d1Y19hY3Rpb25z X2FiaS5oCj4+IEBAIC02LDYgKzYsMTEzIEBACj4+IMKgICNpZm5kZWYgX0FCSV9HVUNfQUNUSU9O U19BQklfSAo+PiDCoCAjZGVmaW5lIF9BQklfR1VDX0FDVElPTlNfQUJJX0gKPj4gwqAgKy8qKgo+ PiArICogRE9DOiBIT1NUMkdVQ19SRUdJU1RFUl9DVEIKPj4gKyAqCj4+ICsgKiBUaGlzIG1lc3Nh Z2UgaXMgdXNlZCBhcyBwYXJ0IG9mIHRoZSBgQ1RCIGJhc2VkIGNvbW11bmljYXRpb25gXyBzZXR1 cC4KPj4gKyAqCj4+ICsgKiBUaGlzIG1lc3NhZ2UgbXVzdCBiZSBzZW50IGFzIGBNTUlPIEhYRyBN ZXNzYWdlYF8uCj4+ICsgKgo+PiArICrCoAo+PiArLS0tKy0tLS0tLS0rLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCj4+Cj4+ICsg KsKgIHzCoMKgIHwgQml0c8KgIHwKPj4gRGVzY3JpcHRpb27CoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoCB8Cj4+ICsgKsKgCj4+ICs9PT0rPT09PT09PSs9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSsKPj4K Pj4gKyAqwqAgfCAwIHzCoMKgwqAgMzEgfCBPUklHSU4gPQo+PiBHVUNfSFhHX09SSUdJTl9IT1NU X8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgIHwKPj4gKyAqwqAgfMKgwqAKPj4gKy0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCj4+ICsgKsKgIHzCoMKg IHwgMzA6MjggfCBUWVBFID0KPj4gR1VDX0hYR19UWVBFX1JFUVVFU1RfwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB8Cj4+ICsg KsKgIHzCoMKgCj4+ICstLS0tLS0tKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwo+PiArICrCoCB8wqDCoCB8IDI3OjE2IHwgREFU QTAgPQo+PiBNQlrCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB8Cj4+ ICsgKsKgIHzCoMKgCj4+ICstLS0tLS0tKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwo+PiArICrCoCB8wqDCoCB8wqAgMTU6MCB8 IEFDVElPTiA9IF9gR1VDX0FDVElPTl9IT1NUMkdVQ19SRUdJU1RFUl9DVEJgID0KPj4gMHg0NTA1 wqDCoMKgwqDCoMKgwqAgfAo+PiArICrCoAo+PiArLS0tKy0tLS0tLS0rLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCj4+Cj4+ICsg KsKgIHwgMSB8IDMxOjEyIHwgUkVTRVJWRUQgPQo+PiBNQlrCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoCB8Cj4+ICsgKsKgIHzCoMKgCj4+ICstLS0tLS0tKy0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwo+PiArICrC oCB8wqDCoCB8wqAgMTE6OCB8ICoqVFlQRSoqIC0gdHlwZSBmb3IgdGhlIGBDVAo+PiBCdWZmZXJg X8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB8Cj4+ICsg KsKgIHzCoMKgIHzCoMKgwqDCoMKgwqAKPj4gfMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHwKPj4gKyAqwqAgfMKgwqAgfMKg wqDCoMKgwqDCoCB8wqDCoCAtIF9gR1VDX0NUQl9UWVBFX0hPU1QyR1VDYCA9Cj4+IDDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB8Cj4+ICsg KsKgIHzCoMKgIHzCoMKgwqDCoMKgwqAgfMKgwqAgLSBfYEdVQ19DVEJfVFlQRV9HVUMySE9TVGAg PQo+PiAxwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqAgfAo+PiArICrCoCB8wqDCoAo+PiArLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKPj4gKyAqwqAgfMKgwqAg fMKgwqAgNzowIHwgKipTSVpFKiogLSBzaXplIG9mIHRoZSBgQ1QgQnVmZmVyYF8gaW4gNEsgdW5p dHMKPj4gbWludXMgMcKgwqDCoMKgwqAgfAo+PiArICrCoAo+PiArLS0tKy0tLS0tLS0rLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0r Cj4+Cj4+ICsgKsKgIHwgMiB8wqAgMzE6MCB8ICoqREVTQ19BRERSKiogLSBHR1RUIGFkZHJlc3Mg b2YgdGhlIGBDVEIKPj4gRGVzY3JpcHRvcmBfwqDCoMKgwqDCoMKgwqAgfAo+PiArICrCoAo+PiAr LS0tKy0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0rCj4+Cj4+ICsgKsKgIHwgMyB8wqAgMzE6MCB8ICoqQlVGRl9BRERG KiogLSBHR1RUIGFkZHJlc3Mgb2YgdGhlIGBDVAo+PiBCdWZmZXJgX8KgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoCB8Cj4+ICsgKsKgCj4+ICstLS0rLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKPj4KPj4gKyAqCj4+ICsg KsKgCj4+ICstLS0rLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKPj4KPj4gKyAqwqAgfMKgwqAgfCBCaXRzwqAgfAo+ PiBEZXNjcmlwdGlvbsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHwK Pj4gKyAqwqAKPj4gKz09PSs9PT09PT09Kz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Kwo+Pgo+PiArICrCoCB8IDAgfMKgwqDCoCAz MSB8IE9SSUdJTiA9Cj4+IEdVQ19IWEdfT1JJR0lOX0dVQ1/CoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHwKPj4gKyAqwqAgfMKg wqAKPj4gKy0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0rCj4+ICsgKsKgIHzCoMKgIHwgMzA6MjggfCBUWVBFID0KPj4g R1VDX0hYR19UWVBFX1JFU1BPTlNFX1NVQ0NFU1NfwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoCB8Cj4+ICsgKsKgIHzCoMKgCj4+ICstLS0tLS0tKy0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwo+ PiArICrCoCB8wqDCoCB8wqAgMjc6MCB8IERBVEEwID0KPj4gTUJawqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgfAo+PiArICrCoAo+PiArLS0tKy0tLS0tLS0rLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0r Cj4+Cj4+ICsgKi8KPj4gKyNkZWZpbmUgR1VDX0FDVElPTl9IT1NUMkdVQ19SRUdJU1RFUl9DVELC oMKgwqDCoMKgwqDCoCAweDQ1MDUKPj4gKwo+PiArI2RlZmluZSBIT1NUMkdVQ19SRUdJU1RFUl9D VEJfUkVRVUVTVF9NU0dfTEVOwqDCoMKgwqDCoMKgwqAKPj4gKEdVQ19IWEdfUkVRVUVTVF9NU0df TUlOX0xFTiArIDN1KQo+PiArI2RlZmluZSBIT1NUMkdVQ19SRUdJU1RFUl9DVEJfUkVRVUVTVF9N U0dfMF9NQlrCoMKgwqDCoMKgwqDCoAo+PiBHVUNfSFhHX1JFUVVFU1RfTVNHXzBfREFUQTAKPj4g KyNkZWZpbmUgSE9TVDJHVUNfUkVHSVNURVJfQ1RCX1JFUVVFU1RfTVNHXzFfTUJawqDCoMKgwqDC oMKgwqAgKDB4ZmZmZmYgPDwgMTIpCj4+ICsjZGVmaW5lIEhPU1QyR1VDX1JFR0lTVEVSX0NUQl9S RVFVRVNUX01TR18xX1RZUEXCoMKgwqAgKDB4ZiA8PCA4KQo+PiArI2RlZmluZcKgwqAgR1VDX0NU Ql9UWVBFX0hPU1QyR1VDwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIDB1Cj4+ICsjZGVm aW5lwqDCoCBHVUNfQ1RCX1RZUEVfR1VDMkhPU1TCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqAgMXUKPj4gKyNkZWZpbmUgSE9TVDJHVUNfUkVHSVNURVJfQ1RCX1JFUVVFU1RfTVNHXzFfU0la RcKgwqDCoCAoMHhmZiA8PCAwKQo+PiArI2RlZmluZSBIT1NUMkdVQ19SRUdJU1RFUl9DVEJfUkVR VUVTVF9NU0dfMl9ERVNDX0FERFLCoMKgwqAKPj4gR1VDX0hYR19SRVFVRVNUX01TR19uX0RBVEFu Cj4+ICsjZGVmaW5lIEhPU1QyR1VDX1JFR0lTVEVSX0NUQl9SRVFVRVNUX01TR18zX0JVRkZfQURE UsKgwqDCoAo+PiBHVUNfSFhHX1JFUVVFU1RfTVNHX25fREFUQW4KPj4gKwo+PiArI2RlZmluZSBI T1NUMkdVQ19SRUdJU1RFUl9DVEJfUkVTUE9OU0VfTVNHX0xFTsKgwqDCoMKgwqDCoMKgCj4+IEdV Q19IWEdfUkVTUE9OU0VfTVNHX01JTl9MRU4KPj4gKyNkZWZpbmUgSE9TVDJHVUNfUkVHSVNURVJf Q1RCX1JFU1BPTlNFX01TR18wX01CWsKgwqDCoAo+PiBHVUNfSFhHX1JFU1BPTlNFX01TR18wX0RB VEEwCj4+ICsKPj4gKy8qKgo+PiArICogRE9DOiBIT1NUMkdVQ19ERVJFR0lTVEVSX0NUQgo+PiAr ICoKPj4gKyAqIFRoaXMgbWVzc2FnZSBpcyB1c2VkIGFzIHBhcnQgb2YgdGhlIGBDVEIgYmFzZWQg Y29tbXVuaWNhdGlvbmBfCj4+IHRlYXJkb3duLgo+PiArICoKPj4gKyAqIFRoaXMgbWVzc2FnZSBt dXN0IGJlIHNlbnQgYXMgYE1NSU8gSFhHIE1lc3NhZ2VgXy4KPj4gKyAqCj4+ICsgKsKgCj4+ICst LS0rLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLSsKPj4KPj4gKyAqwqAgfMKgwqAgfCBCaXRzwqAgfAo+PiBEZXNjcmlw dGlvbsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHwKPj4gKyAqwqAK Pj4gKz09PSs9PT09PT09Kz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Kwo+Pgo+PiArICrCoCB8IDAgfMKgwqDCoCAzMSB8IE9SSUdJ TiA9Cj4+IEdVQ19IWEdfT1JJR0lOX0hPU1RfwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgfAo+PiArICrCoCB8wqDCoAo+PiArLS0t LS0tLSstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLSsKPj4gKyAqwqAgfMKgwqAgfCAzMDoyOCB8IFRZUEUgPQo+PiBHVUNfSFhHX1RZ UEVfUkVRVUVTVF/CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgIHwKPj4gKyAqwqAgfMKgwqAKPj4gKy0tLS0tLS0rLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCj4+ ICsgKsKgIHzCoMKgIHwgMjc6MTYgfCBEQVRBMCA9Cj4+IE1CWsKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgIHwKPj4gKyAqwqAgfMKgwqAKPj4gKy0tLS0tLS0rLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0r Cj4+ICsgKsKgIHzCoMKgIHzCoCAxNTowIHwgQUNUSU9OID0gX2BHVUNfQUNUSU9OX0hPU1QyR1VD X0RFUkVHSVNURVJfQ1RCYCA9Cj4+IDB4NDUwNsKgwqDCoMKgwqAgfAo+PiArICrCoAo+PiArLS0t Ky0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0rCj4+Cj4+ICsgKsKgIHwgMSB8IDMxOjEyIHwgUkVTRVJWRUQgPQo+PiBN QlrCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB8Cj4+ICsgKsKgIHzCoMKgCj4+ ICstLS0tLS0tKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tKwo+PiArICrCoCB8wqDCoCB8wqAgMTE6OCB8ICoqVFlQRSoqIC0gdHlw ZSBvZiB0aGUgYENUCj4+IEJ1ZmZlcmBfwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqAgfAo+PiArICrCoCB8wqDCoCB8wqDCoMKgwqDCoMKgCj4+IHzCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoCB8Cj4+ICsgKsKgIHzCoMKgIHzCoMKgwqDCoMKgwqAgfCBzZWUKPj4gYEdVQ19BQ1RJT05f SE9TVDJHVUNfUkVHSVNURVJfQ1RCYF/CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqAgfAo+PiArICrCoCB8wqDCoAo+PiArLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKPj4gKyAqwqAgfMKg wqAgfMKgwqAgNzowIHwgUkVTRVJWRUQgPQo+PiBNQlrCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoCB8Cj4+ICsgKsKgCj4+ICstLS0rLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKPj4KPj4gKyAqCj4+ ICsgKsKgCj4+ICstLS0rLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKPj4KPj4gKyAqwqAgfMKgwqAgfCBCaXRzwqAg fAo+PiBEZXNjcmlwdGlvbsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg IHwKPj4gKyAqwqAKPj4gKz09PSs9PT09PT09Kz09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Kwo+Pgo+PiArICrCoCB8IDAgfMKgwqDC oCAzMSB8IE9SSUdJTiA9Cj4+IEdVQ19IWEdfT1JJR0lOX0dVQ1/CoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHwKPj4gKyAqwqAg fMKgwqAKPj4gKy0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCj4+ICsgKsKgIHzCoMKgIHwgMzA6MjggfCBUWVBFID0K Pj4gR1VDX0hYR19UWVBFX1JFU1BPTlNFX1NVQ0NFU1NfwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB8Cj4+ICsgKsKgIHzCoMKgCj4+ICstLS0tLS0tKy0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t Kwo+PiArICrCoCB8wqDCoCB8wqAgMjc6MCB8IERBVEEwID0KPj4gTUJawqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgfAo+PiArICrCoAo+PiArLS0tKy0tLS0tLS0rLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0rCj4+Cj4+ICsgKi8KPj4gKyNkZWZpbmUgR1VDX0FDVElPTl9IT1NUMkdVQ19ERVJFR0lTVEVS X0NUQsKgwqDCoMKgwqDCoMKgIDB4NDUwNgo+PiArCj4+ICsjZGVmaW5lIEhPU1QyR1VDX0RFUkVH SVNURVJfQ1RCX1JFUVVFU1RfTVNHX0xFTsKgwqDCoMKgwqDCoMKgCj4+IChHVUNfSFhHX1JFUVVF U1RfTVNHX01JTl9MRU4gKyAxdSkKPj4gKyNkZWZpbmUgSE9TVDJHVUNfREVSRUdJU1RFUl9DVEJf UkVRVUVTVF9NU0dfMF9NQlrCoMKgwqAKPj4gR1VDX0hYR19SRVFVRVNUX01TR18wX0RBVEEwCj4+ ICsjZGVmaW5lIEhPU1QyR1VDX0RFUkVHSVNURVJfQ1RCX1JFUVVFU1RfTVNHXzFfTUJawqDCoMKg ICgweGZmZmZmIDw8IDEyKQo+PiArI2RlZmluZSBIT1NUMkdVQ19ERVJFR0lTVEVSX0NUQl9SRVFV RVNUX01TR18xX1RZUEXCoMKgwqAgKDB4ZiA8PCA4KQo+PiArI2RlZmluZSBIT1NUMkdVQ19ERVJF R0lTVEVSX0NUQl9SRVFVRVNUX01TR18xX01CWjLCoMKgwqAgKDB4ZmYgPDwgMCkKPj4gKwo+PiAr I2RlZmluZSBIT1NUMkdVQ19ERVJFR0lTVEVSX0NUQl9SRVNQT05TRV9NU0dfTEVOwqDCoMKgCj4+ IEdVQ19IWEdfUkVTUE9OU0VfTVNHX01JTl9MRU4KPj4gKyNkZWZpbmUgSE9TVDJHVUNfREVSRUdJ U1RFUl9DVEJfUkVTUE9OU0VfTVNHXzBfTUJawqDCoMKgCj4+IEdVQ19IWEdfUkVTUE9OU0VfTVNH XzBfREFUQTAKPj4gKwo+PiArLyogbGVnYWN5IGRlZmluaXRpb25zICovCj4+ICsKPj4gwqAgZW51 bSBpbnRlbF9ndWNfYWN0aW9uIHsKPj4gwqDCoMKgwqDCoCBJTlRFTF9HVUNfQUNUSU9OX0RFRkFV TFQgPSAweDAsCj4+IMKgwqDCoMKgwqAgSU5URUxfR1VDX0FDVElPTl9SRVFVRVNUX1BSRUVNUFRJ T04gPSAweDIsCj4+IGRpZmYgLS1naXQKPj4gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9h YmkvZ3VjX2NvbW11bmljYXRpb25fY3RiX2FiaS5oCj4+IGIvZHJpdmVycy9ncHUvZHJtL2k5MTUv Z3QvdWMvYWJpL2d1Y19jb21tdW5pY2F0aW9uX2N0Yl9hYmkuaAo+PiBpbmRleCBkMzg5MzVmNDdl Y2YuLjI5ZmM5M2E4YjViZSAxMDA2NDQKPj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Qv dWMvYWJpL2d1Y19jb21tdW5pY2F0aW9uX2N0Yl9hYmkuaAo+PiArKysgYi9kcml2ZXJzL2dwdS9k cm0vaTkxNS9ndC91Yy9hYmkvZ3VjX2NvbW11bmljYXRpb25fY3RiX2FiaS5oCj4+IEBAIC03LDYg KzcsMTEwIEBACj4+IMKgICNkZWZpbmUgX0FCSV9HVUNfQ09NTVVOSUNBVElPTl9DVEJfQUJJX0gK Pj4gwqAgwqAgI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvYnVp bGRfYnVnLmg+Cj4+ICsKPj4gKyNpbmNsdWRlICJndWNfbWVzc2FnZXNfYWJpLmgiCj4+ICsKPj4g Ky8qKgo+PiArICogRE9DOiBDVCBCdWZmZXIKPj4gKyAqCj4+ICsgKiBDaXJjdWxhciBidWZmZXIg dXNlZCB0byBzZW5kIC8gcmVjZWl2ZSBDVEJzIChIMkcgb3IgRzJIKQo+IAo+IG5pdDogdGhlIENU QiBpcyBub3QgdXNlZCB0byBzZW5kIENUQnMsIGJ1dCB0byBzZW5kIG1lc3NhZ2VzLiBDYW4gZml4 Cj4gd2hpbGUgcHVzaGluZy4KCmFuZCB0byBiZSBtb3JlIHByZWNpc2VseSwgbm90IEgyRyBvciBH MkggbWVzc2FnZXMsIGJ1dAoJIiB0byBzZW5kIGdlbmVyaWMgYENUQiBNZXNzYWdlYF8gIgphcyBI Mkcgb3IgRzJIIChhZ2FpbiBtb3JlIHByZWNpc2VseSBgQ1RCIEhYRyBNZXNzYWdlYF8pIGlzIGp1 c3QgYQpzcGVjaWZpYyB0eXBlIG9mIG1lc3NhZ2UKCj4gCj4gRm9yIHRoZSByZXN0IEkgY291bGRu J3Qgc3BvdCBhbnl0aGluZyB0aGF0IGRpZG4ndCBtYXRjaCB3aGF0IHdhcyBhbHJlYWR5Cj4gcmV2 aWV3ZWQsIHNvOgo+IAo+IFJldmlld2VkLWJ5OiBEYW5pZWxlIENlcmFvbG8gU3B1cmlvIDxkYW5p ZWxlLmNlcmFvbG9zcHVyaW9AaW50ZWwuY29tPgo+IAo+IERhbmllbGUKPiAKPj4gKyAqLwo+PiAr Cj4+ICsvKioKPj4gKyAqIERPQzogQ1RCIERlc2NyaXB0b3IKPj4gKyAqCj4+ICsgKsKgCj4+ICst LS0rLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLSsKPj4KPj4gKyAqwqAgfMKgwqAgfCBCaXRzwqAgfAo+PiBEZXNjcmlw dGlvbsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHwKPj4gKyAqwqAK Pj4gKz09PSs9PT09PT09Kz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Kwo+Pgo+PiArICrCoCB8IDAgfMKgIDMxOjAgfCAqKkhFQUQq KiAtIG9mZnNldCAoaW4gZHdvcmRzKSB0byB0aGUgbGFzdCBkd29yZAo+PiB0aGF0IHdhc8KgwqDC oMKgIHwKPj4gKyAqwqAgfMKgwqAgfMKgwqDCoMKgwqDCoCB8IHJlYWQgZnJvbSB0aGUgYENUCj4+ IEJ1ZmZlcmBfLsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoCB8Cj4+ICsgKsKgIHzCoMKgIHzCoMKgwqDCoMKgwqAgfCBJdCBj YW4gb25seSBiZSB1cGRhdGVkIGJ5IHRoZQo+PiByZWNlaXZlci7CoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgfAo+PiArICrCoAo+PiArLS0tKy0tLS0tLS0rLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0r Cj4+Cj4+ICsgKsKgIHwgMSB8wqAgMzE6MCB8ICoqVEFJTCoqIC0gb2Zmc2V0IChpbiBkd29yZHMp IHRvIHRoZSBsYXN0IGR3b3JkCj4+IHRoYXQgd2FzwqDCoMKgwqAgfAo+PiArICrCoCB8wqDCoCB8 wqDCoMKgwqDCoMKgIHwgd3JpdHRlbiB0byB0aGUgYENUCj4+IEJ1ZmZlcmBfLsKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgfAo+ PiArICrCoCB8wqDCoCB8wqDCoMKgwqDCoMKgIHwgSXQgY2FuIG9ubHkgYmUgdXBkYXRlZCBieSB0 aGUKPj4gc2VuZGVyLsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqAgfAo+PiArICrCoAo+PiArLS0tKy0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCj4+Cj4+ICsgKsKgIHwgMiB8wqAg MzE6MCB8ICoqU1RBVFVTKiogLSBzdGF0dXMgb2YgdGhlCj4+IENUQsKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB8Cj4+ICsgKsKgIHzC oMKgIHzCoMKgwqDCoMKgwqAKPj4gfMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHwKPj4gKyAqwqAgfMKgwqAgfMKgwqDCoMKg wqDCoCB8wqDCoCAtIF9gR1VDX0NUQl9TVEFUVVNfTk9fRVJST1JgID0gMCAobm9ybWFsCj4+IG9w ZXJhdGlvbinCoMKgwqDCoMKgwqDCoCB8Cj4+ICsgKsKgIHzCoMKgIHzCoMKgwqDCoMKgwqAgfMKg wqAgLSBfYEdVQ19DVEJfU1RBVFVTX09WRVJGTE9XYCA9IDEgKGhlYWQvdGFpbCB0b28KPj4gbGFy Z2UpwqDCoMKgwqAgfAo+PiArICrCoCB8wqDCoCB8wqDCoMKgwqDCoMKgIHzCoMKgIC0gX2BHVUNf Q1RCX1NUQVRVU19VTkRFUkZMT1dgID0gMiAodHJ1bmNhdGVkCj4+IG1lc3NhZ2UpwqDCoMKgwqDC oCB8Cj4+ICsgKsKgIHzCoMKgIHzCoMKgwqDCoMKgwqAgfMKgwqAgLSBfYEdVQ19DVEJfU1RBVFVT X01JU01BVENIYCA9IDQgKGhlYWQvdGFpbAo+PiBtb2RpZmllZCnCoMKgwqDCoMKgIHwKPj4gKyAq wqAKPj4gKy0tLSstLS0tLS0tKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwo+Pgo+PiArICrCoCB8Li4ufMKgwqDCoMKgwqDCoCB8 IFJFU0VSVkVEID0KPj4gTUJawqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgfAo+ PiArICrCoAo+PiArLS0tKy0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCj4+Cj4+ICsgKsKgIHwgMTV8wqAgMzE6MCB8 IFJFU0VSVkVEID0KPj4gTUJawqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgfAo+ PiArICrCoAo+PiArLS0tKy0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCj4+Cj4+ICsgKi8KPj4gKwo+PiArc3RydWN0 IGd1Y19jdF9idWZmZXJfZGVzYyB7Cj4+ICvCoMKgwqAgdTMyIGhlYWQ7Cj4+ICvCoMKgwqAgdTMy IHRhaWw7Cj4+ICvCoMKgwqAgdTMyIHN0YXR1czsKPj4gKyNkZWZpbmUgR1VDX0NUQl9TVEFUVVNf Tk9fRVJST1LCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgMAo+PiArI2RlZmluZSBHVUNf Q1RCX1NUQVRVU19PVkVSRkxPV8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAoMSA8PCAw KQo+PiArI2RlZmluZSBHVUNfQ1RCX1NUQVRVU19VTkRFUkZMT1fCoMKgwqDCoMKgwqDCoMKgwqDC oMKgICgxIDw8IDEpCj4+ICsjZGVmaW5lIEdVQ19DVEJfU1RBVFVTX01JU01BVENIwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgICgxIDw8IDIpCj4+ICvCoMKgwqAgdTMyIHJlc2VydmVkWzEz XTsKPj4gK30gX19wYWNrZWQ7Cj4+ICtzdGF0aWNfYXNzZXJ0KHNpemVvZihzdHJ1Y3QgZ3VjX2N0 X2J1ZmZlcl9kZXNjKSA9PSA2NCk7Cj4+ICsKPj4gKy8qKgo+PiArICogRE9DOiBDVEIgTWVzc2Fn ZQo+PiArICoKPj4gKyAqwqAKPj4gKy0tLSstLS0tLS0tKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwo+Pgo+PiArICrCoCB8wqDC oCB8IEJpdHPCoCB8Cj4+IERlc2NyaXB0aW9uwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqAgfAo+PiArICrCoAo+PiArPT09Kz09PT09PT0rPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0rCj4+Cj4+ICsgKsKg IHwgMCB8IDMxOjE2IHwgKipGRU5DRSoqIC0gbWVzc2FnZQo+PiBpZGVudGlmaWVywqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHwKPj4g KyAqwqAgfMKgwqAKPj4gKy0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCj4+ICsgKsKgIHzCoMKgIHwgMTU6MTIgfCAq KkZPUk1BVCoqIC0gZm9ybWF0IG9mIHRoZSBDVEIKPj4gbWVzc2FnZcKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHwKPj4gKyAqwqAgfMKgwqAgfMKgwqDCoMKgwqDC oCB8wqAgLSBfYEdVQ19DVEJfRk9STUFUX0hYR2AgPSAwIC0gc2VlIGBDVEIgSFhHCj4+IE1lc3Nh Z2VgX8KgwqDCoMKgwqDCoMKgIHwKPj4gKyAqwqAgfMKgwqAKPj4gKy0tLS0tLS0rLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCj4+ ICsgKsKgIHzCoMKgIHzCoCAxMTo4IHwKPj4gKipSRVNFUlZFRCoqwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgIHwKPj4gKyAqwqAgfMKgwqAKPj4gKy0tLS0tLS0rLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0r Cj4+ICsgKsKgIHzCoMKgIHzCoMKgIDc6MCB8ICoqTlVNX0RXT1JEUyoqIC0gbGVuZ3RoIG9mIHRo ZSBDVEIgbWVzc2FnZSAody9vCj4+IGhlYWRlcinCoMKgwqDCoMKgIHwKPj4gKyAqwqAKPj4gKy0t LSstLS0tLS0tKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tKwo+Pgo+PiArICrCoCB8IDEgfMKgIDMxOjAgfCBvcHRpb25hbCAoZGVw ZW5kcyBvbgo+PiBGT1JNQVQpwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB8Cj4+ICsgKsKgCj4+ICstLS0rLS0tLS0tLSvCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoAo+PiB8Cj4+ICsgKsKgIHwuLi58wqDCoMKgwqDCoMKgCj4+IHzCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB8Cj4+ICsg KsKgCj4+ICstLS0rLS0tLS0tLSvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoAo+PiB8Cj4+ICsgKsKgIHwgbiB8wqAgMzE6MAo+ PiB8wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqAgfAo+PiArICrCoAo+PiArLS0tKy0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCj4+Cj4+ICsgKi8K Pj4gKwo+PiArI2RlZmluZSBHVUNfQ1RCX01TR19NSU5fTEVOwqDCoMKgwqDCoMKgwqDCoMKgwqDC oCAxdQo+PiArI2RlZmluZSBHVUNfQ1RCX01TR19NQVhfTEVOwqDCoMKgwqDCoMKgwqDCoMKgwqDC oCAyNTZ1Cj4+ICsjZGVmaW5lIEdVQ19DVEJfTVNHXzBfRkVOQ0XCoMKgwqDCoMKgwqDCoMKgwqDC oMKgICgweGZmZmYgPDwgMTYpCj4+ICsjZGVmaW5lIEdVQ19DVEJfTVNHXzBfRk9STUFUwqDCoMKg wqDCoMKgwqDCoMKgwqDCoCAoMHhmIDw8IDEyKQo+PiArI2RlZmluZcKgwqAgR1VDX0NUQl9GT1JN QVRfSFhHwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAwdQo+PiArI2RlZmluZSBHVUNfQ1RCX01TR18w X1JFU0VSVkVEwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAoMHhmIDw8IDgpCj4+ICsjZGVmaW5lIEdV Q19DVEJfTVNHXzBfTlVNX0RXT1JEU8KgwqDCoMKgwqDCoMKgICgweGZmIDw8IDApCj4+ICsKPj4g Ky8qKgo+PiArICogRE9DOiBDVEIgSFhHIE1lc3NhZ2UKPj4gKyAqCj4+ICsgKsKgCj4+ICstLS0r LS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLSsKPj4KPj4gKyAqwqAgfMKgwqAgfCBCaXRzwqAgfAo+PiBEZXNjcmlwdGlv bsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHwKPj4gKyAqwqAKPj4g Kz09PSs9PT09PT09Kz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Kwo+Pgo+PiArICrCoCB8IDAgfCAzMToxNiB8Cj4+IEZFTkNFwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgfAo+PiAr ICrCoCB8wqDCoAo+PiArLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKPj4gKyAqwqAgfMKgwqAgfCAxNToxMiB8IEZP Uk1BVCA9Cj4+IEdVQ19DVEJfRk9STUFUX0hYR1/CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHwKPj4gKyAqwqAgfMKgwqAKPj4g Ky0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0rCj4+ICsgKsKgIHzCoMKgIHzCoCAxMTo4IHwgUkVTRVJWRUQgPQo+PiBN QlrCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB8Cj4+ICsgKsKgIHzCoMKgCj4+ ICstLS0tLS0tKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tKwo+PiArICrCoCB8wqDCoCB8wqDCoCA3OjAgfCBOVU1fRFdPUkRTID0g bGVuZ3RoIChpbiBkd29yZHMpIG9mIHRoZSBlbWJlZGRlZCBIWEcKPj4gbWVzc2FnZcKgIHwKPj4g KyAqwqAKPj4gKy0tLSstLS0tLS0tKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwo+Pgo+PiArICrCoCB8IDEgfMKgIDMxOjAgfMKg Cj4+ICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLSvCoCB8Cj4+ICsgKsKgICstLS0rLS0tLS0tLSvCoAo+PiB8wqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgfMKgIHwKPj4gKyAqwqAgfC4uLnzC oMKgwqDCoMKgwqAgfMKgIHzCoCBFbWJlZGRlZCBgSFhHCj4+IE1lc3NhZ2VgX8KgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB8wqAgfAo+ PiArICrCoCArLS0tKy0tLS0tLS0rwqAKPj4gfMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHzCoCB8Cj4+ICsgKsKgIHwgbiB8wqAgMzE6MCB8wqAK Pj4gKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tK8KgIHwKPj4gKyAqwqAKPj4gKy0tLSstLS0tLS0tKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwo+Pgo+PiArICovCj4+ICsK Pj4gKyNkZWZpbmUgR1VDX0NUQl9IWEdfTVNHX01JTl9MRU7CoMKgwqDCoMKgwqDCoCAoR1VDX0NU Ql9NU0dfTUlOX0xFTiArCj4+IEdVQ19IWEdfTVNHX01JTl9MRU4pCj4+ICsjZGVmaW5lIEdVQ19D VEJfSFhHX01TR19NQVhfTEVOwqDCoMKgwqDCoMKgwqAgR1VDX0NUQl9NU0dfTUFYX0xFTgo+PiDC oCDCoCAvKioKPj4gwqDCoCAqIERPQzogQ1RCIGJhc2VkIGNvbW11bmljYXRpb24KPj4gQEAgLTYw LDI4ICsxNjQsNiBAQAo+PiDCoMKgICogLSAqKmZsYWdzKiosIGhvbGRzIHZhcmlvdXMgYml0cyB0 byBjb250cm9sIG1lc3NhZ2UgaGFuZGxpbmcKPj4gwqDCoCAqLwo+PiDCoCAtLyoKPj4gLSAqIERl c2NyaWJlcyBzaW5nbGUgY29tbWFuZCB0cmFuc3BvcnQgYnVmZmVyLgo+PiAtICogVXNlZCBieSBi b3RoIGd1Yy1tYXN0ZXIgYW5kIGNsaWVudHMuCj4+IC0gKi8KPj4gLXN0cnVjdCBndWNfY3RfYnVm ZmVyX2Rlc2Mgewo+PiAtwqDCoMKgIHUzMiBhZGRyO8KgwqDCoMKgwqDCoMKgIC8qIGdmeCBhZGRy ZXNzICovCj4+IC3CoMKgwqAgdTY0IGhvc3RfcHJpdmF0ZTvCoMKgwqAgLyogaG9zdCBwcml2YXRl IGRhdGEgKi8KPj4gLcKgwqDCoCB1MzIgc2l6ZTvCoMKgwqDCoMKgwqDCoCAvKiBzaXplIGluIGJ5 dGVzICovCj4+IC3CoMKgwqAgdTMyIGhlYWQ7wqDCoMKgwqDCoMKgwqAgLyogb2Zmc2V0IHVwZGF0 ZWQgYnkgR3VDKi8KPj4gLcKgwqDCoCB1MzIgdGFpbDvCoMKgwqDCoMKgwqDCoCAvKiBvZmZzZXQg dXBkYXRlZCBieSBvd25lciAqLwo+PiAtwqDCoMKgIHUzMiBpc19pbl9lcnJvcjvCoMKgwqAgLyog ZXJyb3IgaW5kaWNhdG9yICovCj4+IC3CoMKgwqAgdTMyIHJlc2VydmVkMTsKPj4gLcKgwqDCoCB1 MzIgcmVzZXJ2ZWQyOwo+PiAtwqDCoMKgIHUzMiBvd25lcjvCoMKgwqDCoMKgwqDCoCAvKiBpZCBv ZiB0aGUgY2hhbm5lbCBvd25lciAqLwo+PiAtwqDCoMKgIHUzMiBvd25lcl9zdWJfaWQ7wqDCoMKg IC8qIG93bmVyLWRlZmluZWQgZmllbGQgZm9yIGV4dHJhIHRyYWNraW5nICovCj4+IC3CoMKgwqAg dTMyIHJlc2VydmVkWzVdOwo+PiAtfSBfX3BhY2tlZDsKPj4gLQo+PiAtLyogVHlwZSBvZiBjb21t YW5kIHRyYW5zcG9ydCBidWZmZXIgKi8KPj4gLSNkZWZpbmUgSU5URUxfR1VDX0NUX0JVRkZFUl9U WVBFX1NFTkTCoMKgwqAgMHgwdQo+PiAtI2RlZmluZSBJTlRFTF9HVUNfQ1RfQlVGRkVSX1RZUEVf UkVDVsKgwqDCoCAweDF1Cj4+IC0KPj4gwqAgLyoKPj4gwqDCoCAqIERlZmluaXRpb24gb2YgdGhl IGNvbW1hbmQgdHJhbnNwb3J0IG1lc3NhZ2UgaGVhZGVyIChEVzApCj4+IMKgwqAgKgo+PiBkaWZm IC0tZ2l0Cj4+IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvYWJpL2d1Y19jb21tdW5pY2F0 aW9uX21taW9fYWJpLmgKPj4gYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9hYmkvZ3VjX2Nv bW11bmljYXRpb25fbW1pb19hYmkuaAo+PiBpbmRleCBiZTA2NmE2MmU5ZTAuLmJiZjFkZGI3NzQz NCAxMDA2NDQKPj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvYWJpL2d1Y19jb21t dW5pY2F0aW9uX21taW9fYWJpLmgKPj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMv YWJpL2d1Y19jb21tdW5pY2F0aW9uX21taW9fYWJpLmgKPj4gQEAgLTcsNDYgKzcsNDMgQEAKPj4g wqAgI2RlZmluZSBfQUJJX0dVQ19DT01NVU5JQ0FUSU9OX01NSU9fQUJJX0gKPj4gwqAgwqAgLyoq Cj4+IC0gKiBET0M6IE1NSU8gYmFzZWQgY29tbXVuaWNhdGlvbgo+PiArICogRE9DOiBHdUMgTU1J TyBiYXNlZCBjb21tdW5pY2F0aW9uCj4+IMKgwqAgKgo+PiAtICogVGhlIE1NSU8gYmFzZWQgY29t bXVuaWNhdGlvbiBiZXR3ZWVuIEhvc3QgYW5kIEd1QyB1c2VzIHNvZnR3YXJlCj4+IHNjcmF0Y2gK Pj4gLSAqIHJlZ2lzdGVycywgd2hlcmUgZmlyc3QgcmVnaXN0ZXIgaG9sZHMgZGF0YSB0cmVhdGVk IGFzIG1lc3NhZ2UgaGVhZGVyLAo+PiAtICogYW5kIG90aGVyIHJlZ2lzdGVycyBhcmUgdXNlZCB0 byBob2xkIG1lc3NhZ2UgcGF5bG9hZC4KPj4gKyAqIFRoZSBNTUlPIGJhc2VkIGNvbW11bmljYXRp b24gYmV0d2VlbiBIb3N0IGFuZCBHdUMgcmVsaWVzIG9uIHNwZWNpYWwKPj4gKyAqIGhhcmR3YXJl IHJlZ2lzdGVycyB3aGljaCBmb3JtYXQgY291bGQgYmUgZGVmaW5lZCBieSB0aGUgc29mdHdhcmUK Pj4gKyAqIChzbyBjYWxsZWQgc2NyYXRjaCByZWdpc3RlcnMpLgo+PiDCoMKgICoKPj4gLSAqIEZv ciBHZW45KywgR3VDIHVzZXMgc29mdHdhcmUgc2NyYXRjaCByZWdpc3RlcnMgMHhDMTgwLTB4QzFC OCwKPj4gLSAqIGJ1dCBubyBIMkcgY29tbWFuZCB0YWtlcyBtb3JlIHRoYW4gOCBwYXJhbWV0ZXJz IGFuZCB0aGUgR3VDIEZXCj4+IC0gKiBpdHNlbGYgdXNlcyBhbiA4LWVsZW1lbnQgYXJyYXkgdG8g c3RvcmUgdGhlIEgyRyBtZXNzYWdlLgo+PiArICogRWFjaCBNTUlPIGJhc2VkIG1lc3NhZ2UsIGJv dGggSG9zdCB0byBHdUMgKEgyRykgYW5kIEd1QyB0byBIb3N0IChHMkgpCj4+ICsgKiBtZXNzYWdl cywgd2hpY2ggbWF4aW11bSBsZW5ndGggZGVwZW5kcyBvbiBudW1iZXIgb2YgYXZhaWxhYmxlIHNj cmF0Y2gKPj4gKyAqIHJlZ2lzdGVycywgaXMgZGlyZWN0bHkgd3JpdHRlbiBpbnRvIHRob3NlIHNj cmF0Y2ggcmVnaXN0ZXJzLgo+PiDCoMKgICoKPj4gLSAqwqDCoMKgwqDCoCArLS0tLS0tLS0tLS0r LS0tLS0tLS0tKy0tLS0tLS0tLSstLS0tLS0tLS0rCj4+IC0gKsKgwqDCoMKgwqAgfMKgIE1NSU9b MF3CoCB8IE1NSU9bMV0gfMKgwqAgLi4uwqDCoCB8IE1NSU9bbl0gfAo+PiAtICrCoMKgwqDCoMKg ICstLS0tLS0tLS0tLSstLS0tLS0tLS0rLS0tLS0tLS0tKy0tLS0tLS0tLSsKPj4gLSAqwqDCoMKg wqDCoCB8IGhlYWRlcsKgwqDCoCB8wqDCoMKgwqDCoCBvcHRpb25hbCBwYXlsb2FkwqDCoMKgwqDC oMKgIHwKPj4gLSAqwqDCoMKgwqDCoCArPT09PT09Kz09PT0rPT09PT09PT09Kz09PT09PT09PSs9 PT09PT09PT0rCj4+IC0gKsKgwqDCoMKgwqAgfCAzMToyOHx0eXBlfMKgwqDCoMKgwqDCoMKgwqAg fMKgwqDCoMKgwqDCoMKgwqAgfMKgwqDCoMKgwqDCoMKgwqAgfAo+PiAtICrCoMKgwqDCoMKgICst LS0tLS0rLS0tLSvCoMKgwqDCoMKgwqDCoMKgIHzCoMKgwqDCoMKgwqDCoMKgIHzCoMKgwqDCoMKg wqDCoMKgIHwKPj4gLSAqwqDCoMKgwqDCoCB8IDI3OjE2fGRhdGF8wqDCoMKgwqDCoMKgwqDCoCB8 wqDCoMKgwqDCoMKgwqDCoCB8wqDCoMKgwqDCoMKgwqDCoCB8Cj4+IC0gKsKgwqDCoMKgwqAgKy0t LS0tLSstLS0tK8KgwqDCoMKgwqDCoMKgwqAgfMKgwqDCoMKgwqDCoMKgwqAgfMKgwqDCoMKgwqDC oMKgwqAgfAo+PiAtICrCoMKgwqDCoMKgIHzCoCAxNTowfGNvZGV8wqDCoMKgwqDCoMKgwqDCoCB8 wqDCoMKgwqDCoMKgwqDCoCB8wqDCoMKgwqDCoMKgwqDCoCB8Cj4+IC0gKsKgwqDCoMKgwqAgKy0t LS0tLSstLS0tKy0tLS0tLS0tLSstLS0tLS0tLS0rLS0tLS0tLS0tKwo+PiArICogRm9yIEdlbjkr LCB0aGVyZSBhcmUgMTYgc29mdHdhcmUgc2NyYXRjaCByZWdpc3RlcnMgMHhDMTgwLTB4QzFCOCwK Pj4gKyAqIGJ1dCBubyBIMkcgY29tbWFuZCB0YWtlcyBtb3JlIHRoYW4gNCBwYXJhbWV0ZXJzIGFu ZCB0aGUgR3VDIGZpcm13YXJlCj4+ICsgKiBpdHNlbGYgdXNlcyBhbiA0LWVsZW1lbnQgYXJyYXkg dG8gc3RvcmUgdGhlIEgyRyBtZXNzYWdlLgo+PiDCoMKgICoKPj4gLSAqIFRoZSBtZXNzYWdlIGhl YWRlciBjb25zaXN0cyBvZjoKPj4gKyAqIEZvciBHZW4xMSssIHRoZXJlIGFyZSBhZGRpdGlvbmFs IDQgcmVnaXN0ZXJzIDB4MTkwMjQwLTB4MTkwMjRDLCB3aGljaAo+PiArICogYXJlLCByZWdhcmRs ZXNzIG9uIGxvd2VyIGNvdW50LCBwcmVmZXJyZWQgb3ZlciBsZWdhY3kgb25lcy4KPj4gwqDCoCAq Cj4+IC0gKiAtICoqdHlwZSoqLCBpbmRpY2F0ZXMgbWVzc2FnZSB0eXBlCj4+IC0gKiAtICoqY29k ZSoqLCBpbmRpY2F0ZXMgbWVzc2FnZSBjb2RlLCBpcyBzcGVjaWZpYyBmb3IgKip0eXBlKioKPj4g LSAqIC0gKipkYXRhKiosIGluZGljYXRlcyBtZXNzYWdlIGRhdGEsIG9wdGlvbmFsLCBkZXBlbmRz IG9uICoqY29kZSoqCj4+IC0gKgo+PiAtICogVGhlIGZvbGxvd2luZyBtZXNzYWdlICoqdHlwZXMq KiBhcmUgc3VwcG9ydGVkOgo+PiAtICoKPj4gLSAqIC0gKipSRVFVRVNUKiosIGluZGljYXRlcyBI b3N0LXRvLUd1QyByZXF1ZXN0LCByZXF1ZXN0ZWQgR3VDIGFjdGlvbgo+PiBjb2RlCj4+IC0gKsKg wqAgbXVzdCBiZSBwcmlvdmlkZWQgaW4gKipjb2RlKiogZmllbGQuIE9wdGlvbmFsIGFjdGlvbiBz cGVjaWZpYwo+PiBwYXJhbWV0ZXJzCj4+IC0gKsKgwqAgY2FuIGJlIHByb3ZpZGVkIGluIHJlbWFp bmluZyBwYXlsb2FkIHJlZ2lzdGVycyBvciAqKmRhdGEqKiBmaWVsZC4KPj4gLSAqCj4+IC0gKiAt ICoqUkVTUE9OU0UqKiwgaW5kaWNhdGVzIEd1Qy10by1Ib3N0IHJlc3BvbnNlIGZyb20gZWFybGll ciBHdUMKPj4gcmVxdWVzdCwKPj4gLSAqwqDCoCBhY3Rpb24gcmVzcG9uc2Ugc3RhdHVzIHdpbGwg YmUgcHJvdmlkZWQgaW4gKipjb2RlKiogZmllbGQuIE9wdGlvbmFsCj4+IC0gKsKgwqAgcmVzcG9u c2UgZGF0YSBjYW4gYmUgcmV0dXJuZWQgaW4gcmVtYWluaW5nIHBheWxvYWQgcmVnaXN0ZXJzIG9y Cj4+ICoqZGF0YSoqCj4+IC0gKsKgwqAgZmllbGQuCj4+ICsgKiBUaGUgTU1JTyBiYXNlZCBjb21t dW5pY2F0aW9uIGlzIG1haW5seSB1c2VkIGR1cmluZyBkcml2ZXIKPj4gaW5pdGlhbGl6YXRpb24K Pj4gKyAqIHBoYXNlIHRvIHNldHVwIHRoZSBgQ1RCIGJhc2VkIGNvbW11bmljYXRpb25gXyB0aGF0 IHdpbGwgYmUgdXNlZAo+PiBhZnRlcndhcmRzLgo+PiDCoMKgICovCj4+IMKgIC0jZGVmaW5lIEdV Q19NQVhfTU1JT19NU0dfTEVOwqDCoMKgwqDCoMKgwqAgOAo+PiArI2RlZmluZSBHVUNfTUFYX01N SU9fTVNHX0xFTsKgwqDCoMKgwqDCoMKgIDQKPj4gKwo+PiArLyoqCj4+ICsgKiBET0M6IE1NSU8g SFhHIE1lc3NhZ2UKPj4gKyAqCj4+ICsgKiBGb3JtYXQgb2YgdGhlIE1NSU8gbWVzc2FnZXMgZm9s bG93cyBkZWZpbml0aW9ucyBvZiBgSFhHIE1lc3NhZ2VgXy4KPj4gKyAqCj4+ICsgKsKgCj4+ICst LS0rLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLSsKPj4KPj4gKyAqwqAgfMKgwqAgfCBCaXRzwqAgfAo+PiBEZXNjcmlw dGlvbsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHwKPj4gKyAqwqAK Pj4gKz09PSs9PT09PT09Kz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Kwo+Pgo+PiArICrCoCB8IDAgfMKgIDMxOjAgfMKgCj4+ICst LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSvC oCB8Cj4+ICsgKsKgICstLS0rLS0tLS0tLSvCoAo+PiB8wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgfMKgIHwKPj4gKyAqwqAgfC4uLnzCoMKgwqDC oMKgwqAgfMKgIHzCoCBFbWJlZGRlZCBgSFhHCj4+IE1lc3NhZ2VgX8KgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB8wqAgfAo+PiArICrC oCArLS0tKy0tLS0tLS0rwqAKPj4gfMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgIHzCoCB8Cj4+ICsgKsKgIHwgbiB8wqAgMzE6MCB8wqAKPj4gKy0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tK8Kg IHwKPj4gKyAqwqAKPj4gKy0tLSstLS0tLS0tKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwo+Pgo+PiArICovCj4+IMKgIMKgICNl bmRpZiAvKiBfQUJJX0dVQ19DT01NVU5JQ0FUSU9OX01NSU9fQUJJX0ggKi8KPj4gZGlmZiAtLWdp dCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Yy5jCj4+IGIvZHJpdmVycy9n cHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjLmMKPj4gaW5kZXggZjE0N2NiMzg5YTIwLi42NjYx ZGNiMDIyMzkgMTAwNjQ0Cj4+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVs X2d1Yy5jCj4+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Yy5jCj4+ IEBAIC0yMTksMjQgKzIxOSwxOSBAQCBzdGF0aWMgdTMyIGd1Y19jdGxfbG9nX3BhcmFtc19mbGFn cyhzdHJ1Y3QKPj4gaW50ZWxfZ3VjICpndWMpCj4+IMKgIMKgwqDCoMKgwqAgQlVJTERfQlVHX09O KCFDUkFTSF9CVUZGRVJfU0laRSk7Cj4+IMKgwqDCoMKgwqAgQlVJTERfQlVHX09OKCFJU19BTElH TkVEKENSQVNIX0JVRkZFUl9TSVpFLCBVTklUKSk7Cj4+IC3CoMKgwqAgQlVJTERfQlVHX09OKCFE UENfQlVGRkVSX1NJWkUpOwo+PiAtwqDCoMKgIEJVSUxEX0JVR19PTighSVNfQUxJR05FRChEUENf QlVGRkVSX1NJWkUsIFVOSVQpKTsKPj4gLcKgwqDCoCBCVUlMRF9CVUdfT04oIUlTUl9CVUZGRVJf U0laRSk7Cj4+IC3CoMKgwqAgQlVJTERfQlVHX09OKCFJU19BTElHTkVEKElTUl9CVUZGRVJfU0la RSwgVU5JVCkpOwo+PiArwqDCoMKgIEJVSUxEX0JVR19PTighREVCVUdfQlVGRkVSX1NJWkUpOwo+ PiArwqDCoMKgIEJVSUxEX0JVR19PTighSVNfQUxJR05FRChERUJVR19CVUZGRVJfU0laRSwgVU5J VCkpOwo+PiDCoCDCoMKgwqDCoMKgIEJVSUxEX0JVR19PTigoQ1JBU0hfQlVGRkVSX1NJWkUgLyBV TklUIC0gMSkgPgo+PiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAoR1VDX0xPR19DUkFTSF9N QVNLID4+IEdVQ19MT0dfQ1JBU0hfU0hJRlQpKTsKPj4gLcKgwqDCoCBCVUlMRF9CVUdfT04oKERQ Q19CVUZGRVJfU0laRSAvIFVOSVQgLSAxKSA+Cj4+IC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKgIChH VUNfTE9HX0RQQ19NQVNLID4+IEdVQ19MT0dfRFBDX1NISUZUKSk7Cj4+IC3CoMKgwqAgQlVJTERf QlVHX09OKChJU1JfQlVGRkVSX1NJWkUgLyBVTklUIC0gMSkgPgo+PiAtwqDCoMKgwqDCoMKgwqDC oMKgwqDCoCAoR1VDX0xPR19JU1JfTUFTSyA+PiBHVUNfTE9HX0lTUl9TSElGVCkpOwo+PiArwqDC oMKgIEJVSUxEX0JVR19PTigoREVCVUdfQlVGRkVSX1NJWkUgLyBVTklUIC0gMSkgPgo+PiArwqDC oMKgwqDCoMKgwqDCoMKgwqDCoCAoR1VDX0xPR19ERUJVR19NQVNLID4+IEdVQ19MT0dfREVCVUdf U0hJRlQpKTsKPj4gwqAgwqDCoMKgwqDCoCBmbGFncyA9IEdVQ19MT0dfVkFMSUQgfAo+PiDCoMKg wqDCoMKgwqDCoMKgwqAgR1VDX0xPR19OT1RJRllfT05fSEFMRl9GVUxMIHwKPj4gwqDCoMKgwqDC oMKgwqDCoMKgIEZMQUcgfAo+PiDCoMKgwqDCoMKgwqDCoMKgwqAgKChDUkFTSF9CVUZGRVJfU0la RSAvIFVOSVQgLSAxKSA8PCBHVUNfTE9HX0NSQVNIX1NISUZUKSB8Cj4+IC3CoMKgwqDCoMKgwqDC oCAoKERQQ19CVUZGRVJfU0laRSAvIFVOSVQgLSAxKSA8PCBHVUNfTE9HX0RQQ19TSElGVCkgfAo+ PiAtwqDCoMKgwqDCoMKgwqAgKChJU1JfQlVGRkVSX1NJWkUgLyBVTklUIC0gMSkgPDwgR1VDX0xP R19JU1JfU0hJRlQpIHwKPj4gK8KgwqDCoMKgwqDCoMKgICgoREVCVUdfQlVGRkVSX1NJWkUgLyBV TklUIC0gMSkgPDwgR1VDX0xPR19ERUJVR19TSElGVCkgfAo+PiDCoMKgwqDCoMKgwqDCoMKgwqAg KG9mZnNldCA8PCBHVUNfTE9HX0JVRl9BRERSX1NISUZUKTsKPj4gwqAgwqDCoMKgwqDCoCAjdW5k ZWYgVU5JVAo+PiBAQCAtMzc2LDI5ICszNzEsMjcgQEAgdm9pZCBpbnRlbF9ndWNfZmluaShzdHJ1 Y3QgaW50ZWxfZ3VjICpndWMpCj4+IMKgIC8qCj4+IMKgwqAgKiBUaGlzIGZ1bmN0aW9uIGltcGxl bWVudHMgdGhlIE1NSU8gYmFzZWQgaG9zdCB0byBHdUMgaW50ZXJmYWNlLgo+PiDCoMKgICovCj4+ IC1pbnQgaW50ZWxfZ3VjX3NlbmRfbW1pbyhzdHJ1Y3QgaW50ZWxfZ3VjICpndWMsIGNvbnN0IHUz MiAqYWN0aW9uLCB1MzIKPj4gbGVuLAo+PiAraW50IGludGVsX2d1Y19zZW5kX21taW8oc3RydWN0 IGludGVsX2d1YyAqZ3VjLCBjb25zdCB1MzIgKnJlcXVlc3QsCj4+IHUzMiBsZW4sCj4+IMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgIHUzMiAqcmVzcG9uc2VfYnVmLCB1MzIgcmVzcG9uc2VfYnVm X3NpemUpCj4+IMKgIHsKPj4gK8KgwqDCoCBzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSA9 IGd1Y190b19ndChndWMpLT5pOTE1Owo+PiDCoMKgwqDCoMKgIHN0cnVjdCBpbnRlbF91bmNvcmUg KnVuY29yZSA9IGd1Y190b19ndChndWMpLT51bmNvcmU7Cj4+IC3CoMKgwqAgdTMyIHN0YXR1czsK Pj4gK8KgwqDCoCB1MzIgaGVhZGVyOwo+PiDCoMKgwqDCoMKgIGludCBpOwo+PiDCoMKgwqDCoMKg IGludCByZXQ7Cj4+IMKgIMKgwqDCoMKgwqAgR0VNX0JVR19PTighbGVuKTsKPj4gwqDCoMKgwqDC oCBHRU1fQlVHX09OKGxlbiA+IGd1Yy0+c2VuZF9yZWdzLmNvdW50KTsKPj4gwqAgLcKgwqDCoCAv KiBXZSBleHBlY3Qgb25seSBhY3Rpb24gY29kZSAqLwo+PiAtwqDCoMKgIEdFTV9CVUdfT04oKmFj dGlvbiAmIH5JTlRFTF9HVUNfTVNHX0NPREVfTUFTSyk7Cj4+IC0KPj4gLcKgwqDCoCAvKiBJZiBD VCBpcyBhdmFpbGFibGUsIHdlIGV4cGVjdCB0byB1c2UgTU1JTyBvbmx5IGR1cmluZwo+PiBpbml0 L2ZpbmkgKi8KPj4gLcKgwqDCoCBHRU1fQlVHX09OKCphY3Rpb24gIT0KPj4gSU5URUxfR1VDX0FD VElPTl9SRUdJU1RFUl9DT01NQU5EX1RSQU5TUE9SVF9CVUZGRVIgJiYKPj4gLcKgwqDCoMKgwqDC oMKgwqDCoMKgICphY3Rpb24gIT0KPj4gSU5URUxfR1VDX0FDVElPTl9ERVJFR0lTVEVSX0NPTU1B TkRfVFJBTlNQT1JUX0JVRkZFUik7Cj4+ICvCoMKgwqAgR0VNX0JVR19PTihGSUVMRF9HRVQoR1VD X0hYR19NU0dfMF9PUklHSU4sIHJlcXVlc3RbMF0pICE9Cj4+IEdVQ19IWEdfT1JJR0lOX0hPU1Qp Owo+PiArwqDCoMKgIEdFTV9CVUdfT04oRklFTERfR0VUKEdVQ19IWEdfTVNHXzBfVFlQRSwgcmVx dWVzdFswXSkgIT0KPj4gR1VDX0hYR19UWVBFX1JFUVVFU1QpOwo+PiDCoCDCoMKgwqDCoMKgIG11 dGV4X2xvY2soJmd1Yy0+c2VuZF9tdXRleCk7Cj4+IMKgwqDCoMKgwqAgaW50ZWxfdW5jb3JlX2Zv cmNld2FrZV9nZXQodW5jb3JlLCBndWMtPnNlbmRfcmVncy5md19kb21haW5zKTsKPj4gwqAgK3Jl dHJ5Ogo+PiDCoMKgwqDCoMKgIGZvciAoaSA9IDA7IGkgPCBsZW47IGkrKykKPj4gLcKgwqDCoMKg wqDCoMKgIGludGVsX3VuY29yZV93cml0ZSh1bmNvcmUsIGd1Y19zZW5kX3JlZyhndWMsIGkpLCBh Y3Rpb25baV0pOwo+PiArwqDCoMKgwqDCoMKgwqAgaW50ZWxfdW5jb3JlX3dyaXRlKHVuY29yZSwg Z3VjX3NlbmRfcmVnKGd1YywgaSksIHJlcXVlc3RbaV0pOwo+PiDCoCDCoMKgwqDCoMKgIGludGVs X3VuY29yZV9wb3N0aW5nX3JlYWQodW5jb3JlLCBndWNfc2VuZF9yZWcoZ3VjLCBpIC0gMSkpOwo+ PiDCoCBAQCAtNDEwLDMwICs0MDMsNzQgQEAgaW50IGludGVsX2d1Y19zZW5kX21taW8oc3RydWN0 IGludGVsX2d1YyAqZ3VjLAo+PiBjb25zdCB1MzIgKmFjdGlvbiwgdTMyIGxlbiwKPj4gwqDCoMKg wqDCoMKgICovCj4+IMKgwqDCoMKgwqAgcmV0ID0gX19pbnRlbF93YWl0X2Zvcl9yZWdpc3Rlcl9m dyh1bmNvcmUsCj4+IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoCBndWNfc2VuZF9yZWcoZ3VjLCAwKSwKPj4gLcKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgIElOVEVMX0dVQ19NU0dfVFlQRV9NQVNLLAo+PiAtwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgSU5URUxfR1VDX01TR19UWVBFX1JF U1BPTlNFIDw8Cj4+IC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oCBJTlRFTF9HVUNfTVNHX1RZUEVfU0hJRlQsCj4+IC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoCAxMCwgMTAsICZzdGF0dXMpOwo+PiAtwqDCoMKgIC8qIElmIEd1 QyBleHBsaWNpdGx5IHJldHVybmVkIGFuIGVycm9yLCBjb252ZXJ0IGl0IHRvIC1FSU8gKi8KPj4g LcKgwqDCoCBpZiAoIXJldCAmJiAhSU5URUxfR1VDX01TR19JU19SRVNQT05TRV9TVUNDRVNTKHN0 YXR1cykpCj4+IC3CoMKgwqDCoMKgwqDCoCByZXQgPSAtRUlPOwo+PiArwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgR1VDX0hYR19NU0dfMF9PUklHSU4sCj4+ICvC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBGSUVMRF9QUkVQKEdV Q19IWEdfTVNHXzBfT1JJR0lOLAo+PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBHVUNfSFhHX09SSUdJTl9HVUMpLAo+PiArwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgMTAsIDEwLCAmaGVhZGVyKTsK Pj4gK8KgwqDCoCBpZiAodW5saWtlbHkocmV0KSkgewo+PiArdGltZW91dDoKPj4gK8KgwqDCoMKg wqDCoMKgIGRybV9lcnIoJmk5MTUtPmRybSwgIm1taW8gcmVxdWVzdCAlI3g6IG5vIHJlcGx5ICV4 XG4iLAo+PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCByZXF1ZXN0WzBdLCBoZWFkZXIpOwo+PiAr wqDCoMKgwqDCoMKgwqAgZ290byBvdXQ7Cj4+ICvCoMKgwqAgfQo+PiDCoCAtwqDCoMKgIGlmIChy ZXQpIHsKPj4gLcKgwqDCoMKgwqDCoMKgIERSTV9FUlJPUigiTU1JTzogR3VDIGFjdGlvbiAlI3gg ZmFpbGVkIHdpdGggZXJyb3IgJWQgJSN4XG4iLAo+PiAtwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqAgYWN0aW9uWzBdLCByZXQsIHN0YXR1cyk7Cj4+ICvCoMKgwqAgaWYgKEZJRUxEX0dFVChHVUNf SFhHX01TR18wX1RZUEUsIGhlYWRlcikgPT0KPj4gR1VDX0hYR19UWVBFX05PX1JFU1BPTlNFX0JV U1kpIHsKPj4gKyNkZWZpbmUgZG9uZSAoeyBoZWFkZXIgPSBpbnRlbF91bmNvcmVfcmVhZCh1bmNv cmUsIGd1Y19zZW5kX3JlZyhndWMsCj4+IDApKTsgXAo+PiArwqDCoMKgwqDCoMKgwqAgRklFTERf R0VUKEdVQ19IWEdfTVNHXzBfT1JJR0lOLCBoZWFkZXIpICE9IEdVQ19IWEdfT1JJR0lOX0dVQwo+ PiB8fCBcCj4+ICvCoMKgwqDCoMKgwqDCoCBGSUVMRF9HRVQoR1VDX0hYR19NU0dfMF9UWVBFLCBo ZWFkZXIpICE9Cj4+IEdVQ19IWEdfVFlQRV9OT19SRVNQT05TRV9CVVNZOyB9KQo+PiArCj4+ICvC oMKgwqDCoMKgwqDCoCByZXQgPSB3YWl0X2Zvcihkb25lLCAxMDAwKTsKPj4gK8KgwqDCoMKgwqDC oMKgIGlmICh1bmxpa2VseShyZXQpKQo+PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBnb3RvIHRp bWVvdXQ7Cj4+ICvCoMKgwqDCoMKgwqDCoCBpZiAodW5saWtlbHkoRklFTERfR0VUKEdVQ19IWEdf TVNHXzBfT1JJR0lOLCBoZWFkZXIpICE9Cj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoCBHVUNfSFhHX09SSUdJTl9HVUMpKQo+PiArwqDCoMKgwqDCoMKgwqDC oMKgwqDCoCBnb3RvIHByb3RvOwo+PiArI3VuZGVmIGRvbmUKPj4gK8KgwqDCoCB9Cj4+ICsKPj4g K8KgwqDCoCBpZiAoRklFTERfR0VUKEdVQ19IWEdfTVNHXzBfVFlQRSwgaGVhZGVyKSA9PQo+PiBH VUNfSFhHX1RZUEVfTk9fUkVTUE9OU0VfUkVUUlkpIHsKPj4gK8KgwqDCoMKgwqDCoMKgIHUzMiBy ZWFzb24gPSBGSUVMRF9HRVQoR1VDX0hYR19SRVRSWV9NU0dfMF9SRUFTT04sIGhlYWRlcik7Cj4+ ICsKPj4gK8KgwqDCoMKgwqDCoMKgIGRybV9kYmcoJmk5MTUtPmRybSwgIm1taW8gcmVxdWVzdCAl I3g6IHJldHJ5aW5nLCByZWFzb24gJXVcbiIsCj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHJl cXVlc3RbMF0sIHJlYXNvbik7Cj4+ICvCoMKgwqDCoMKgwqDCoCBnb3RvIHJldHJ5Owo+PiArwqDC oMKgIH0KPj4gKwo+PiArwqDCoMKgIGlmIChGSUVMRF9HRVQoR1VDX0hYR19NU0dfMF9UWVBFLCBo ZWFkZXIpID09Cj4+IEdVQ19IWEdfVFlQRV9SRVNQT05TRV9GQUlMVVJFKSB7Cj4+ICvCoMKgwqDC oMKgwqDCoCB1MzIgaGludCA9IEZJRUxEX0dFVChHVUNfSFhHX0ZBSUxVUkVfTVNHXzBfSElOVCwg aGVhZGVyKTsKPj4gK8KgwqDCoMKgwqDCoMKgIHUzMiBlcnJvciA9IEZJRUxEX0dFVChHVUNfSFhH X0ZBSUxVUkVfTVNHXzBfRVJST1IsIGhlYWRlcik7Cj4+ICsKPj4gK8KgwqDCoMKgwqDCoMKgIGRy bV9lcnIoJmk5MTUtPmRybSwgIm1taW8gcmVxdWVzdCAlI3g6IGZhaWx1cmUgJXgvJXVcbiIsCj4+ ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHJlcXVlc3RbMF0sIGVycm9yLCBoaW50KTsKPj4gK8Kg wqDCoMKgwqDCoMKgIHJldCA9IC1FTlhJTzsKPj4gK8KgwqDCoMKgwqDCoMKgIGdvdG8gb3V0Owo+ PiArwqDCoMKgIH0KPj4gKwo+PiArwqDCoMKgIGlmIChGSUVMRF9HRVQoR1VDX0hYR19NU0dfMF9U WVBFLCBoZWFkZXIpICE9Cj4+IEdVQ19IWEdfVFlQRV9SRVNQT05TRV9TVUNDRVNTKSB7Cj4+ICtw cm90bzoKPj4gK8KgwqDCoMKgwqDCoMKgIGRybV9lcnIoJmk5MTUtPmRybSwgIm1taW8gcmVxdWVz dCAlI3g6IHVuZXhwZWN0ZWQgcmVwbHkgJSN4XG4iLAo+PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDC oCByZXF1ZXN0WzBdLCBoZWFkZXIpOwo+PiArwqDCoMKgwqDCoMKgwqAgcmV0ID0gLUVQUk9UTzsK Pj4gwqDCoMKgwqDCoMKgwqDCoMKgIGdvdG8gb3V0Owo+PiDCoMKgwqDCoMKgIH0KPj4gwqAgwqDC oMKgwqDCoCBpZiAocmVzcG9uc2VfYnVmKSB7Cj4+IC3CoMKgwqDCoMKgwqDCoCBpbnQgY291bnQg PSBtaW4ocmVzcG9uc2VfYnVmX3NpemUsIGd1Yy0+c2VuZF9yZWdzLmNvdW50IC0gMSk7Cj4+ICvC oMKgwqDCoMKgwqDCoCBpbnQgY291bnQgPSBtaW4ocmVzcG9uc2VfYnVmX3NpemUsIGd1Yy0+c2Vu ZF9yZWdzLmNvdW50KTsKPj4gwqAgLcKgwqDCoMKgwqDCoMKgIGZvciAoaSA9IDA7IGkgPCBjb3Vu dDsgaSsrKQo+PiArwqDCoMKgwqDCoMKgwqAgR0VNX0JVR19PTighY291bnQpOwo+PiArCj4+ICvC oMKgwqDCoMKgwqDCoCByZXNwb25zZV9idWZbMF0gPSBoZWFkZXI7Cj4+ICsKPj4gK8KgwqDCoMKg wqDCoMKgIGZvciAoaSA9IDE7IGkgPCBjb3VudDsgaSsrKQo+PiDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoCByZXNwb25zZV9idWZbaV0gPSBpbnRlbF91bmNvcmVfcmVhZCh1bmNvcmUsCj4+IC3C oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoCBndWNfc2VuZF9yZWcoZ3VjLCBpICsgMSkpOwo+PiAtwqDCoMKgIH0KPj4gK8KgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGd1 Y19zZW5kX3JlZyhndWMsIGkpKTsKPj4gwqAgLcKgwqDCoCAvKiBVc2UgZGF0YSBmcm9tIHRoZSBH dUMgcmVzcG9uc2UgYXMgb3VyIHJldHVybiB2YWx1ZSAqLwo+PiAtwqDCoMKgIHJldCA9IElOVEVM X0dVQ19NU0dfVE9fREFUQShzdGF0dXMpOwo+PiArwqDCoMKgwqDCoMKgwqAgLyogVXNlIG51bWJl ciBvZiBjb3BpZWQgZHdvcmRzIGFzIG91ciByZXR1cm4gdmFsdWUgKi8KPj4gK8KgwqDCoMKgwqDC oMKgIHJldCA9IGNvdW50Owo+PiArwqDCoMKgIH0gZWxzZSB7Cj4+ICvCoMKgwqDCoMKgwqDCoCAv KiBVc2UgZGF0YSBmcm9tIHRoZSBHdUMgcmVzcG9uc2UgYXMgb3VyIHJldHVybiB2YWx1ZSAqLwo+ PiArwqDCoMKgwqDCoMKgwqAgcmV0ID0gRklFTERfR0VUKEdVQ19IWEdfUkVTUE9OU0VfTVNHXzBf REFUQTAsIGhlYWRlcik7Cj4+ICvCoMKgwqAgfQo+PiDCoCDCoCBvdXQ6Cj4+IMKgwqDCoMKgwqAg aW50ZWxfdW5jb3JlX2ZvcmNld2FrZV9wdXQodW5jb3JlLCBndWMtPnNlbmRfcmVncy5md19kb21h aW5zKTsKPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1 Y19hZHMuYwo+PiBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Y19hZHMuYwo+ PiBpbmRleCA5YWJmYmM2ZWRiZDYuLmI4MjE0NTY1MmQ1NyAxMDA2NDQKPj4gLS0tIGEvZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX2Fkcy5jCj4+ICsrKyBiL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Y19hZHMuYwo+PiBAQCAtMjQsMTAgKzI0LDYgQEAKPj4g wqDCoCAqwqDCoMKgwqDCoCArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t Kwo+PiDCoMKgICrCoMKgwqDCoMKgIHwgZ3VjX2d0X3N5c3RlbV9pbmZvwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgfAo+PiDCoMKgICrCoMKgwqDCoMKgICstLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCj4+IC0gKsKgwqDCoMKgwqAgfCBndWNfY2xp ZW50c19pbmZvwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHwKPj4g LSAqwqDCoMKgwqDCoCArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwo+ PiAtICrCoMKgwqDCoMKgIHwgZ3VjX2N0X3Bvb2xfZW50cnlbc2l6ZV3CoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgIHwKPj4gLSAqwqDCoMKgwqDCoCArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tKwo+PiDCoMKgICrCoMKgwqDCoMKgIHwgcGFkZGluZ8KgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB8Cj4+IMKg wqAgKsKgwqDCoMKgwqAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsg PD09IDRLIGFsaWduZWQKPj4gwqDCoCAqwqDCoMKgwqDCoCB8IHByaXZhdGUgZGF0YcKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHwKPj4gQEAgLTM5LDgg KzM1LDYgQEAgc3RydWN0IF9fZ3VjX2Fkc19ibG9iIHsKPj4gwqDCoMKgwqDCoCBzdHJ1Y3QgZ3Vj X2FkcyBhZHM7Cj4+IMKgwqDCoMKgwqAgc3RydWN0IGd1Y19wb2xpY2llcyBwb2xpY2llczsKPj4g wqDCoMKgwqDCoCBzdHJ1Y3QgZ3VjX2d0X3N5c3RlbV9pbmZvIHN5c3RlbV9pbmZvOwo+PiAtwqDC oMKgIHN0cnVjdCBndWNfY2xpZW50c19pbmZvIGNsaWVudHNfaW5mbzsKPj4gLcKgwqDCoCBzdHJ1 Y3QgZ3VjX2N0X3Bvb2xfZW50cnkgY3RfcG9vbFtHVUNfQ1RfUE9PTF9TSVpFXTsKPj4gwqAgfSBf X3BhY2tlZDsKPj4gwqAgwqAgc3RhdGljIHUzMiBndWNfYWRzX3ByaXZhdGVfZGF0YV9zaXplKHN0 cnVjdCBpbnRlbF9ndWMgKmd1YykKPj4gQEAgLTU5LDM4ICs1MywxNSBAQCBzdGF0aWMgdTMyIGd1 Y19hZHNfYmxvYl9zaXplKHN0cnVjdCBpbnRlbF9ndWMgKmd1YykKPj4gwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgIGd1Y19hZHNfcHJpdmF0ZV9kYXRhX3NpemUoZ3VjKTsKPj4gwqAgfQo+PiDCoCAt c3RhdGljIHZvaWQgZ3VjX3BvbGljeV9pbml0KHN0cnVjdCBndWNfcG9saWN5ICpwb2xpY3kpCj4+ IC17Cj4+IC3CoMKgwqAgcG9saWN5LT5leGVjdXRpb25fcXVhbnR1bSA9IFBPTElDWV9ERUZBVUxU X0VYRUNVVElPTl9RVUFOVFVNX1VTOwo+PiAtwqDCoMKgIHBvbGljeS0+cHJlZW1wdGlvbl90aW1l ID0gUE9MSUNZX0RFRkFVTFRfUFJFRU1QVElPTl9USU1FX1VTOwo+PiAtwqDCoMKgIHBvbGljeS0+ ZmF1bHRfdGltZSA9IFBPTElDWV9ERUZBVUxUX0ZBVUxUX1RJTUVfVVM7Cj4+IC3CoMKgwqAgcG9s aWN5LT5wb2xpY3lfZmxhZ3MgPSAwOwo+PiAtfQo+PiAtCj4+IMKgIHN0YXRpYyB2b2lkIGd1Y19w b2xpY2llc19pbml0KHN0cnVjdCBndWNfcG9saWNpZXMgKnBvbGljaWVzKQo+PiDCoCB7Cj4+IC3C oMKgwqAgc3RydWN0IGd1Y19wb2xpY3kgKnBvbGljeTsKPj4gLcKgwqDCoCB1MzIgcCwgaTsKPj4g LQo+PiAtwqDCoMKgIHBvbGljaWVzLT5kcGNfcHJvbW90ZV90aW1lID0gUE9MSUNZX0RFRkFVTFRf RFBDX1BST01PVEVfVElNRV9VUzsKPj4gLcKgwqDCoCBwb2xpY2llcy0+bWF4X251bV93b3JrX2l0 ZW1zID0gUE9MSUNZX01BWF9OVU1fV0k7Cj4+IC0KPj4gLcKgwqDCoCBmb3IgKHAgPSAwOyBwIDwg R1VDX0NMSUVOVF9QUklPUklUWV9OVU07IHArKykgewo+PiAtwqDCoMKgwqDCoMKgwqAgZm9yIChp ID0gMDsgaSA8IEdVQ19NQVhfRU5HSU5FX0NMQVNTRVM7IGkrKykgewo+PiAtwqDCoMKgwqDCoMKg wqDCoMKgwqDCoCBwb2xpY3kgPSAmcG9saWNpZXMtPnBvbGljeVtwXVtpXTsKPj4gLQo+PiAtwqDC oMKgwqDCoMKgwqDCoMKgwqDCoCBndWNfcG9saWN5X2luaXQocG9saWN5KTsKPj4gLcKgwqDCoMKg wqDCoMKgIH0KPj4gLcKgwqDCoCB9Cj4+IC0KPj4gK8KgwqDCoCBwb2xpY2llcy0+ZHBjX3Byb21v dGVfdGltZSA9Cj4+IEdMT0JBTF9QT0xJQ1lfREVGQVVMVF9EUENfUFJPTU9URV9USU1FX1VTOwo+ PiArwqDCoMKgIHBvbGljaWVzLT5tYXhfbnVtX3dvcmtfaXRlbXMgPSBHTE9CQUxfUE9MSUNZX01B WF9OVU1fV0k7Cj4+ICvCoMKgwqAgLyogRGlzYWJsZSBhdXRvbWF0aWMgcmVzZXRzIGFzIG5vdCB5 ZXQgc3VwcG9ydGVkLiAqLwo+PiArwqDCoMKgIHBvbGljaWVzLT5nbG9iYWxfZmxhZ3MgPSBHTE9C QUxfUE9MSUNZX0RJU0FCTEVfRU5HSU5FX1JFU0VUOwo+PiDCoMKgwqDCoMKgIHBvbGljaWVzLT5p c192YWxpZCA9IDE7Cj4+IMKgIH0KPj4gwqAgLXN0YXRpYyB2b2lkIGd1Y19jdF9wb29sX2VudHJp ZXNfaW5pdChzdHJ1Y3QgZ3VjX2N0X3Bvb2xfZW50cnkKPj4gKnBvb2wsIHUzMiBudW0pCj4+IC17 Cj4+IC3CoMKgwqAgbWVtc2V0KHBvb2wsIDAsIG51bSAqIHNpemVvZigqcG9vbCkpOwo+PiAtfQo+ PiAtCj4+IMKgIHN0YXRpYyB2b2lkIGd1Y19tYXBwaW5nX3RhYmxlX2luaXQoc3RydWN0IGludGVs X2d0ICpndCwKPj4gwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBzdHJ1 Y3QgZ3VjX2d0X3N5c3RlbV9pbmZvICpzeXN0ZW1faW5mbykKPj4gwqAgewo+PiBAQCAtMTc4LDE3 ICsxNDksOSBAQCBzdGF0aWMgdm9pZCBfX2d1Y19hZHNfaW5pdChzdHJ1Y3QgaW50ZWxfZ3VjICpn dWMpCj4+IMKgIMKgwqDCoMKgwqAgYmFzZSA9IGludGVsX2d1Y19nZ3R0X29mZnNldChndWMsIGd1 Yy0+YWRzX3ZtYSk7Cj4+IMKgIC3CoMKgwqAgLyogQ2xpZW50cyBpbmZvwqAgKi8KPj4gLcKgwqDC oCBndWNfY3RfcG9vbF9lbnRyaWVzX2luaXQoYmxvYi0+Y3RfcG9vbCwgQVJSQVlfU0laRShibG9i LT5jdF9wb29sKSk7Cj4+IC0KPj4gLcKgwqDCoCBibG9iLT5jbGllbnRzX2luZm8uY2xpZW50c19u dW0gPSAxOwo+PiAtwqDCoMKgIGJsb2ItPmNsaWVudHNfaW5mby5jdF9wb29sX2FkZHIgPSBiYXNl ICsgcHRyX29mZnNldChibG9iLCBjdF9wb29sKTsKPj4gLcKgwqDCoCBibG9iLT5jbGllbnRzX2lu Zm8uY3RfcG9vbF9jb3VudCA9IEFSUkFZX1NJWkUoYmxvYi0+Y3RfcG9vbCk7Cj4+IC0KPj4gwqDC oMKgwqDCoCAvKiBBRFMgKi8KPj4gwqDCoMKgwqDCoCBibG9iLT5hZHMuc2NoZWR1bGVyX3BvbGlj aWVzID0gYmFzZSArIHB0cl9vZmZzZXQoYmxvYiwgcG9saWNpZXMpOwo+PiDCoMKgwqDCoMKgIGJs b2ItPmFkcy5ndF9zeXN0ZW1faW5mbyA9IGJhc2UgKyBwdHJfb2Zmc2V0KGJsb2IsIHN5c3RlbV9p bmZvKTsKPj4gLcKgwqDCoCBibG9iLT5hZHMuY2xpZW50c19pbmZvID0gYmFzZSArIHB0cl9vZmZz ZXQoYmxvYiwgY2xpZW50c19pbmZvKTsKPj4gwqAgwqDCoMKgwqDCoCAvKiBQcml2YXRlIERhdGEg Ki8KPj4gwqDCoMKgwqDCoCBibG9iLT5hZHMucHJpdmF0ZV9kYXRhID0gYmFzZSArIGd1Y19hZHNf cHJpdmF0ZV9kYXRhX29mZnNldChndWMpOwo+PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX2N0LmMKPj4gYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91 Yy9pbnRlbF9ndWNfY3QuYwo+PiBpbmRleCA4ZjdiMTQ4ZmVmNTguLjQzNDA5MDQ0NTI4ZSAxMDA2 NDQKPj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX2N0LmMKPj4g KysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX2N0LmMKPj4gQEAgLTEw Myw2MSArMTAzLDY2IEBAIHZvaWQgaW50ZWxfZ3VjX2N0X2luaXRfZWFybHkoc3RydWN0IGludGVs X2d1Y19jdAo+PiAqY3QpCj4+IMKgIHN0YXRpYyBpbmxpbmUgY29uc3QgY2hhciAqZ3VjX2N0X2J1 ZmZlcl90eXBlX3RvX3N0cih1MzIgdHlwZSkKPj4gwqAgewo+PiDCoMKgwqDCoMKgIHN3aXRjaCAo dHlwZSkgewo+PiAtwqDCoMKgIGNhc2UgSU5URUxfR1VDX0NUX0JVRkZFUl9UWVBFX1NFTkQ6Cj4+ ICvCoMKgwqAgY2FzZSBHVUNfQ1RCX1RZUEVfSE9TVDJHVUM6Cj4+IMKgwqDCoMKgwqDCoMKgwqDC oCByZXR1cm4gIlNFTkQiOwo+PiAtwqDCoMKgIGNhc2UgSU5URUxfR1VDX0NUX0JVRkZFUl9UWVBF X1JFQ1Y6Cj4+ICvCoMKgwqAgY2FzZSBHVUNfQ1RCX1RZUEVfR1VDMkhPU1Q6Cj4+IMKgwqDCoMKg wqDCoMKgwqDCoCByZXR1cm4gIlJFQ1YiOwo+PiDCoMKgwqDCoMKgIGRlZmF1bHQ6Cj4+IMKgwqDC oMKgwqDCoMKgwqDCoCByZXR1cm4gIjxpbnZhbGlkPiI7Cj4+IMKgwqDCoMKgwqAgfQo+PiDCoCB9 Cj4+IMKgIC1zdGF0aWMgdm9pZCBndWNfY3RfYnVmZmVyX2Rlc2NfaW5pdChzdHJ1Y3QgZ3VjX2N0 X2J1ZmZlcl9kZXNjICpkZXNjLAo+PiAtwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqAgdTMyIGNtZHNfYWRkciwgdTMyIHNpemUpCj4+ICtzdGF0aWMgdm9pZCBndWNfY3RfYnVm ZmVyX2Rlc2NfaW5pdChzdHJ1Y3QgZ3VjX2N0X2J1ZmZlcl9kZXNjICpkZXNjKQo+PiDCoCB7Cj4+ IMKgwqDCoMKgwqAgbWVtc2V0KGRlc2MsIDAsIHNpemVvZigqZGVzYykpOwo+PiAtwqDCoMKgIGRl c2MtPmFkZHIgPSBjbWRzX2FkZHI7Cj4+IC3CoMKgwqAgZGVzYy0+c2l6ZSA9IHNpemU7Cj4+IC3C oMKgwqAgZGVzYy0+b3duZXIgPSBDVEJfT1dORVJfSE9TVDsKPj4gwqAgfQo+PiDCoCAtc3RhdGlj IHZvaWQgZ3VjX2N0X2J1ZmZlcl9yZXNldChzdHJ1Y3QgaW50ZWxfZ3VjX2N0X2J1ZmZlciAqY3Ri LAo+PiB1MzIgY21kc19hZGRyKQo+PiArc3RhdGljIHZvaWQgZ3VjX2N0X2J1ZmZlcl9yZXNldChz dHJ1Y3QgaW50ZWxfZ3VjX2N0X2J1ZmZlciAqY3RiKQo+PiDCoCB7Cj4+IC3CoMKgwqAgZ3VjX2N0 X2J1ZmZlcl9kZXNjX2luaXQoY3RiLT5kZXNjLCBjbWRzX2FkZHIsIGN0Yi0+c2l6ZSk7Cj4+ICvC oMKgwqAgY3RiLT5icm9rZW4gPSBmYWxzZTsKPj4gK8KgwqDCoCBndWNfY3RfYnVmZmVyX2Rlc2Nf aW5pdChjdGItPmRlc2MpOwo+PiDCoCB9Cj4+IMKgIMKgIHN0YXRpYyB2b2lkIGd1Y19jdF9idWZm ZXJfaW5pdChzdHJ1Y3QgaW50ZWxfZ3VjX2N0X2J1ZmZlciAqY3RiLAo+PiDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHN0cnVjdCBndWNfY3RfYnVmZmVyX2Rlc2MgKmRl c2MsCj4+IC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgdTMyICpjbWRzLCB1 MzIgc2l6ZSkKPj4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB1MzIgKmNt ZHMsIHUzMiBzaXplX2luX2J5dGVzKQo+PiDCoCB7Cj4+IC3CoMKgwqAgR0VNX0JVR19PTihzaXpl ICUgNCk7Cj4+ICvCoMKgwqAgR0VNX0JVR19PTihzaXplX2luX2J5dGVzICUgNCk7Cj4+IMKgIMKg wqDCoMKgwqAgY3RiLT5kZXNjID0gZGVzYzsKPj4gwqDCoMKgwqDCoCBjdGItPmNtZHMgPSBjbWRz Owo+PiAtwqDCoMKgIGN0Yi0+c2l6ZSA9IHNpemU7Cj4+ICvCoMKgwqAgY3RiLT5zaXplID0gc2l6 ZV9pbl9ieXRlcyAvIDQ7Cj4+IMKgIC3CoMKgwqAgZ3VjX2N0X2J1ZmZlcl9yZXNldChjdGIsIDAp Owo+PiArwqDCoMKgIGd1Y19jdF9idWZmZXJfcmVzZXQoY3RiKTsKPj4gwqAgfQo+PiDCoCAtc3Rh dGljIGludCBndWNfYWN0aW9uX3JlZ2lzdGVyX2N0X2J1ZmZlcihzdHJ1Y3QgaW50ZWxfZ3VjICpn dWMsCj4+IC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHUzMiBkZXNj X2FkZHIsCj4+IC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHUzMiB0 eXBlKQo+PiArc3RhdGljIGludCBndWNfYWN0aW9uX3JlZ2lzdGVyX2N0X2J1ZmZlcihzdHJ1Y3Qg aW50ZWxfZ3VjICpndWMsIHUzMgo+PiB0eXBlLAo+PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoCB1MzIgZGVzY19hZGRyLCB1MzIgYnVmZl9hZGRyLCB1MzIgc2l6ZSkK Pj4gwqAgewo+PiAtwqDCoMKgIHUzMiBhY3Rpb25bXSA9IHsKPj4gLcKgwqDCoMKgwqDCoMKgIElO VEVMX0dVQ19BQ1RJT05fUkVHSVNURVJfQ09NTUFORF9UUkFOU1BPUlRfQlVGRkVSLAo+PiAtwqDC oMKgwqDCoMKgwqAgZGVzY19hZGRyLAo+PiAtwqDCoMKgwqDCoMKgwqAgc2l6ZW9mKHN0cnVjdCBn dWNfY3RfYnVmZmVyX2Rlc2MpLAo+PiAtwqDCoMKgwqDCoMKgwqAgdHlwZQo+PiArwqDCoMKgIHUz MiByZXF1ZXN0W0hPU1QyR1VDX1JFR0lTVEVSX0NUQl9SRVFVRVNUX01TR19MRU5dID0gewo+PiAr wqDCoMKgwqDCoMKgwqAgRklFTERfUFJFUChHVUNfSFhHX01TR18wX09SSUdJTiwgR1VDX0hYR19P UklHSU5fSE9TVCkgfAo+PiArwqDCoMKgwqDCoMKgwqAgRklFTERfUFJFUChHVUNfSFhHX01TR18w X1RZUEUsIEdVQ19IWEdfVFlQRV9SRVFVRVNUKSB8Cj4+ICvCoMKgwqDCoMKgwqDCoCBGSUVMRF9Q UkVQKEdVQ19IWEdfUkVRVUVTVF9NU0dfMF9BQ1RJT04sCj4+IEdVQ19BQ1RJT05fSE9TVDJHVUNf UkVHSVNURVJfQ1RCKSwKPj4gK8KgwqDCoMKgwqDCoMKgIEZJRUxEX1BSRVAoSE9TVDJHVUNfUkVH SVNURVJfQ1RCX1JFUVVFU1RfTVNHXzFfU0laRSwgc2l6ZSAvCj4+IFNaXzRLIC0gMSkgfAo+PiAr wqDCoMKgwqDCoMKgwqAgRklFTERfUFJFUChIT1NUMkdVQ19SRUdJU1RFUl9DVEJfUkVRVUVTVF9N U0dfMV9UWVBFLCB0eXBlKSwKPj4gK8KgwqDCoMKgwqDCoMKgIEZJRUxEX1BSRVAoSE9TVDJHVUNf UkVHSVNURVJfQ1RCX1JFUVVFU1RfTVNHXzJfREVTQ19BRERSLAo+PiBkZXNjX2FkZHIpLAo+PiAr wqDCoMKgwqDCoMKgwqAgRklFTERfUFJFUChIT1NUMkdVQ19SRUdJU1RFUl9DVEJfUkVRVUVTVF9N U0dfM19CVUZGX0FERFIsCj4+IGJ1ZmZfYWRkciksCj4+IMKgwqDCoMKgwqAgfTsKPj4gwqAgLcKg wqDCoCAvKiBDYW4ndCB1c2UgZ2VuZXJpYyBzZW5kKCksIENUIHJlZ2lzdHJhdGlvbiBtdXN0IGdv IG92ZXIgTU1JTyAqLwo+PiAtwqDCoMKgIHJldHVybiBpbnRlbF9ndWNfc2VuZF9tbWlvKGd1Yywg YWN0aW9uLCBBUlJBWV9TSVpFKGFjdGlvbiksIE5VTEwsCj4+IDApOwo+PiArwqDCoMKgIEdFTV9C VUdfT04odHlwZSAhPSBHVUNfQ1RCX1RZUEVfSE9TVDJHVUMgJiYgdHlwZSAhPQo+PiBHVUNfQ1RC X1RZUEVfR1VDMkhPU1QpOwo+PiArwqDCoMKgIEdFTV9CVUdfT04oc2l6ZSAlIFNaXzRLKTsKPj4g Kwo+PiArwqDCoMKgIC8qIENUIHJlZ2lzdHJhdGlvbiBtdXN0IGdvIG92ZXIgTU1JTyAqLwo+PiAr wqDCoMKgIHJldHVybiBpbnRlbF9ndWNfc2VuZF9tbWlvKGd1YywgcmVxdWVzdCwgQVJSQVlfU0la RShyZXF1ZXN0KSwKPj4gTlVMTCwgMCk7Cj4+IMKgIH0KPj4gwqAgLXN0YXRpYyBpbnQgY3RfcmVn aXN0ZXJfYnVmZmVyKHN0cnVjdCBpbnRlbF9ndWNfY3QgKmN0LCB1MzIKPj4gZGVzY19hZGRyLCB1 MzIgdHlwZSkKPj4gK3N0YXRpYyBpbnQgY3RfcmVnaXN0ZXJfYnVmZmVyKHN0cnVjdCBpbnRlbF9n dWNfY3QgKmN0LCB1MzIgdHlwZSwKPj4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqAgdTMyIGRlc2NfYWRkciwgdTMyIGJ1ZmZfYWRkciwgdTMyIHNpemUpCj4+IMKgIHsKPj4gLcKg wqDCoCBpbnQgZXJyID0gZ3VjX2FjdGlvbl9yZWdpc3Rlcl9jdF9idWZmZXIoY3RfdG9fZ3VjKGN0 KSwgZGVzY19hZGRyLAo+PiB0eXBlKTsKPj4gK8KgwqDCoCBpbnQgZXJyOwo+PiDCoCArwqDCoMKg IGVyciA9IGd1Y19hY3Rpb25fcmVnaXN0ZXJfY3RfYnVmZmVyKGN0X3RvX2d1YyhjdCksIHR5cGUs Cj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRlc2Nf YWRkciwgYnVmZl9hZGRyLCBzaXplKTsKPj4gwqDCoMKgwqDCoCBpZiAodW5saWtlbHkoZXJyKSkK Pj4gwqDCoMKgwqDCoMKgwqDCoMKgIENUX0VSUk9SKGN0LCAiRmFpbGVkIHRvIHJlZ2lzdGVyICVz IGJ1ZmZlciAoZXJyPSVkKVxuIiwKPj4gwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBndWNf Y3RfYnVmZmVyX3R5cGVfdG9fc3RyKHR5cGUpLCBlcnIpOwo+PiBAQCAtMTY2LDE0ICsxNzEsMTcg QEAgc3RhdGljIGludCBjdF9yZWdpc3Rlcl9idWZmZXIoc3RydWN0Cj4+IGludGVsX2d1Y19jdCAq Y3QsIHUzMiBkZXNjX2FkZHIsIHUzMiB0eXBlKQo+PiDCoCDCoCBzdGF0aWMgaW50IGd1Y19hY3Rp b25fZGVyZWdpc3Rlcl9jdF9idWZmZXIoc3RydWN0IGludGVsX2d1YyAqZ3VjLAo+PiB1MzIgdHlw ZSkKPj4gwqAgewo+PiAtwqDCoMKgIHUzMiBhY3Rpb25bXSA9IHsKPj4gLcKgwqDCoMKgwqDCoMKg IElOVEVMX0dVQ19BQ1RJT05fREVSRUdJU1RFUl9DT01NQU5EX1RSQU5TUE9SVF9CVUZGRVIsCj4+ IC3CoMKgwqDCoMKgwqDCoCBDVEJfT1dORVJfSE9TVCwKPj4gLcKgwqDCoMKgwqDCoMKgIHR5cGUK Pj4gK8KgwqDCoCB1MzIgcmVxdWVzdFtIT1NUMkdVQ19ERVJFR0lTVEVSX0NUQl9SRVFVRVNUX01T R19MRU5dID0gewo+PiArwqDCoMKgwqDCoMKgwqAgRklFTERfUFJFUChHVUNfSFhHX01TR18wX09S SUdJTiwgR1VDX0hYR19PUklHSU5fSE9TVCkgfAo+PiArwqDCoMKgwqDCoMKgwqAgRklFTERfUFJF UChHVUNfSFhHX01TR18wX1RZUEUsIEdVQ19IWEdfVFlQRV9SRVFVRVNUKSB8Cj4+ICvCoMKgwqDC oMKgwqDCoCBGSUVMRF9QUkVQKEdVQ19IWEdfUkVRVUVTVF9NU0dfMF9BQ1RJT04sCj4+IEdVQ19B Q1RJT05fSE9TVDJHVUNfREVSRUdJU1RFUl9DVEIpLAo+PiArwqDCoMKgwqDCoMKgwqAgRklFTERf UFJFUChIT1NUMkdVQ19ERVJFR0lTVEVSX0NUQl9SRVFVRVNUX01TR18xX1RZUEUsIHR5cGUpLAo+ PiDCoMKgwqDCoMKgIH07Cj4+IMKgIC3CoMKgwqAgLyogQ2FuJ3QgdXNlIGdlbmVyaWMgc2VuZCgp LCBDVCBkZXJlZ2lzdHJhdGlvbiBtdXN0IGdvIG92ZXIKPj4gTU1JTyAqLwo+PiAtwqDCoMKgIHJl dHVybiBpbnRlbF9ndWNfc2VuZF9tbWlvKGd1YywgYWN0aW9uLCBBUlJBWV9TSVpFKGFjdGlvbiks IE5VTEwsCj4+IDApOwo+PiArwqDCoMKgIEdFTV9CVUdfT04odHlwZSAhPSBHVUNfQ1RCX1RZUEVf SE9TVDJHVUMgJiYgdHlwZSAhPQo+PiBHVUNfQ1RCX1RZUEVfR1VDMkhPU1QpOwo+PiArCj4+ICvC oMKgwqAgLyogQ1QgZGVyZWdpc3RyYXRpb24gbXVzdCBnbyBvdmVyIE1NSU8gKi8KPj4gK8KgwqDC oCByZXR1cm4gaW50ZWxfZ3VjX3NlbmRfbW1pbyhndWMsIHJlcXVlc3QsIEFSUkFZX1NJWkUocmVx dWVzdCksCj4+IE5VTEwsIDApOwo+PiDCoCB9Cj4+IMKgIMKgIHN0YXRpYyBpbnQgY3RfZGVyZWdp c3Rlcl9idWZmZXIoc3RydWN0IGludGVsX2d1Y19jdCAqY3QsIHUzMiB0eXBlKQo+PiBAQCAtMjYx LDcgKzI2OSw3IEBAIHZvaWQgaW50ZWxfZ3VjX2N0X2Zpbmkoc3RydWN0IGludGVsX2d1Y19jdCAq Y3QpCj4+IMKgIGludCBpbnRlbF9ndWNfY3RfZW5hYmxlKHN0cnVjdCBpbnRlbF9ndWNfY3QgKmN0 KQo+PiDCoCB7Cj4+IMKgwqDCoMKgwqAgc3RydWN0IGludGVsX2d1YyAqZ3VjID0gY3RfdG9fZ3Vj KGN0KTsKPj4gLcKgwqDCoCB1MzIgYmFzZSwgY21kczsKPj4gK8KgwqDCoCB1MzIgYmFzZSwgZGVz YywgY21kczsKPj4gwqDCoMKgwqDCoCB2b2lkICpibG9iOwo+PiDCoMKgwqDCoMKgIGludCBlcnI7 Cj4+IMKgIEBAIC0yNzcsMjMgKzI4NSwyNiBAQCBpbnQgaW50ZWxfZ3VjX2N0X2VuYWJsZShzdHJ1 Y3QgaW50ZWxfZ3VjX2N0ICpjdCkKPj4gwqDCoMKgwqDCoCBHRU1fQlVHX09OKGJsb2IgIT0gY3Qt PmN0YnMuc2VuZC5kZXNjKTsKPj4gwqAgwqDCoMKgwqDCoCAvKiAocmUpaW5pdGlhbGl6ZSBkZXNj cmlwdG9ycyAqLwo+PiAtwqDCoMKgIGNtZHMgPSBiYXNlICsgcHRyZGlmZihjdC0+Y3Ricy5zZW5k LmNtZHMsIGJsb2IpOwo+PiAtwqDCoMKgIGd1Y19jdF9idWZmZXJfcmVzZXQoJmN0LT5jdGJzLnNl bmQsIGNtZHMpOwo+PiAtCj4+IC3CoMKgwqAgY21kcyA9IGJhc2UgKyBwdHJkaWZmKGN0LT5jdGJz LnJlY3YuY21kcywgYmxvYik7Cj4+IC3CoMKgwqAgZ3VjX2N0X2J1ZmZlcl9yZXNldCgmY3QtPmN0 YnMucmVjdiwgY21kcyk7Cj4+ICvCoMKgwqAgZ3VjX2N0X2J1ZmZlcl9yZXNldCgmY3QtPmN0YnMu c2VuZCk7Cj4+ICvCoMKgwqAgZ3VjX2N0X2J1ZmZlcl9yZXNldCgmY3QtPmN0YnMucmVjdik7Cj4+ IMKgIMKgwqDCoMKgwqAgLyoKPj4gwqDCoMKgwqDCoMKgICogUmVnaXN0ZXIgYm90aCBDVCBidWZm ZXJzIHN0YXJ0aW5nIHdpdGggUkVDViBidWZmZXIuCj4+IMKgwqDCoMKgwqDCoCAqIERlc2NyaXB0 b3JzIGFyZSBpbiBmaXJzdCBoYWxmIG9mIHRoZSBibG9iLgo+PiDCoMKgwqDCoMKgwqAgKi8KPj4g LcKgwqDCoCBlcnIgPSBjdF9yZWdpc3Rlcl9idWZmZXIoY3QsIGJhc2UgKyBwdHJkaWZmKGN0LT5j dGJzLnJlY3YuZGVzYywKPj4gYmxvYiksCj4+IC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoCBJTlRFTF9HVUNfQ1RfQlVGRkVSX1RZUEVfUkVDVik7Cj4+ICvCoMKgwqAgZGVzYyA9IGJh c2UgKyBwdHJkaWZmKGN0LT5jdGJzLnJlY3YuZGVzYywgYmxvYik7Cj4+ICvCoMKgwqAgY21kcyA9 IGJhc2UgKyBwdHJkaWZmKGN0LT5jdGJzLnJlY3YuY21kcywgYmxvYik7Cj4+ICvCoMKgwqAgZXJy ID0gY3RfcmVnaXN0ZXJfYnVmZmVyKGN0LCBHVUNfQ1RCX1RZUEVfR1VDMkhPU1QsCj4+ICvCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBkZXNjLCBjbWRzLCBjdC0+Y3Ricy5yZWN2LnNp emUgKiA0KTsKPj4gKwo+PiDCoMKgwqDCoMKgIGlmICh1bmxpa2VseShlcnIpKQo+PiDCoMKgwqDC oMKgwqDCoMKgwqAgZ290byBlcnJfb3V0Owo+PiDCoCAtwqDCoMKgIGVyciA9IGN0X3JlZ2lzdGVy X2J1ZmZlcihjdCwgYmFzZSArIHB0cmRpZmYoY3QtPmN0YnMuc2VuZC5kZXNjLAo+PiBibG9iKSwK Pj4gLcKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIElOVEVMX0dVQ19DVF9CVUZGRVJf VFlQRV9TRU5EKTsKPj4gK8KgwqDCoCBkZXNjID0gYmFzZSArIHB0cmRpZmYoY3QtPmN0YnMuc2Vu ZC5kZXNjLCBibG9iKTsKPj4gK8KgwqDCoCBjbWRzID0gYmFzZSArIHB0cmRpZmYoY3QtPmN0YnMu c2VuZC5jbWRzLCBibG9iKTsKPj4gK8KgwqDCoCBlcnIgPSBjdF9yZWdpc3Rlcl9idWZmZXIoY3Qs IEdVQ19DVEJfVFlQRV9IT1NUMkdVQywKPj4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgIGRlc2MsIGNtZHMsIGN0LT5jdGJzLnNlbmQuc2l6ZSAqIDQpOwo+PiArCj4+IMKgwqDCoMKg wqAgaWYgKHVubGlrZWx5KGVycikpCj4+IMKgwqDCoMKgwqDCoMKgwqDCoCBnb3RvIGVycl9kZXJl Z2lzdGVyOwo+PiDCoCBAQCAtMzAyLDcgKzMxMyw3IEBAIGludCBpbnRlbF9ndWNfY3RfZW5hYmxl KHN0cnVjdCBpbnRlbF9ndWNfY3QgKmN0KQo+PiDCoMKgwqDCoMKgIHJldHVybiAwOwo+PiDCoCDC oCBlcnJfZGVyZWdpc3RlcjoKPj4gLcKgwqDCoCBjdF9kZXJlZ2lzdGVyX2J1ZmZlcihjdCwgSU5U RUxfR1VDX0NUX0JVRkZFUl9UWVBFX1JFQ1YpOwo+PiArwqDCoMKgIGN0X2RlcmVnaXN0ZXJfYnVm ZmVyKGN0LCBHVUNfQ1RCX1RZUEVfR1VDMkhPU1QpOwo+PiDCoCBlcnJfb3V0Ogo+PiDCoMKgwqDC oMKgIENUX1BST0JFX0VSUk9SKGN0LCAiRmFpbGVkIHRvIGVuYWJsZSBDVEIgKCVwZSlcbiIsIEVS Ul9QVFIoZXJyKSk7Cj4+IMKgwqDCoMKgwqAgcmV0dXJuIGVycjsKPj4gQEAgLTMyMSw4ICszMzIs OCBAQCB2b2lkIGludGVsX2d1Y19jdF9kaXNhYmxlKHN0cnVjdCBpbnRlbF9ndWNfY3QgKmN0KQo+ PiDCoMKgwqDCoMKgIGN0LT5lbmFibGVkID0gZmFsc2U7Cj4+IMKgIMKgwqDCoMKgwqAgaWYgKGlu dGVsX2d1Y19pc19md19ydW5uaW5nKGd1YykpIHsKPj4gLcKgwqDCoMKgwqDCoMKgIGN0X2RlcmVn aXN0ZXJfYnVmZmVyKGN0LCBJTlRFTF9HVUNfQ1RfQlVGRkVSX1RZUEVfU0VORCk7Cj4+IC3CoMKg wqDCoMKgwqDCoCBjdF9kZXJlZ2lzdGVyX2J1ZmZlcihjdCwgSU5URUxfR1VDX0NUX0JVRkZFUl9U WVBFX1JFQ1YpOwo+PiArwqDCoMKgwqDCoMKgwqAgY3RfZGVyZWdpc3Rlcl9idWZmZXIoY3QsIEdV Q19DVEJfVFlQRV9IT1NUMkdVQyk7Cj4+ICvCoMKgwqDCoMKgwqDCoCBjdF9kZXJlZ2lzdGVyX2J1 ZmZlcihjdCwgR1VDX0NUQl9UWVBFX0dVQzJIT1NUKTsKPj4gwqDCoMKgwqDCoCB9Cj4+IMKgIH0K Pj4gwqAgQEAgLTM1NCwyNCArMzY1LDYgQEAgc3RhdGljIHZvaWQgd3JpdGVfYmFycmllcihzdHJ1 Y3QgaW50ZWxfZ3VjX2N0ICpjdCkKPj4gwqDCoMKgwqDCoCB9Cj4+IMKgIH0KPj4gwqAgLS8qKgo+ PiAtICogRE9DOiBDVEIgSG9zdCB0byBHdUMgcmVxdWVzdAo+PiAtICoKPj4gLSAqIEZvcm1hdCBv ZiB0aGUgQ1RCIEhvc3QgdG8gR3VDIHJlcXVlc3QgbWVzc2FnZSBpcyBhcyBmb2xsb3dzOjoKPj4g LSAqCj4+IC0gKsKgwqDCoMKgwqAgKy0tLS0tLS0tLS0tLSstLS0tLS0tLS0rLS0tLS0tLS0tKy0t LS0tLS0tLSstLS0tLS0tLS0rCj4+IC0gKsKgwqDCoMKgwqAgfMKgwqAgbXNnWzBdwqDCoCB8wqDC oCBbMV3CoMKgIHzCoMKgIFsyXcKgwqAgfMKgwqAgLi4uwqDCoCB8wqAgW24tMV3CoCB8Cj4+IC0g KsKgwqDCoMKgwqAgKy0tLS0tLS0tLS0tLSstLS0tLS0tLS0rLS0tLS0tLS0tKy0tLS0tLS0tLSst LS0tLS0tLS0rCj4+IC0gKsKgwqDCoMKgwqAgfMKgwqAgTUVTU0FHRcKgIHzCoMKgwqDCoMKgwqAg TUVTU0FHRSBQQVlMT0FEwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgfAo+PiAtICrC oMKgwqDCoMKgICvCoMKgIEhFQURFUsKgwqAgKy0tLS0tLS0tLSstLS0tLS0tLS0rLS0tLS0tLS0t Ky0tLS0tLS0tLSsKPj4gLSAqwqDCoMKgwqDCoCB8wqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB8wqDC oMKgIDDCoMKgwqAgfMKgwqDCoCAxwqDCoMKgIHzCoMKgIC4uLsKgwqAgfMKgwqDCoCBuwqDCoMKg IHwKPj4gLSAqwqDCoMKgwqDCoCArPT09PT09PT09PT09Kz09PT09PT09PSs9PT09PT09PT0rPT09 PT09PT09Kz09PT09PT09PSsKPj4gLSAqwqDCoMKgwqDCoCB8wqAgbGVuID49IDHCoCB8wqAgRkVO Q0XCoCB8wqDCoMKgwqAgcmVxdWVzdCBzcGVjaWZpYyBkYXRhwqDCoCB8Cj4+IC0gKsKgwqDCoMKg wqAgKy0tLS0tLSstLS0tLSstLS0tLS0tLS0rLS0tLS0tLS0tKy0tLS0tLS0tLSstLS0tLS0tLS0r Cj4+IC0gKgo+PiAtICrCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgXi0tLS0t LS0tLS0tLS0tLS0tbGVuLS0tLS0tLS0tLS0tLS0tLS0tLV4KPj4gLSAqLwo+PiAtCj4+IMKgIHN0 YXRpYyBpbnQgY3Rfd3JpdGUoc3RydWN0IGludGVsX2d1Y19jdCAqY3QsCj4+IMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgIGNvbnN0IHUzMiAqYWN0aW9uLAo+PiDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoCB1MzIgbGVuIC8qIGluIGR3b3JkcyAqLywKPj4gQEAgLTM4NCwyMCArMzc3LDIyIEBA IHN0YXRpYyBpbnQgY3Rfd3JpdGUoc3RydWN0IGludGVsX2d1Y19jdCAqY3QsCj4+IMKgwqDCoMKg wqAgdTMyIHNpemUgPSBjdGItPnNpemU7Cj4+IMKgwqDCoMKgwqAgdTMyIHVzZWQ7Cj4+IMKgwqDC oMKgwqAgdTMyIGhlYWRlcjsKPj4gK8KgwqDCoCB1MzIgaHhnOwo+PiDCoMKgwqDCoMKgIHUzMiAq Y21kcyA9IGN0Yi0+Y21kczsKPj4gwqDCoMKgwqDCoCB1bnNpZ25lZCBpbnQgaTsKPj4gwqAgLcKg wqDCoCBpZiAodW5saWtlbHkoZGVzYy0+aXNfaW5fZXJyb3IpKQo+PiArwqDCoMKgIGlmICh1bmxp a2VseShjdGItPmJyb2tlbikpCj4+IMKgwqDCoMKgwqDCoMKgwqDCoCByZXR1cm4gLUVQSVBFOwo+ PiDCoCAtwqDCoMKgIGlmICh1bmxpa2VseSghSVNfQUxJR05FRChoZWFkIHwgdGFpbCwgNCkgfHwK Pj4gLcKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAodGFpbCB8IGhlYWQpID49IHNpemUpKQo+PiAr wqDCoMKgIGlmICh1bmxpa2VseShkZXNjLT5zdGF0dXMpKQo+PiDCoMKgwqDCoMKgwqDCoMKgwqAg Z290byBjb3JydXB0ZWQ7Cj4+IMKgIC3CoMKgwqAgLyogbGF0ZXIgY2FsY3VsYXRpb25zIHdpbGwg YmUgZG9uZSBpbiBkd29yZHMgKi8KPj4gLcKgwqDCoCBoZWFkIC89IDQ7Cj4+IC3CoMKgwqAgdGFp bCAvPSA0Owo+PiAtwqDCoMKgIHNpemUgLz0gNDsKPj4gK8KgwqDCoCBpZiAodW5saWtlbHkoKHRh aWwgfCBoZWFkKSA+PSBzaXplKSkgewo+PiArwqDCoMKgwqDCoMKgwqAgQ1RfRVJST1IoY3QsICJJ bnZhbGlkIG9mZnNldHMgaGVhZD0ldSB0YWlsPSV1IChzaXplPSV1KVxuIiwKPj4gK8KgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoCBoZWFkLCB0YWlsLCBzaXplKTsKPj4gK8KgwqDCoMKgwqDCoMKgIGRl c2MtPnN0YXR1cyB8PSBHVUNfQ1RCX1NUQVRVU19PVkVSRkxPVzsKPj4gK8KgwqDCoMKgwqDCoMKg IGdvdG8gY29ycnVwdGVkOwo+PiArwqDCoMKgIH0KPj4gwqAgwqDCoMKgwqDCoCAvKgo+PiDCoMKg wqDCoMKgwqAgKiB0YWlsID09IGhlYWQgY29uZGl0aW9uIGluZGljYXRlcyBlbXB0eS4gR3VDIEZX IGRvZXMgbm90IHN1cHBvcnQKPj4gQEAgLTQxMywyMiArNDA4LDI1IEBAIHN0YXRpYyBpbnQgY3Rf d3JpdGUoc3RydWN0IGludGVsX2d1Y19jdCAqY3QsCj4+IMKgwqDCoMKgwqDCoMKgwqDCoCByZXR1 cm4gLUVOT1NQQzsKPj4gwqAgwqDCoMKgwqDCoCAvKgo+PiAtwqDCoMKgwqAgKiBXcml0ZSB0aGUg bWVzc2FnZS4gVGhlIGZvcm1hdCBpcyB0aGUgZm9sbG93aW5nOgo+PiAtwqDCoMKgwqAgKiBEVzA6 IGhlYWRlciAoaW5jbHVkaW5nIGFjdGlvbiBjb2RlKQo+PiAtwqDCoMKgwqAgKiBEVzE6IGZlbmNl Cj4+IC3CoMKgwqDCoCAqIERXMis6IGFjdGlvbiBkYXRhCj4+ICvCoMKgwqDCoCAqIGR3MDogQ1Qg aGVhZGVyIChpbmNsdWRpbmcgZmVuY2UpCj4+ICvCoMKgwqDCoCAqIGR3MTogSFhHIGhlYWRlciAo aW5jbHVkaW5nIGFjdGlvbiBjb2RlKQo+PiArwqDCoMKgwqAgKiBkdzIrOiBhY3Rpb24gZGF0YQo+ PiDCoMKgwqDCoMKgwqAgKi8KPj4gLcKgwqDCoCBoZWFkZXIgPSAobGVuIDw8IEdVQ19DVF9NU0df TEVOX1NISUZUKSB8Cj4+IC3CoMKgwqDCoMKgwqDCoMKgIEdVQ19DVF9NU0dfU0VORF9TVEFUVVMg fAo+PiAtwqDCoMKgwqDCoMKgwqDCoCAoYWN0aW9uWzBdIDw8IEdVQ19DVF9NU0dfQUNUSU9OX1NI SUZUKTsKPj4gK8KgwqDCoCBoZWFkZXIgPSBGSUVMRF9QUkVQKEdVQ19DVEJfTVNHXzBfRk9STUFU LCBHVUNfQ1RCX0ZPUk1BVF9IWEcpIHwKPj4gK8KgwqDCoMKgwqDCoMKgwqAgRklFTERfUFJFUChH VUNfQ1RCX01TR18wX05VTV9EV09SRFMsIGxlbikgfAo+PiArwqDCoMKgwqDCoMKgwqDCoCBGSUVM RF9QUkVQKEdVQ19DVEJfTVNHXzBfRkVOQ0UsIGZlbmNlKTsKPj4gwqAgLcKgwqDCoCBDVF9ERUJV RyhjdCwgIndyaXRpbmcgJSpwaCAlKnBoICUqcGhcbiIsCj4+IC3CoMKgwqDCoMKgwqDCoMKgIDQs ICZoZWFkZXIsIDQsICZmZW5jZSwgNCAqIChsZW4gLSAxKSwgJmFjdGlvblsxXSk7Cj4+ICvCoMKg wqAgaHhnID0gRklFTERfUFJFUChHVUNfSFhHX01TR18wX1RZUEUsIEdVQ19IWEdfVFlQRV9SRVFV RVNUKSB8Cj4+ICvCoMKgwqDCoMKgwqDCoMKgwqAgRklFTERfUFJFUChHVUNfSFhHX1JFUVVFU1Rf TVNHXzBfQUNUSU9OIHwKPj4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBHVUNfSFhHX1JFUVVF U1RfTVNHXzBfREFUQTAsIGFjdGlvblswXSk7Cj4+ICsKPj4gK8KgwqDCoCBDVF9ERUJVRyhjdCwg IndyaXRpbmcgKHRhaWwgJXUpICUqcGggJSpwaCAlKnBoXG4iLAo+PiArwqDCoMKgwqDCoMKgwqDC oCB0YWlsLCA0LCAmaGVhZGVyLCA0LCAmaHhnLCA0ICogKGxlbiAtIDEpLCAmYWN0aW9uWzFdKTsK Pj4gwqAgwqDCoMKgwqDCoCBjbWRzW3RhaWxdID0gaGVhZGVyOwo+PiDCoMKgwqDCoMKgIHRhaWwg PSAodGFpbCArIDEpICUgc2l6ZTsKPj4gwqAgLcKgwqDCoCBjbWRzW3RhaWxdID0gZmVuY2U7Cj4+ ICvCoMKgwqAgY21kc1t0YWlsXSA9IGh4ZzsKPj4gwqDCoMKgwqDCoCB0YWlsID0gKHRhaWwgKyAx KSAlIHNpemU7Cj4+IMKgIMKgwqDCoMKgwqAgZm9yIChpID0gMTsgaSA8IGxlbjsgaSsrKSB7Cj4+ IEBAIC00NDMsMTQgKzQ0MSwxNSBAQCBzdGF0aWMgaW50IGN0X3dyaXRlKHN0cnVjdCBpbnRlbF9n dWNfY3QgKmN0LAo+PiDCoMKgwqDCoMKgwqAgKi8KPj4gwqDCoMKgwqDCoCB3cml0ZV9iYXJyaWVy KGN0KTsKPj4gwqAgLcKgwqDCoCAvKiBub3cgdXBkYXRlIGRlc2MgdGFpbCAoYmFjayBpbiBieXRl cykgKi8KPj4gLcKgwqDCoCBkZXNjLT50YWlsID0gdGFpbCAqIDQ7Cj4+ICvCoMKgwqAgLyogbm93 IHVwZGF0ZSBkZXNjcmlwdG9yICovCj4+ICvCoMKgwqAgV1JJVEVfT05DRShkZXNjLT50YWlsLCB0 YWlsKTsKPj4gKwo+PiDCoMKgwqDCoMKgIHJldHVybiAwOwo+PiDCoCDCoCBjb3JydXB0ZWQ6Cj4+ IC3CoMKgwqAgQ1RfRVJST1IoY3QsICJDb3JydXB0ZWQgZGVzY3JpcHRvciBhZGRyPSUjeCBoZWFk PSV1IHRhaWw9JXUKPj4gc2l6ZT0ldVxuIiwKPj4gLcKgwqDCoMKgwqDCoMKgwqAgZGVzYy0+YWRk ciwgZGVzYy0+aGVhZCwgZGVzYy0+dGFpbCwgZGVzYy0+c2l6ZSk7Cj4+IC3CoMKgwqAgZGVzYy0+ aXNfaW5fZXJyb3IgPSAxOwo+PiArwqDCoMKgIENUX0VSUk9SKGN0LCAiQ29ycnVwdGVkIGRlc2Ny aXB0b3IgaGVhZD0ldSB0YWlsPSV1IHN0YXR1cz0lI3hcbiIsCj4+ICvCoMKgwqDCoMKgwqDCoMKg IGRlc2MtPmhlYWQsIGRlc2MtPnRhaWwsIGRlc2MtPnN0YXR1cyk7Cj4+ICvCoMKgwqAgY3RiLT5i cm9rZW4gPSB0cnVlOwo+PiDCoMKgwqDCoMKgIHJldHVybiAtRVBJUEU7Cj4+IMKgIH0KPj4gwqAg QEAgLTQ3Nyw3ICs0NzYsOSBAQCBzdGF0aWMgaW50IHdhaXRfZm9yX2N0X3JlcXVlc3RfdXBkYXRl KHN0cnVjdAo+PiBjdF9yZXF1ZXN0ICpyZXEsIHUzMiAqc3RhdHVzKQo+PiDCoMKgwqDCoMKgwqAg KiB1cCB0byB0aGF0IGxlbmd0aCBvZiB0aW1lLCB0aGVuIHN3aXRjaCB0byBhIHNsb3dlciBzbGVl cC13YWl0Cj4+IGxvb3AuCj4+IMKgwqDCoMKgwqDCoCAqIE5vIEd1QyBjb21tYW5kIHNob3VsZCBl dmVyIHRha2UgbG9uZ2VyIHRoYW4gMTBtcy4KPj4gwqDCoMKgwqDCoMKgICovCj4+IC0jZGVmaW5l IGRvbmUgSU5URUxfR1VDX01TR19JU19SRVNQT05TRShSRUFEX09OQ0UocmVxLT5zdGF0dXMpKQo+ PiArI2RlZmluZSBkb25lIFwKPj4gK8KgwqDCoCAoRklFTERfR0VUKEdVQ19IWEdfTVNHXzBfT1JJ R0lOLCBSRUFEX09OQ0UocmVxLT5zdGF0dXMpKSA9PSBcCj4+ICvCoMKgwqDCoCBHVUNfSFhHX09S SUdJTl9HVUMpCj4+IMKgwqDCoMKgwqAgZXJyID0gd2FpdF9mb3JfdXMoZG9uZSwgMTApOwo+PiDC oMKgwqDCoMKgIGlmIChlcnIpCj4+IMKgwqDCoMKgwqDCoMKgwqDCoCBlcnIgPSB3YWl0X2Zvcihk b25lLCAxMCk7Cj4+IEBAIC01MzIsMjEgKzUzMywyMSBAQCBzdGF0aWMgaW50IGN0X3NlbmQoc3Ry dWN0IGludGVsX2d1Y19jdCAqY3QsCj4+IMKgwqDCoMKgwqAgaWYgKHVubGlrZWx5KGVycikpCj4+ IMKgwqDCoMKgwqDCoMKgwqDCoCBnb3RvIHVubGluazsKPj4gwqAgLcKgwqDCoCBpZiAoIUlOVEVM X0dVQ19NU0dfSVNfUkVTUE9OU0VfU1VDQ0VTUygqc3RhdHVzKSkgewo+PiArwqDCoMKgIGlmIChG SUVMRF9HRVQoR1VDX0hYR19NU0dfMF9UWVBFLCAqc3RhdHVzKSAhPQo+PiBHVUNfSFhHX1RZUEVf UkVTUE9OU0VfU1VDQ0VTUykgewo+PiDCoMKgwqDCoMKgwqDCoMKgwqAgZXJyID0gLUVJTzsKPj4g wqDCoMKgwqDCoMKgwqDCoMKgIGdvdG8gdW5saW5rOwo+PiDCoMKgwqDCoMKgIH0KPj4gwqAgwqDC oMKgwqDCoCBpZiAocmVzcG9uc2VfYnVmKSB7Cj4+IMKgwqDCoMKgwqDCoMKgwqDCoCAvKiBUaGVy ZSBzaGFsbCBiZSBubyBkYXRhIGluIHRoZSBzdGF0dXMgKi8KPj4gLcKgwqDCoMKgwqDCoMKgIFdB Uk5fT04oSU5URUxfR1VDX01TR19UT19EQVRBKHJlcXVlc3Quc3RhdHVzKSk7Cj4+ICvCoMKgwqDC oMKgwqDCoCBXQVJOX09OKEZJRUxEX0dFVChHVUNfSFhHX1JFU1BPTlNFX01TR18wX0RBVEEwLAo+ PiByZXF1ZXN0LnN0YXR1cykpOwo+PiDCoMKgwqDCoMKgwqDCoMKgwqAgLyogUmV0dXJuIGFjdHVh bCByZXNwb25zZSBsZW4gKi8KPj4gwqDCoMKgwqDCoMKgwqDCoMKgIGVyciA9IHJlcXVlc3QucmVz cG9uc2VfbGVuOwo+PiDCoMKgwqDCoMKgIH0gZWxzZSB7Cj4+IMKgwqDCoMKgwqDCoMKgwqDCoCAv KiBUaGVyZSBzaGFsbCBiZSBubyByZXNwb25zZSBwYXlsb2FkICovCj4+IMKgwqDCoMKgwqDCoMKg wqDCoCBXQVJOX09OKHJlcXVlc3QucmVzcG9uc2VfbGVuKTsKPj4gwqDCoMKgwqDCoMKgwqDCoMKg IC8qIFJldHVybiBkYXRhIGRlY29kZWQgZnJvbSB0aGUgc3RhdHVzIGR3b3JkICovCj4+IC3CoMKg wqDCoMKgwqDCoCBlcnIgPSBJTlRFTF9HVUNfTVNHX1RPX0RBVEEoKnN0YXR1cyk7Cj4+ICvCoMKg wqDCoMKgwqDCoCBlcnIgPSBGSUVMRF9HRVQoR1VDX0hYR19SRVNQT05TRV9NU0dfMF9EQVRBMCwg KnN0YXR1cyk7Cj4+IMKgwqDCoMKgwqAgfQo+PiDCoCDCoCB1bmxpbms6Cj4+IEBAIC01ODMsMjEg KzU4NCw2IEBAIGludCBpbnRlbF9ndWNfY3Rfc2VuZChzdHJ1Y3QgaW50ZWxfZ3VjX2N0ICpjdCwK Pj4gY29uc3QgdTMyICphY3Rpb24sIHUzMiBsZW4sCj4+IMKgwqDCoMKgwqAgcmV0dXJuIHJldDsK Pj4gwqAgfQo+PiDCoCAtc3RhdGljIGlubGluZSB1bnNpZ25lZCBpbnQgY3RfaGVhZGVyX2dldF9s ZW4odTMyIGhlYWRlcikKPj4gLXsKPj4gLcKgwqDCoCByZXR1cm4gKGhlYWRlciA+PiBHVUNfQ1Rf TVNHX0xFTl9TSElGVCkgJiBHVUNfQ1RfTVNHX0xFTl9NQVNLOwo+PiAtfQo+PiAtCj4+IC1zdGF0 aWMgaW5saW5lIHVuc2lnbmVkIGludCBjdF9oZWFkZXJfZ2V0X2FjdGlvbih1MzIgaGVhZGVyKQo+ PiAtewo+PiAtwqDCoMKgIHJldHVybiAoaGVhZGVyID4+IEdVQ19DVF9NU0dfQUNUSU9OX1NISUZU KSAmIEdVQ19DVF9NU0dfQUNUSU9OX01BU0s7Cj4+IC19Cj4+IC0KPj4gLXN0YXRpYyBpbmxpbmUg Ym9vbCBjdF9oZWFkZXJfaXNfcmVzcG9uc2UodTMyIGhlYWRlcikKPj4gLXsKPj4gLcKgwqDCoCBy ZXR1cm4gISEoaGVhZGVyICYgR1VDX0NUX01TR19JU19SRVNQT05TRSk7Cj4+IC19Cj4+IC0KPj4g wqAgc3RhdGljIHN0cnVjdCBjdF9pbmNvbWluZ19tc2cgKmN0X2FsbG9jX21zZyh1MzIgbnVtX2R3 b3JkcykKPj4gwqAgewo+PiDCoMKgwqDCoMKgIHN0cnVjdCBjdF9pbmNvbWluZ19tc2cgKm1zZzsK Pj4gQEAgLTYzMCwxNyArNjE2LDE4IEBAIHN0YXRpYyBpbnQgY3RfcmVhZChzdHJ1Y3QgaW50ZWxf Z3VjX2N0ICpjdCwKPj4gc3RydWN0IGN0X2luY29taW5nX21zZyAqKm1zZykKPj4gwqDCoMKgwqDC oCB1bnNpZ25lZCBpbnQgaTsKPj4gwqDCoMKgwqDCoCB1MzIgaGVhZGVyOwo+PiDCoCAtwqDCoMKg IGlmICh1bmxpa2VseShkZXNjLT5pc19pbl9lcnJvcikpCj4+ICvCoMKgwqAgaWYgKHVubGlrZWx5 KGN0Yi0+YnJva2VuKSkKPj4gwqDCoMKgwqDCoMKgwqDCoMKgIHJldHVybiAtRVBJUEU7Cj4+IMKg IC3CoMKgwqAgaWYgKHVubGlrZWx5KCFJU19BTElHTkVEKGhlYWQgfCB0YWlsLCA0KSB8fAo+PiAt wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgICh0YWlsIHwgaGVhZCkgPj0gc2l6ZSkpCj4+ICvCoMKg wqAgaWYgKHVubGlrZWx5KGRlc2MtPnN0YXR1cykpCj4+IMKgwqDCoMKgwqDCoMKgwqDCoCBnb3Rv IGNvcnJ1cHRlZDsKPj4gwqAgLcKgwqDCoCAvKiBsYXRlciBjYWxjdWxhdGlvbnMgd2lsbCBiZSBk b25lIGluIGR3b3JkcyAqLwo+PiAtwqDCoMKgIGhlYWQgLz0gNDsKPj4gLcKgwqDCoCB0YWlsIC89 IDQ7Cj4+IC3CoMKgwqAgc2l6ZSAvPSA0Owo+PiArwqDCoMKgIGlmICh1bmxpa2VseSgodGFpbCB8 IGhlYWQpID49IHNpemUpKSB7Cj4+ICvCoMKgwqDCoMKgwqDCoCBDVF9FUlJPUihjdCwgIkludmFs aWQgb2Zmc2V0cyBoZWFkPSV1IHRhaWw9JXUgKHNpemU9JXUpXG4iLAo+PiArwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgIGhlYWQsIHRhaWwsIHNpemUpOwo+PiArwqDCoMKgwqDCoMKgwqAgZGVzYy0+ c3RhdHVzIHw9IEdVQ19DVEJfU1RBVFVTX09WRVJGTE9XOwo+PiArwqDCoMKgwqDCoMKgwqAgZ290 byBjb3JydXB0ZWQ7Cj4+ICvCoMKgwqAgfQo+PiDCoCDCoMKgwqDCoMKgIC8qIHRhaWwgPT0gaGVh ZCBjb25kaXRpb24gaW5kaWNhdGVzIGVtcHR5ICovCj4+IMKgwqDCoMKgwqAgYXZhaWxhYmxlID0g dGFpbCAtIGhlYWQ7Cj4+IEBAIC02NTksNyArNjQ2LDcgQEAgc3RhdGljIGludCBjdF9yZWFkKHN0 cnVjdCBpbnRlbF9ndWNfY3QgKmN0LCBzdHJ1Y3QKPj4gY3RfaW5jb21pbmdfbXNnICoqbXNnKQo+ PiDCoMKgwqDCoMKgIGhlYWQgPSAoaGVhZCArIDEpICUgc2l6ZTsKPj4gwqAgwqDCoMKgwqDCoCAv KiBtZXNzYWdlIGxlbiB3aXRoIGhlYWRlciAqLwo+PiAtwqDCoMKgIGxlbiA9IGN0X2hlYWRlcl9n ZXRfbGVuKGhlYWRlcikgKyAxOwo+PiArwqDCoMKgIGxlbiA9IEZJRUxEX0dFVChHVUNfQ1RCX01T R18wX05VTV9EV09SRFMsIGhlYWRlcikgKwo+PiBHVUNfQ1RCX01TR19NSU5fTEVOOwo+PiDCoMKg wqDCoMKgIGlmICh1bmxpa2VseShsZW4gPiAodTMyKWF2YWlsYWJsZSkpIHsKPj4gwqDCoMKgwqDC oMKgwqDCoMKgIENUX0VSUk9SKGN0LCAiSW5jb21wbGV0ZSBtZXNzYWdlICUqcGggJSpwaCAlKnBo XG4iLAo+PiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIDQsICZoZWFkZXIsCj4+IEBAIC02 NjcsNiArNjU0LDcgQEAgc3RhdGljIGludCBjdF9yZWFkKHN0cnVjdCBpbnRlbF9ndWNfY3QgKmN0 LCBzdHJ1Y3QKPj4gY3RfaW5jb21pbmdfbXNnICoqbXNnKQo+PiDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoCBzaXplIC0gaGVhZCA6IGF2YWlsYWJsZSAtIDEpLCAmY21kc1to ZWFkXSwKPj4gwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCA0ICogKGhlYWQgKyBhdmFpbGFi bGUgLSAxID4gc2l6ZSA/Cj4+IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg IGF2YWlsYWJsZSAtIDEgLSBzaXplICsgaGVhZCA6IDApLCAmY21kc1swXSk7Cj4+ICvCoMKgwqDC oMKgwqDCoCBkZXNjLT5zdGF0dXMgfD0gR1VDX0NUQl9TVEFUVVNfVU5ERVJGTE9XOwo+PiDCoMKg wqDCoMKgwqDCoMKgwqAgZ290byBjb3JydXB0ZWQ7Cj4+IMKgwqDCoMKgwqAgfQo+PiDCoCBAQCAt Njg5LDY1ICs2NzcsMzYgQEAgc3RhdGljIGludCBjdF9yZWFkKHN0cnVjdCBpbnRlbF9ndWNfY3Qg KmN0LAo+PiBzdHJ1Y3QgY3RfaW5jb21pbmdfbXNnICoqbXNnKQo+PiDCoMKgwqDCoMKgIH0KPj4g wqDCoMKgwqDCoCBDVF9ERUJVRyhjdCwgInJlY2VpdmVkICUqcGhcbiIsIDQgKiBsZW4sICgqbXNn KS0+bXNnKTsKPj4gwqAgLcKgwqDCoCBkZXNjLT5oZWFkID0gaGVhZCAqIDQ7Cj4+ICvCoMKgwqAg Lyogbm93IHVwZGF0ZSBkZXNjcmlwdG9yICovCj4+ICvCoMKgwqAgV1JJVEVfT05DRShkZXNjLT5o ZWFkLCBoZWFkKTsKPj4gKwo+PiDCoMKgwqDCoMKgIHJldHVybiBhdmFpbGFibGUgLSBsZW47Cj4+ IMKgIMKgIGNvcnJ1cHRlZDoKPj4gLcKgwqDCoCBDVF9FUlJPUihjdCwgIkNvcnJ1cHRlZCBkZXNj cmlwdG9yIGFkZHI9JSN4IGhlYWQ9JXUgdGFpbD0ldQo+PiBzaXplPSV1XG4iLAo+PiAtwqDCoMKg wqDCoMKgwqDCoCBkZXNjLT5hZGRyLCBkZXNjLT5oZWFkLCBkZXNjLT50YWlsLCBkZXNjLT5zaXpl KTsKPj4gLcKgwqDCoCBkZXNjLT5pc19pbl9lcnJvciA9IDE7Cj4+ICvCoMKgwqAgQ1RfRVJST1Io Y3QsICJDb3JydXB0ZWQgZGVzY3JpcHRvciBoZWFkPSV1IHRhaWw9JXUgc3RhdHVzPSUjeFxuIiwK Pj4gK8KgwqDCoMKgwqDCoMKgwqAgZGVzYy0+aGVhZCwgZGVzYy0+dGFpbCwgZGVzYy0+c3RhdHVz KTsKPj4gK8KgwqDCoCBjdGItPmJyb2tlbiA9IHRydWU7Cj4+IMKgwqDCoMKgwqAgcmV0dXJuIC1F UElQRTsKPj4gwqAgfQo+PiDCoCAtLyoqCj4+IC0gKiBET0M6IENUQiBHdUMgdG8gSG9zdCByZXNw b25zZQo+PiAtICoKPj4gLSAqIEZvcm1hdCBvZiB0aGUgQ1RCIEd1QyB0byBIb3N0IHJlc3BvbnNl IG1lc3NhZ2UgaXMgYXMgZm9sbG93czo6Cj4+IC0gKgo+PiAtICrCoMKgwqDCoMKgICstLS0tLS0t LS0tLS0rLS0tLS0tLS0tKy0tLS0tLS0tLSstLS0tLS0tLS0rLS0tLS0tLS0tKy0tLS0tLS0tLSsK Pj4gLSAqwqDCoMKgwqDCoCB8wqDCoCBtc2dbMF3CoMKgIHzCoMKgIFsxXcKgwqAgfMKgwqAgWzJd wqDCoCB8wqDCoCBbM13CoMKgIHzCoMKgIC4uLsKgwqAgfMKgIFtuLTFdwqAgfAo+PiAtICrCoMKg wqDCoMKgICstLS0tLS0tLS0tLS0rLS0tLS0tLS0tKy0tLS0tLS0tLSstLS0tLS0tLS0rLS0tLS0t LS0tKy0tLS0tLS0tLSsKPj4gLSAqwqDCoMKgwqDCoCB8wqDCoCBNRVNTQUdFwqAgfMKgwqDCoMKg wqDCoCBNRVNTQUdFIFBBWUxPQUTCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgIHwKPj4gLSAqwqDCoMKgwqDCoCArwqDCoCBIRUFERVLCoMKgICstLS0t LS0tLS0rLS0tLS0tLS0tKy0tLS0tLS0tLSstLS0tLS0tLS0rLS0tLS0tLS0tKwo+PiAtICrCoMKg wqDCoMKgIHzCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHzCoMKgwqAgMMKgwqDCoCB8wqDCoMKgIDHC oMKgwqAgfMKgwqDCoCAywqDCoMKgIHzCoMKgIC4uLsKgwqAgfMKgwqDCoCBuwqDCoMKgIHwKPj4g LSAqwqDCoMKgwqDCoCArPT09PT09PT09PT09Kz09PT09PT09PSs9PT09PT09PT0rPT09PT09PT09 Kz09PT09PT09PSs9PT09PT09PT0rCj4+IC0gKsKgwqDCoMKgwqAgfMKgIGxlbiA+PSAywqAgfMKg IEZFTkNFwqAgfMKgIFNUQVRVUyB8wqDCoCByZXNwb25zZSBzcGVjaWZpYyBkYXRhwqDCoMKgIHwK Pj4gLSAqwqDCoMKgwqDCoCArLS0tLS0tKy0tLS0tKy0tLS0tLS0tLSstLS0tLS0tLS0rLS0tLS0t LS0tKy0tLS0tLS0tLSstLS0tLS0tLS0rCj4+IC0gKgo+PiAtICrCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqAgXi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tbGVuLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS1eCj4+IC0gKi8KPj4gLQo+PiDCoCBzdGF0aWMgaW50IGN0X2hhbmRsZV9yZXNw b25zZShzdHJ1Y3QgaW50ZWxfZ3VjX2N0ICpjdCwgc3RydWN0Cj4+IGN0X2luY29taW5nX21zZyAq cmVzcG9uc2UpCj4+IMKgIHsKPj4gLcKgwqDCoCB1MzIgaGVhZGVyID0gcmVzcG9uc2UtPm1zZ1sw XTsKPj4gLcKgwqDCoCB1MzIgbGVuID0gY3RfaGVhZGVyX2dldF9sZW4oaGVhZGVyKTsKPj4gLcKg wqDCoCB1MzIgZmVuY2U7Cj4+IC3CoMKgwqAgdTMyIHN0YXR1czsKPj4gLcKgwqDCoCB1MzIgZGF0 YWxlbjsKPj4gK8KgwqDCoCB1MzIgbGVuID0gRklFTERfR0VUKEdVQ19DVEJfTVNHXzBfTlVNX0RX T1JEUywgcmVzcG9uc2UtPm1zZ1swXSk7Cj4+ICvCoMKgwqAgdTMyIGZlbmNlID0gRklFTERfR0VU KEdVQ19DVEJfTVNHXzBfRkVOQ0UsIHJlc3BvbnNlLT5tc2dbMF0pOwo+PiArwqDCoMKgIGNvbnN0 IHUzMiAqaHhnID0gJnJlc3BvbnNlLT5tc2dbR1VDX0NUQl9NU0dfTUlOX0xFTl07Cj4+ICvCoMKg wqAgY29uc3QgdTMyICpkYXRhID0gJmh4Z1tHVUNfSFhHX01TR19NSU5fTEVOXTsKPj4gK8KgwqDC oCB1MzIgZGF0YWxlbiA9IGxlbiAtIEdVQ19IWEdfTVNHX01JTl9MRU47Cj4+IMKgwqDCoMKgwqAg c3RydWN0IGN0X3JlcXVlc3QgKnJlcTsKPj4gwqDCoMKgwqDCoCB1bnNpZ25lZCBsb25nIGZsYWdz Owo+PiDCoMKgwqDCoMKgIGJvb2wgZm91bmQgPSBmYWxzZTsKPj4gwqDCoMKgwqDCoCBpbnQgZXJy ID0gMDsKPj4gwqAgLcKgwqDCoCBHRU1fQlVHX09OKCFjdF9oZWFkZXJfaXNfcmVzcG9uc2UoaGVh ZGVyKSk7Cj4+IC0KPj4gLcKgwqDCoCAvKiBSZXNwb25zZSBwYXlsb2FkIHNoYWxsIGF0IGxlYXN0 IGluY2x1ZGUgZmVuY2UgYW5kIHN0YXR1cyAqLwo+PiAtwqDCoMKgIGlmICh1bmxpa2VseShsZW4g PCAyKSkgewo+PiAtwqDCoMKgwqDCoMKgwqAgQ1RfRVJST1IoY3QsICJDb3JydXB0ZWQgcmVzcG9u c2UgKGxlbiAldSlcbiIsIGxlbik7Cj4+IC3CoMKgwqDCoMKgwqDCoCByZXR1cm4gLUVQUk9UTzsK Pj4gLcKgwqDCoCB9Cj4+IC0KPj4gLcKgwqDCoCBmZW5jZSA9IHJlc3BvbnNlLT5tc2dbMV07Cj4+ IC3CoMKgwqAgc3RhdHVzID0gcmVzcG9uc2UtPm1zZ1syXTsKPj4gLcKgwqDCoCBkYXRhbGVuID0g bGVuIC0gMjsKPj4gLQo+PiAtwqDCoMKgIC8qIEZvcm1hdCBvZiB0aGUgc3RhdHVzIGZvbGxvd3Mg UkVTUE9OU0UgbWVzc2FnZSAqLwo+PiAtwqDCoMKgIGlmICh1bmxpa2VseSghSU5URUxfR1VDX01T R19JU19SRVNQT05TRShzdGF0dXMpKSkgewo+PiAtwqDCoMKgwqDCoMKgwqAgQ1RfRVJST1IoY3Qs ICJDb3JydXB0ZWQgcmVzcG9uc2UgKHN0YXR1cyAlI3gpXG4iLCBzdGF0dXMpOwo+PiAtwqDCoMKg wqDCoMKgwqAgcmV0dXJuIC1FUFJPVE87Cj4+IC3CoMKgwqAgfQo+PiArwqDCoMKgIEdFTV9CVUdf T04obGVuIDwgR1VDX0hYR19NU0dfTUlOX0xFTik7Cj4+ICvCoMKgwqAgR0VNX0JVR19PTihGSUVM RF9HRVQoR1VDX0hYR19NU0dfMF9PUklHSU4sIGh4Z1swXSkgIT0KPj4gR1VDX0hYR19PUklHSU5f R1VDKTsKPj4gK8KgwqDCoCBHRU1fQlVHX09OKEZJRUxEX0dFVChHVUNfSFhHX01TR18wX1RZUEUs IGh4Z1swXSkgIT0KPj4gR1VDX0hYR19UWVBFX1JFU1BPTlNFX1NVQ0NFU1MgJiYKPj4gK8KgwqDC oMKgwqDCoMKgwqDCoMKgIEZJRUxEX0dFVChHVUNfSFhHX01TR18wX1RZUEUsIGh4Z1swXSkgIT0K Pj4gR1VDX0hYR19UWVBFX1JFU1BPTlNFX0ZBSUxVUkUpOwo+PiDCoCAtwqDCoMKgIENUX0RFQlVH KGN0LCAicmVzcG9uc2UgZmVuY2UgJXUgc3RhdHVzICUjeFxuIiwgZmVuY2UsIHN0YXR1cyk7Cj4+ ICvCoMKgwqAgQ1RfREVCVUcoY3QsICJyZXNwb25zZSBmZW5jZSAldSBzdGF0dXMgJSN4XG4iLCBm ZW5jZSwgaHhnWzBdKTsKPj4gwqAgwqDCoMKgwqDCoCBzcGluX2xvY2tfaXJxc2F2ZSgmY3QtPnJl cXVlc3RzLmxvY2ssIGZsYWdzKTsKPj4gwqDCoMKgwqDCoCBsaXN0X2Zvcl9lYWNoX2VudHJ5KHJl cSwgJmN0LT5yZXF1ZXN0cy5wZW5kaW5nLCBsaW5rKSB7Cj4+IEBAIC03NjMsOSArNzIyLDkgQEAg c3RhdGljIGludCBjdF9oYW5kbGVfcmVzcG9uc2Uoc3RydWN0IGludGVsX2d1Y19jdAo+PiAqY3Qs IHN0cnVjdCBjdF9pbmNvbWluZ19tc2cgKnIKPj4gwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAg ZXJyID0gLUVNU0dTSVpFOwo+PiDCoMKgwqDCoMKgwqDCoMKgwqAgfQo+PiDCoMKgwqDCoMKgwqDC oMKgwqAgaWYgKGRhdGFsZW4pCj4+IC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKgIG1lbWNweShyZXEt PnJlc3BvbnNlX2J1ZiwgcmVzcG9uc2UtPm1zZyArIDMsIDQgKiBkYXRhbGVuKTsKPj4gK8KgwqDC oMKgwqDCoMKgwqDCoMKgwqAgbWVtY3B5KHJlcS0+cmVzcG9uc2VfYnVmLCBkYXRhLCA0ICogZGF0 YWxlbik7Cj4+IMKgwqDCoMKgwqDCoMKgwqDCoCByZXEtPnJlc3BvbnNlX2xlbiA9IGRhdGFsZW47 Cj4+IC3CoMKgwqDCoMKgwqDCoCBXUklURV9PTkNFKHJlcS0+c3RhdHVzLCBzdGF0dXMpOwo+PiAr wqDCoMKgwqDCoMKgwqAgV1JJVEVfT05DRShyZXEtPnN0YXR1cywgaHhnWzBdKTsKPj4gwqDCoMKg wqDCoMKgwqDCoMKgIGZvdW5kID0gdHJ1ZTsKPj4gwqDCoMKgwqDCoMKgwqDCoMKgIGJyZWFrOwo+ PiDCoMKgwqDCoMKgIH0KPj4gQEAgLTc4NiwxNCArNzQ1LDE2IEBAIHN0YXRpYyBpbnQgY3RfaGFu ZGxlX3Jlc3BvbnNlKHN0cnVjdAo+PiBpbnRlbF9ndWNfY3QgKmN0LCBzdHJ1Y3QgY3RfaW5jb21p bmdfbXNnICpyCj4+IMKgIHN0YXRpYyBpbnQgY3RfcHJvY2Vzc19yZXF1ZXN0KHN0cnVjdCBpbnRl bF9ndWNfY3QgKmN0LCBzdHJ1Y3QKPj4gY3RfaW5jb21pbmdfbXNnICpyZXF1ZXN0KQo+PiDCoCB7 Cj4+IMKgwqDCoMKgwqAgc3RydWN0IGludGVsX2d1YyAqZ3VjID0gY3RfdG9fZ3VjKGN0KTsKPj4g LcKgwqDCoCB1MzIgaGVhZGVyLCBhY3Rpb24sIGxlbjsKPj4gK8KgwqDCoCBjb25zdCB1MzIgKmh4 ZzsKPj4gwqDCoMKgwqDCoCBjb25zdCB1MzIgKnBheWxvYWQ7Cj4+ICvCoMKgwqAgdTMyIGh4Z19s ZW4sIGFjdGlvbiwgbGVuOwo+PiDCoMKgwqDCoMKgIGludCByZXQ7Cj4+IMKgIC3CoMKgwqAgaGVh ZGVyID0gcmVxdWVzdC0+bXNnWzBdOwo+PiAtwqDCoMKgIHBheWxvYWQgPSAmcmVxdWVzdC0+bXNn WzFdOwo+PiAtwqDCoMKgIGFjdGlvbiA9IGN0X2hlYWRlcl9nZXRfYWN0aW9uKGhlYWRlcik7Cj4+ IC3CoMKgwqAgbGVuID0gY3RfaGVhZGVyX2dldF9sZW4oaGVhZGVyKTsKPj4gK8KgwqDCoCBoeGcg PSAmcmVxdWVzdC0+bXNnW0dVQ19DVEJfTVNHX01JTl9MRU5dOwo+PiArwqDCoMKgIGh4Z19sZW4g PSByZXF1ZXN0LT5zaXplIC0gR1VDX0NUQl9NU0dfTUlOX0xFTjsKPj4gK8KgwqDCoCBwYXlsb2Fk ID0gJmh4Z1tHVUNfSFhHX01TR19NSU5fTEVOXTsKPj4gK8KgwqDCoCBhY3Rpb24gPSBGSUVMRF9H RVQoR1VDX0hYR19FVkVOVF9NU0dfMF9BQ1RJT04sIGh4Z1swXSk7Cj4+ICvCoMKgwqAgbGVuID0g aHhnX2xlbiAtIEdVQ19IWEdfTVNHX01JTl9MRU47Cj4+IMKgIMKgwqDCoMKgwqAgQ1RfREVCVUco Y3QsICJyZXF1ZXN0ICV4ICUqcGhcbiIsIGFjdGlvbiwgNCAqIGxlbiwgcGF5bG9hZCk7Cj4+IMKg IEBAIC04NTUsMjkgKzgxNiwxMiBAQCBzdGF0aWMgdm9pZAo+PiBjdF9pbmNvbWluZ19yZXF1ZXN0 X3dvcmtlcl9mdW5jKHN0cnVjdCB3b3JrX3N0cnVjdCAqdykKPj4gwqDCoMKgwqDCoMKgwqDCoMKg IHF1ZXVlX3dvcmsoc3lzdGVtX3VuYm91bmRfd3EsICZjdC0+cmVxdWVzdHMud29ya2VyKTsKPj4g wqAgfQo+PiDCoCAtLyoqCj4+IC0gKiBET0M6IENUQiBHdUMgdG8gSG9zdCByZXF1ZXN0Cj4+IC0g Kgo+PiAtICogRm9ybWF0IG9mIHRoZSBDVEIgR3VDIHRvIEhvc3QgcmVxdWVzdCBtZXNzYWdlIGlz IGFzIGZvbGxvd3M6Ogo+PiAtICoKPj4gLSAqwqDCoMKgwqDCoCArLS0tLS0tLS0tLS0tKy0tLS0t LS0tLSstLS0tLS0tLS0rLS0tLS0tLS0tKy0tLS0tLS0tLSstLS0tLS0tLS0rCj4+IC0gKsKgwqDC oMKgwqAgfMKgwqAgbXNnWzBdwqDCoCB8wqDCoCBbMV3CoMKgIHzCoMKgIFsyXcKgwqAgfMKgwqAg WzNdwqDCoCB8wqDCoCAuLi7CoMKgIHzCoCBbbi0xXcKgIHwKPj4gLSAqwqDCoMKgwqDCoCArLS0t LS0tLS0tLS0tKy0tLS0tLS0tLSstLS0tLS0tLS0rLS0tLS0tLS0tKy0tLS0tLS0tLSstLS0tLS0t LS0rCj4+IC0gKsKgwqDCoMKgwqAgfMKgwqAgTUVTU0FHRcKgIHzCoMKgwqDCoMKgwqAgTUVTU0FH RSBQQVlMT0FEwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoCB8Cj4+IC0gKsKgwqDCoMKgwqAgK8KgwqAgSEVBREVSwqDCoCArLS0tLS0tLS0tKy0tLS0t LS0tLSstLS0tLS0tLS0rLS0tLS0tLS0tKy0tLS0tLS0tLSsKPj4gLSAqwqDCoMKgwqDCoCB8wqDC oMKgwqDCoMKgwqDCoMKgwqDCoCB8wqDCoMKgIDDCoMKgwqAgfMKgwqDCoCAxwqDCoMKgIHzCoMKg wqAgMsKgwqDCoCB8wqDCoCAuLi7CoMKgIHzCoMKgwqAgbsKgwqDCoCB8Cj4+IC0gKsKgwqDCoMKg wqAgKz09PT09PT09PT09PSs9PT09PT09PT0rPT09PT09PT09Kz09PT09PT09PSs9PT09PT09PT0r PT09PT09PT09Kwo+PiAtICrCoMKgwqDCoMKgIHzCoMKgwqDCoCBsZW7CoMKgwqAgfMKgwqDCoMKg wqDCoMKgwqDCoMKgwqAgcmVxdWVzdCBzcGVjaWZpYyBkYXRhwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgIHwKPj4gLSAqwqDCoMKgwqDCoCArLS0tLS0tKy0tLS0tKy0tLS0tLS0tLSstLS0t LS0tLS0rLS0tLS0tLS0tKy0tLS0tLS0tLSstLS0tLS0tLS0rCj4+IC0gKgo+PiAtICrCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgXi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tbGVu LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS1eCj4+IC0gKi8KPj4gLQo+PiAtc3RhdGljIGludCBjdF9o YW5kbGVfcmVxdWVzdChzdHJ1Y3QgaW50ZWxfZ3VjX2N0ICpjdCwgc3RydWN0Cj4+IGN0X2luY29t aW5nX21zZyAqcmVxdWVzdCkKPj4gK3N0YXRpYyBpbnQgY3RfaGFuZGxlX2V2ZW50KHN0cnVjdCBp bnRlbF9ndWNfY3QgKmN0LCBzdHJ1Y3QKPj4gY3RfaW5jb21pbmdfbXNnICpyZXF1ZXN0KQo+PiDC oCB7Cj4+ICvCoMKgwqAgY29uc3QgdTMyICpoeGcgPSAmcmVxdWVzdC0+bXNnW0dVQ19DVEJfTVNH X01JTl9MRU5dOwo+PiDCoMKgwqDCoMKgIHVuc2lnbmVkIGxvbmcgZmxhZ3M7Cj4+IMKgIC3CoMKg wqAgR0VNX0JVR19PTihjdF9oZWFkZXJfaXNfcmVzcG9uc2UocmVxdWVzdC0+bXNnWzBdKSk7Cj4+ ICvCoMKgwqAgR0VNX0JVR19PTihGSUVMRF9HRVQoR1VDX0hYR19NU0dfMF9UWVBFLCBoeGdbMF0p ICE9Cj4+IEdVQ19IWEdfVFlQRV9FVkVOVCk7Cj4+IMKgIMKgwqDCoMKgwqAgc3Bpbl9sb2NrX2ly cXNhdmUoJmN0LT5yZXF1ZXN0cy5sb2NrLCBmbGFncyk7Cj4+IMKgwqDCoMKgwqAgbGlzdF9hZGRf dGFpbCgmcmVxdWVzdC0+bGluaywgJmN0LT5yZXF1ZXN0cy5pbmNvbWluZyk7Cj4+IEBAIC04ODcs MTUgKzgzMSw1MyBAQCBzdGF0aWMgaW50IGN0X2hhbmRsZV9yZXF1ZXN0KHN0cnVjdCBpbnRlbF9n dWNfY3QKPj4gKmN0LCBzdHJ1Y3QgY3RfaW5jb21pbmdfbXNnICpyZQo+PiDCoMKgwqDCoMKgIHJl dHVybiAwOwo+PiDCoCB9Cj4+IMKgIC1zdGF0aWMgdm9pZCBjdF9oYW5kbGVfbXNnKHN0cnVjdCBp bnRlbF9ndWNfY3QgKmN0LCBzdHJ1Y3QKPj4gY3RfaW5jb21pbmdfbXNnICptc2cpCj4+ICtzdGF0 aWMgaW50IGN0X2hhbmRsZV9oeGcoc3RydWN0IGludGVsX2d1Y19jdCAqY3QsIHN0cnVjdAo+PiBj dF9pbmNvbWluZ19tc2cgKm1zZykKPj4gwqAgewo+PiAtwqDCoMKgIHUzMiBoZWFkZXIgPSBtc2ct Pm1zZ1swXTsKPj4gK8KgwqDCoCB1MzIgb3JpZ2luLCB0eXBlOwo+PiArwqDCoMKgIHUzMiAqaHhn Owo+PiDCoMKgwqDCoMKgIGludCBlcnI7Cj4+IMKgIC3CoMKgwqAgaWYgKGN0X2hlYWRlcl9pc19y ZXNwb25zZShoZWFkZXIpKQo+PiArwqDCoMKgIGlmICh1bmxpa2VseShtc2ctPnNpemUgPCBHVUNf Q1RCX0hYR19NU0dfTUlOX0xFTikpCj4+ICvCoMKgwqDCoMKgwqDCoCByZXR1cm4gLUVCQURNU0c7 Cj4+ICsKPj4gK8KgwqDCoCBoeGcgPSAmbXNnLT5tc2dbR1VDX0NUQl9NU0dfTUlOX0xFTl07Cj4+ ICsKPj4gK8KgwqDCoCBvcmlnaW4gPSBGSUVMRF9HRVQoR1VDX0hYR19NU0dfMF9PUklHSU4sIGh4 Z1swXSk7Cj4+ICvCoMKgwqAgaWYgKHVubGlrZWx5KG9yaWdpbiAhPSBHVUNfSFhHX09SSUdJTl9H VUMpKSB7Cj4+ICvCoMKgwqDCoMKgwqDCoCBlcnIgPSAtRVBST1RPOwo+PiArwqDCoMKgwqDCoMKg wqAgZ290byBmYWlsZWQ7Cj4+ICvCoMKgwqAgfQo+PiArCj4+ICvCoMKgwqAgdHlwZSA9IEZJRUxE X0dFVChHVUNfSFhHX01TR18wX1RZUEUsIGh4Z1swXSk7Cj4+ICvCoMKgwqAgc3dpdGNoICh0eXBl KSB7Cj4+ICvCoMKgwqAgY2FzZSBHVUNfSFhHX1RZUEVfRVZFTlQ6Cj4+ICvCoMKgwqDCoMKgwqDC oCBlcnIgPSBjdF9oYW5kbGVfZXZlbnQoY3QsIG1zZyk7Cj4+ICvCoMKgwqDCoMKgwqDCoCBicmVh azsKPj4gK8KgwqDCoCBjYXNlIEdVQ19IWEdfVFlQRV9SRVNQT05TRV9TVUNDRVNTOgo+PiArwqDC oMKgIGNhc2UgR1VDX0hYR19UWVBFX1JFU1BPTlNFX0ZBSUxVUkU6Cj4+IMKgwqDCoMKgwqDCoMKg wqDCoCBlcnIgPSBjdF9oYW5kbGVfcmVzcG9uc2UoY3QsIG1zZyk7Cj4+ICvCoMKgwqDCoMKgwqDC oCBicmVhazsKPj4gK8KgwqDCoCBkZWZhdWx0Ogo+PiArwqDCoMKgwqDCoMKgwqAgZXJyID0gLUVP UE5PVFNVUFA7Cj4+ICvCoMKgwqAgfQo+PiArCj4+ICvCoMKgwqAgaWYgKHVubGlrZWx5KGVycikp IHsKPj4gK2ZhaWxlZDoKPj4gK8KgwqDCoMKgwqDCoMKgIENUX0VSUk9SKGN0LCAiRmFpbGVkIHRv IGhhbmRsZSBIWEcgbWVzc2FnZSAoJXBlKSAlKnBoXG4iLAo+PiArwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgIEVSUl9QVFIoZXJyKSwgNCAqIEdVQ19IWEdfTVNHX01JTl9MRU4sIGh4Zyk7Cj4+ICvC oMKgwqAgfQo+PiArwqDCoMKgIHJldHVybiBlcnI7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyB2b2lk IGN0X2hhbmRsZV9tc2coc3RydWN0IGludGVsX2d1Y19jdCAqY3QsIHN0cnVjdAo+PiBjdF9pbmNv bWluZ19tc2cgKm1zZykKPj4gK3sKPj4gK8KgwqDCoCB1MzIgZm9ybWF0ID0gRklFTERfR0VUKEdV Q19DVEJfTVNHXzBfRk9STUFULCBtc2ctPm1zZ1swXSk7Cj4+ICvCoMKgwqAgaW50IGVycjsKPj4g Kwo+PiArwqDCoMKgIGlmIChmb3JtYXQgPT0gR1VDX0NUQl9GT1JNQVRfSFhHKQo+PiArwqDCoMKg wqDCoMKgwqAgZXJyID0gY3RfaGFuZGxlX2h4ZyhjdCwgbXNnKTsKPj4gwqDCoMKgwqDCoCBlbHNl Cj4+IC3CoMKgwqDCoMKgwqDCoCBlcnIgPSBjdF9oYW5kbGVfcmVxdWVzdChjdCwgbXNnKTsKPj4g K8KgwqDCoMKgwqDCoMKgIGVyciA9IC1FT1BOT1RTVVBQOwo+PiDCoCDCoMKgwqDCoMKgIGlmICh1 bmxpa2VseShlcnIpKSB7Cj4+IMKgwqDCoMKgwqDCoMKgwqDCoCBDVF9FUlJPUihjdCwgIkZhaWxl ZCB0byBwcm9jZXNzIENUIG1lc3NhZ2UgKCVwZSkgJSpwaFxuIiwKPj4gZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Y19jdC5oCj4+IGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX2N0LmgKPj4gaW5kZXggY2IyMjJmMjAyMzAxLi4xYWUy ZGRlNmRiOTMgMTAwNjQ0Cj4+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVs X2d1Y19jdC5oCj4+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Y19j dC5oCj4+IEBAIC0zMSwxMyArMzEsMTUgQEAgc3RydWN0IGludGVsX2d1YzsKPj4gwqDCoCAqIEBs b2NrOiBwcm90ZWN0cyBhY2Nlc3MgdG8gdGhlIGNvbW1hbmRzIGJ1ZmZlciBhbmQgYnVmZmVyIGRl c2NyaXB0b3IKPj4gwqDCoCAqIEBkZXNjOiBwb2ludGVyIHRvIHRoZSBidWZmZXIgZGVzY3JpcHRv cgo+PiDCoMKgICogQGNtZHM6IHBvaW50ZXIgdG8gdGhlIGNvbW1hbmRzIGJ1ZmZlcgo+PiAtICog QHNpemU6IHNpemUgb2YgdGhlIGNvbW1hbmRzIGJ1ZmZlcgo+PiArICogQHNpemU6IHNpemUgb2Yg dGhlIGNvbW1hbmRzIGJ1ZmZlciBpbiBkd29yZHMKPj4gKyAqIEBicm9rZW46IGZsYWcgdG8gaW5k aWNhdGUgaWYgZGVzY3JpcHRvciBkYXRhIGlzIGJyb2tlbgo+PiDCoMKgICovCj4+IMKgIHN0cnVj dCBpbnRlbF9ndWNfY3RfYnVmZmVyIHsKPj4gwqDCoMKgwqDCoCBzcGlubG9ja190IGxvY2s7Cj4+ IMKgwqDCoMKgwqAgc3RydWN0IGd1Y19jdF9idWZmZXJfZGVzYyAqZGVzYzsKPj4gwqDCoMKgwqDC oCB1MzIgKmNtZHM7Cj4+IMKgwqDCoMKgwqAgdTMyIHNpemU7Cj4+ICvCoMKgwqAgYm9vbCBicm9r ZW47Cj4+IMKgIH07Cj4+IMKgIMKgIEBAIC01OSw3ICs2MSw3IEBAIHN0cnVjdCBpbnRlbF9ndWNf Y3Qgewo+PiDCoMKgwqDCoMKgIHN0cnVjdCB0YXNrbGV0X3N0cnVjdCByZWNlaXZlX3Rhc2tsZXQ7 Cj4+IMKgIMKgwqDCoMKgwqAgc3RydWN0IHsKPj4gLcKgwqDCoMKgwqDCoMKgIHUzMiBsYXN0X2Zl bmNlOyAvKiBsYXN0IGZlbmNlIHVzZWQgdG8gc2VuZCByZXF1ZXN0ICovCj4+ICvCoMKgwqDCoMKg wqDCoCB1MTYgbGFzdF9mZW5jZTsgLyogbGFzdCBmZW5jZSB1c2VkIHRvIHNlbmQgcmVxdWVzdCAq Lwo+PiDCoCDCoMKgwqDCoMKgwqDCoMKgwqAgc3BpbmxvY2tfdCBsb2NrOyAvKiBwcm90ZWN0cyBw ZW5kaW5nIHJlcXVlc3RzIGxpc3QgKi8KPj4gwqDCoMKgwqDCoMKgwqDCoMKgIHN0cnVjdCBsaXN0 X2hlYWQgcGVuZGluZzsgLyogcmVxdWVzdHMgd2FpdGluZyBmb3IgcmVzcG9uc2UgKi8KPj4gZGlm ZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Y19md2lmLmgKPj4g Yi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRlbF9ndWNfZndpZi5oCj4+IGluZGV4IGU5 YTlkODVlMmFhMy4uNjE3ZWM2MDE2NDhkIDEwMDY0NAo+PiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0v aTkxNS9ndC91Yy9pbnRlbF9ndWNfZndpZi5oCj4+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2d0L3VjL2ludGVsX2d1Y19md2lmLmgKPj4gQEAgLTgxLDEwICs4MSw4IEBACj4+IMKgICNkZWZp bmXCoMKgIEdVQ19MT0dfQUxMT0NfSU5fTUVHQUJZVEXCoMKgwqAgKDEgPDwgMykKPj4gwqAgI2Rl ZmluZcKgwqAgR1VDX0xPR19DUkFTSF9TSElGVMKgwqDCoMKgwqDCoMKgIDQKPj4gwqAgI2RlZmlu ZcKgwqAgR1VDX0xPR19DUkFTSF9NQVNLwqDCoMKgwqDCoMKgwqAgKDB4MyA8PCBHVUNfTE9HX0NS QVNIX1NISUZUKQo+PiAtI2RlZmluZcKgwqAgR1VDX0xPR19EUENfU0hJRlTCoMKgwqDCoMKgwqDC oCA2Cj4+IC0jZGVmaW5lwqDCoCBHVUNfTE9HX0RQQ19NQVNLwqDCoMKgwqDCoMKgwqDCoMKgwqDC oCAoMHg3IDw8IEdVQ19MT0dfRFBDX1NISUZUKQo+PiAtI2RlZmluZcKgwqAgR1VDX0xPR19JU1Jf U0hJRlTCoMKgwqDCoMKgwqDCoCA5Cj4+IC0jZGVmaW5lwqDCoCBHVUNfTE9HX0lTUl9NQVNLwqDC oMKgwqDCoMKgwqDCoMKgwqDCoCAoMHg3IDw8IEdVQ19MT0dfSVNSX1NISUZUKQo+PiArI2RlZmlu ZcKgwqAgR1VDX0xPR19ERUJVR19TSElGVMKgwqDCoMKgwqDCoMKgIDYKPj4gKyNkZWZpbmXCoMKg IEdVQ19MT0dfREVCVUdfTUFTS8KgwqDCoMKgwqDCoMKgwqDCoMKgwqAgKDB4RiA8PCBHVUNfTE9H X0RFQlVHX1NISUZUKQo+PiDCoCAjZGVmaW5lwqDCoCBHVUNfTE9HX0JVRl9BRERSX1NISUZUwqDC oMKgIDEyCj4+IMKgIMKgICNkZWZpbmUgR1VDX0NUTF9XQcKgwqDCoMKgwqDCoMKgwqDCoMKgwqAg MQo+PiBAQCAtMjQ3LDMyICsyNDUsMTQgQEAgc3RydWN0IGd1Y19zdGFnZV9kZXNjIHsKPj4gwqAg wqAgLyogU2NoZWR1bGluZyBwb2xpY3kgc2V0dGluZ3MgKi8KPj4gwqAgLS8qIFJlc2V0IGVuZ2lu ZSB1cG9uIHByZWVtcHQgZmFpbHVyZSAqLwo+PiAtI2RlZmluZSBQT0xJQ1lfUkVTRVRfRU5HSU5F wqDCoMKgwqDCoMKgwqAgKDE8PDApCj4+IC0vKiBQcmVlbXB0IHRvIGlkbGUgb24gcXVhbnR1bSBl eHBpcnkgKi8KPj4gLSNkZWZpbmUgUE9MSUNZX1BSRUVNUFRfVE9fSURMRcKgwqDCoMKgwqDCoMKg ICgxPDwxKQo+PiAtCj4+IC0jZGVmaW5lIFBPTElDWV9NQVhfTlVNX1dJIDE1Cj4+IC0jZGVmaW5l IFBPTElDWV9ERUZBVUxUX0RQQ19QUk9NT1RFX1RJTUVfVVMgNTAwMDAwCj4+IC0jZGVmaW5lIFBP TElDWV9ERUZBVUxUX0VYRUNVVElPTl9RVUFOVFVNX1VTIDEwMDAwMDAKPj4gLSNkZWZpbmUgUE9M SUNZX0RFRkFVTFRfUFJFRU1QVElPTl9USU1FX1VTIDUwMDAwMAo+PiAtI2RlZmluZSBQT0xJQ1lf REVGQVVMVF9GQVVMVF9USU1FX1VTIDI1MDAwMAo+PiAtCj4+IC1zdHJ1Y3QgZ3VjX3BvbGljeSB7 Cj4+IC3CoMKgwqAgLyogVGltZSBmb3Igb25lIHdvcmtsb2FkIHRvIGV4ZWN1dGUuIChpbiBtaWNy byBzZWNvbmRzKSAqLwo+PiAtwqDCoMKgIHUzMiBleGVjdXRpb25fcXVhbnR1bTsKPj4gLcKgwqDC oCAvKiBUaW1lIHRvIHdhaXQgZm9yIGEgcHJlZW1wdGlvbiByZXF1ZXN0IHRvIGNvbXBsZXRlZCBi ZWZvcmUKPj4gaXNzdWluZyBhCj4+IC3CoMKgwqDCoCAqIHJlc2V0LiAoaW4gbWljcm8gc2Vjb25k cykuICovCj4+IC3CoMKgwqAgdTMyIHByZWVtcHRpb25fdGltZTsKPj4gLcKgwqDCoCAvKiBIb3cg bXVjaCB0aW1lIHRvIGFsbG93IHRvIHJ1biBhZnRlciB0aGUgZmlyc3QgZmF1bHQgaXMgb2JzZXJ2 ZWQuCj4+IC3CoMKgwqDCoCAqIFRoZW4gcHJlZW1wdCBhZnRlcndhcmRzLiAoaW4gbWljcm8gc2Vj b25kcykgKi8KPj4gLcKgwqDCoCB1MzIgZmF1bHRfdGltZTsKPj4gLcKgwqDCoCB1MzIgcG9saWN5 X2ZsYWdzOwo+PiAtwqDCoMKgIHUzMiByZXNlcnZlZFs4XTsKPj4gLX0gX19wYWNrZWQ7Cj4+ICsj ZGVmaW5lIEdMT0JBTF9QT0xJQ1lfTUFYX05VTV9XSSAxNQo+PiArCj4+ICsvKiBEb24ndCByZXNl dCBhbiBlbmdpbmUgdXBvbiBwcmVlbXB0aW9uIGZhaWx1cmUgKi8KPj4gKyNkZWZpbmUgR0xPQkFM X1BPTElDWV9ESVNBQkxFX0VOR0lORV9SRVNFVMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oCBCSVQoMCkKPj4gKwo+PiArI2RlZmluZSBHTE9CQUxfUE9MSUNZX0RFRkFVTFRfRFBDX1BST01P VEVfVElNRV9VUyA1MDAwMDAKPj4gwqAgwqAgc3RydWN0IGd1Y19wb2xpY2llcyB7Cj4+IC3CoMKg wqAgc3RydWN0IGd1Y19wb2xpY3kKPj4gcG9saWN5W0dVQ19DTElFTlRfUFJJT1JJVFlfTlVNXVtH VUNfTUFYX0VOR0lORV9DTEFTU0VTXTsKPj4gwqDCoMKgwqDCoCB1MzIgc3VibWlzc2lvbl9xdWV1 ZV9kZXB0aFtHVUNfTUFYX0VOR0lORV9DTEFTU0VTXTsKPj4gwqDCoMKgwqDCoCAvKiBJbiBtaWNy byBzZWNvbmRzLiBIb3cgbXVjaCB0aW1lIHRvIGFsbG93IGJlZm9yZSBEUEMKPj4gcHJvY2Vzc2lu ZyBpcwo+PiDCoMKgwqDCoMKgwqAgKiBjYWxsZWQgYmFjayB2aWEgaW50ZXJydXB0ICh0byBwcmV2 ZW50IERQQyBxdWV1ZSBkcmFpbiBzdGFydmluZykuCj4+IEBAIC0yODYsNiArMjY2LDcgQEAgc3Ry dWN0IGd1Y19wb2xpY2llcyB7Cj4+IMKgwqDCoMKgwqDCoCAqIGlkbGUuICovCj4+IMKgwqDCoMKg wqAgdTMyIG1heF9udW1fd29ya19pdGVtczsKPj4gwqAgK8KgwqDCoCB1MzIgZ2xvYmFsX2ZsYWdz Owo+PiDCoMKgwqDCoMKgIHUzMiByZXNlcnZlZFs0XTsKPj4gwqAgfSBfX3BhY2tlZDsKPj4gwqAg QEAgLTMxMSwyOSArMjkyLDEzIEBAIHN0cnVjdCBndWNfZ3Rfc3lzdGVtX2luZm8gewo+PiDCoMKg wqDCoMKgIHUzMiBnZW5lcmljX2d0X3N5c2luZm9bR1VDX0dFTkVSSUNfR1RfU1lTSU5GT19NQVhd Owo+PiDCoCB9IF9fcGFja2VkOwo+PiDCoCAtLyogQ2xpZW50cyBpbmZvICovCj4+IC1zdHJ1Y3Qg Z3VjX2N0X3Bvb2xfZW50cnkgewo+PiAtwqDCoMKgIHN0cnVjdCBndWNfY3RfYnVmZmVyX2Rlc2Mg ZGVzYzsKPj4gLcKgwqDCoCB1MzIgcmVzZXJ2ZWRbN107Cj4+IC19IF9fcGFja2VkOwo+PiAtCj4+ IC0jZGVmaW5lIEdVQ19DVF9QT09MX1NJWkXCoMKgwqAgMgo+PiAtCj4+IC1zdHJ1Y3QgZ3VjX2Ns aWVudHNfaW5mbyB7Cj4+IC3CoMKgwqAgdTMyIGNsaWVudHNfbnVtOwo+PiAtwqDCoMKgIHUzMiBy ZXNlcnZlZDBbMTNdOwo+PiAtwqDCoMKgIHUzMiBjdF9wb29sX2FkZHI7Cj4+IC3CoMKgwqAgdTMy IGN0X3Bvb2xfY291bnQ7Cj4+IC3CoMKgwqAgdTMyIHJlc2VydmVkWzRdOwo+PiAtfSBfX3BhY2tl ZDsKPj4gLQo+PiDCoCAvKiBHdUMgQWRkaXRpb25hbCBEYXRhIFN0cnVjdCAqLwo+PiDCoCBzdHJ1 Y3QgZ3VjX2FkcyB7Cj4+IMKgwqDCoMKgwqAgc3RydWN0IGd1Y19tbWlvX3JlZ19zZXQKPj4gcmVn X3N0YXRlX2xpc3RbR1VDX01BWF9FTkdJTkVfQ0xBU1NFU11bR1VDX01BWF9JTlNUQU5DRVNfUEVS X0NMQVNTXTsKPj4gwqDCoMKgwqDCoCB1MzIgcmVzZXJ2ZWQwOwo+PiDCoMKgwqDCoMKgIHUzMiBz Y2hlZHVsZXJfcG9saWNpZXM7Cj4+IMKgwqDCoMKgwqAgdTMyIGd0X3N5c3RlbV9pbmZvOwo+PiAt wqDCoMKgIHUzMiBjbGllbnRzX2luZm87Cj4+ICvCoMKgwqAgdTMyIHJlc2VydmVkMTsKPj4gwqDC oMKgwqDCoCB1MzIgY29udHJvbF9kYXRhOwo+PiDCoMKgwqDCoMKgIHUzMiBnb2xkZW5fY29udGV4 dF9scmNhW0dVQ19NQVhfRU5HSU5FX0NMQVNTRVNdOwo+PiDCoMKgwqDCoMKgIHUzMiBlbmdfc3Rh dGVfc2l6ZVtHVUNfTUFYX0VOR0lORV9DTEFTU0VTXTsKPj4gQEAgLTM0NCw4ICszMDksNyBAQCBz dHJ1Y3QgZ3VjX2FkcyB7Cj4+IMKgIC8qIEd1QyBsb2dnaW5nIHN0cnVjdHVyZXMgKi8KPj4gwqAg wqAgZW51bSBndWNfbG9nX2J1ZmZlcl90eXBlIHsKPj4gLcKgwqDCoCBHVUNfSVNSX0xPR19CVUZG RVIsCj4+IC3CoMKgwqAgR1VDX0RQQ19MT0dfQlVGRkVSLAo+PiArwqDCoMKgIEdVQ19ERUJVR19M T0dfQlVGRkVSLAo+PiDCoMKgwqDCoMKgIEdVQ19DUkFTSF9EVU1QX0xPR19CVUZGRVIsCj4+IMKg wqDCoMKgwqAgR1VDX01BWF9MT0dfQlVGRkVSCj4+IMKgIH07Cj4+IEBAIC00MTQsMjMgKzM3OCw2 IEBAIHN0cnVjdCBndWNfc2hhcmVkX2N0eF9kYXRhIHsKPj4gwqDCoMKgwqDCoCBzdHJ1Y3QgZ3Vj X2N0eF9yZXBvcnQgcHJlZW1wdF9jdHhfcmVwb3J0W0dVQ19NQVhfRU5HSU5FU19OVU1dOwo+PiDC oCB9IF9fcGFja2VkOwo+PiDCoCAtI2RlZmluZSBfX0lOVEVMX0dVQ19NU0dfR0VUKFQsIG0pIFwK Pj4gLcKgwqDCoCAoKChtKSAmIElOVEVMX0dVQ19NU0dfICMjIFQgIyMgX01BU0spID4+IElOVEVM X0dVQ19NU0dfICMjIFQgIyMKPj4gX1NISUZUKQo+PiAtI2RlZmluZSBJTlRFTF9HVUNfTVNHX1RP X1RZUEUobSnCoMKgwqAgX19JTlRFTF9HVUNfTVNHX0dFVChUWVBFLCBtKQo+PiAtI2RlZmluZSBJ TlRFTF9HVUNfTVNHX1RPX0RBVEEobSnCoMKgwqAgX19JTlRFTF9HVUNfTVNHX0dFVChEQVRBLCBt KQo+PiAtI2RlZmluZSBJTlRFTF9HVUNfTVNHX1RPX0NPREUobSnCoMKgwqAgX19JTlRFTF9HVUNf TVNHX0dFVChDT0RFLCBtKQo+PiAtCj4+IC0jZGVmaW5lIF9fSU5URUxfR1VDX01TR19UWVBFX0lT KFQsIG0pIFwKPj4gLcKgwqDCoCAoSU5URUxfR1VDX01TR19UT19UWVBFKG0pID09IElOVEVMX0dV Q19NU0dfVFlQRV8gIyMgVCkKPj4gLSNkZWZpbmUgSU5URUxfR1VDX01TR19JU19SRVFVRVNUKG0p wqDCoMKgCj4+IF9fSU5URUxfR1VDX01TR19UWVBFX0lTKFJFUVVFU1QsIG0pCj4+IC0jZGVmaW5l IElOVEVMX0dVQ19NU0dfSVNfUkVTUE9OU0UobSnCoMKgwqAKPj4gX19JTlRFTF9HVUNfTVNHX1RZ UEVfSVMoUkVTUE9OU0UsIG0pCj4+IC0KPj4gLSNkZWZpbmUgSU5URUxfR1VDX01TR19JU19SRVNQ T05TRV9TVUNDRVNTKG0pIFwKPj4gLcKgwqDCoMKgICh0eXBlY2hlY2sodTMyLCAobSkpICYmIFwK Pj4gLcKgwqDCoMKgwqAgKChtKSAmIChJTlRFTF9HVUNfTVNHX1RZUEVfTUFTSyB8IElOVEVMX0dV Q19NU0dfQ09ERV9NQVNLKSkgPT0gXAo+PiAtwqDCoMKgwqDCoCAoKElOVEVMX0dVQ19NU0dfVFlQ RV9SRVNQT05TRSA8PCBJTlRFTF9HVUNfTVNHX1RZUEVfU0hJRlQpIHwgXAo+PiAtwqDCoMKgwqDC oMKgIChJTlRFTF9HVUNfUkVTUE9OU0VfU1RBVFVTX1NVQ0NFU1MgPDwgSU5URUxfR1VDX01TR19D T0RFX1NISUZUKSkpCj4+IC0KPj4gwqAgLyogVGhpcyBhY3Rpb24gd2lsbCBiZSBwcm9ncmFtbWVk IGluIEMxQkMgLSBTT0ZUX1NDUkFUQ0hfMTVfUkVHICovCj4+IMKgIGVudW0gaW50ZWxfZ3VjX3Jl Y3ZfbWVzc2FnZSB7Cj4+IMKgwqDCoMKgwqAgSU5URUxfR1VDX1JFQ1ZfTVNHX0NSQVNIX0RVTVBf UE9TVEVEID0gQklUKDEpLAo+PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Qv dWMvaW50ZWxfZ3VjX2xvZy5jCj4+IGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxf Z3VjX2xvZy5jCj4+IGluZGV4IGMzNmQ1ZWI1YmJiOS4uYWMwOTMxZjAzNzRiIDEwMDY0NAo+PiAt LS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRlbF9ndWNfbG9nLmMKPj4gKysrIGIv ZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX2xvZy5jCj4+IEBAIC0xOTcsMTAg KzE5Nyw4IEBAIHN0YXRpYyBib29sIGd1Y19jaGVja19sb2dfYnVmX292ZXJmbG93KHN0cnVjdAo+ PiBpbnRlbF9ndWNfbG9nICpsb2csCj4+IMKgIHN0YXRpYyB1bnNpZ25lZCBpbnQgZ3VjX2dldF9s b2dfYnVmZmVyX3NpemUoZW51bSBndWNfbG9nX2J1ZmZlcl90eXBlCj4+IHR5cGUpCj4+IMKgIHsK Pj4gwqDCoMKgwqDCoCBzd2l0Y2ggKHR5cGUpIHsKPj4gLcKgwqDCoCBjYXNlIEdVQ19JU1JfTE9H X0JVRkZFUjoKPj4gLcKgwqDCoMKgwqDCoMKgIHJldHVybiBJU1JfQlVGRkVSX1NJWkU7Cj4+IC3C oMKgwqAgY2FzZSBHVUNfRFBDX0xPR19CVUZGRVI6Cj4+IC3CoMKgwqDCoMKgwqDCoCByZXR1cm4g RFBDX0JVRkZFUl9TSVpFOwo+PiArwqDCoMKgIGNhc2UgR1VDX0RFQlVHX0xPR19CVUZGRVI6Cj4+ ICvCoMKgwqDCoMKgwqDCoCByZXR1cm4gREVCVUdfQlVGRkVSX1NJWkU7Cj4+IMKgwqDCoMKgwqAg Y2FzZSBHVUNfQ1JBU0hfRFVNUF9MT0dfQlVGRkVSOgo+PiDCoMKgwqDCoMKgwqDCoMKgwqAgcmV0 dXJuIENSQVNIX0JVRkZFUl9TSVpFOwo+PiDCoMKgwqDCoMKgIGRlZmF1bHQ6Cj4+IEBAIC0yNDUs NyArMjQzLDcgQEAgc3RhdGljIHZvaWQgZ3VjX3JlYWRfdXBkYXRlX2xvZ19idWZmZXIoc3RydWN0 Cj4+IGludGVsX2d1Y19sb2cgKmxvZykKPj4gwqDCoMKgwqDCoCBzcmNfZGF0YSArPSBQQUdFX1NJ WkU7Cj4+IMKgwqDCoMKgwqAgZHN0X2RhdGEgKz0gUEFHRV9TSVpFOwo+PiDCoCAtwqDCoMKgIGZv ciAodHlwZSA9IEdVQ19JU1JfTE9HX0JVRkZFUjsgdHlwZSA8IEdVQ19NQVhfTE9HX0JVRkZFUjsK Pj4gdHlwZSsrKSB7Cj4+ICvCoMKgwqAgZm9yICh0eXBlID0gR1VDX0RFQlVHX0xPR19CVUZGRVI7 IHR5cGUgPCBHVUNfTUFYX0xPR19CVUZGRVI7Cj4+IHR5cGUrKykgewo+PiDCoMKgwqDCoMKgwqDC oMKgwqAgLyoKPj4gwqDCoMKgwqDCoMKgwqDCoMKgwqAgKiBNYWtlIGEgY29weSBvZiB0aGUgc3Rh dGUgc3RydWN0dXJlLCBpbnNpZGUgR3VDIGxvZyBidWZmZXIKPj4gwqDCoMKgwqDCoMKgwqDCoMKg wqAgKiAod2hpY2ggaXMgdW5jYWNoZWQgbWFwcGVkKSwgb24gdGhlIHN0YWNrIHRvIGF2b2lkIHJl YWRpbmcKPj4gQEAgLTQ2MywyMSArNDYxLDE2IEBAIGludCBpbnRlbF9ndWNfbG9nX2NyZWF0ZShz dHJ1Y3QgaW50ZWxfZ3VjX2xvZyAqbG9nKQo+PiDCoMKgwqDCoMKgwqAgKsKgICs9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09KyAwMEIKPj4gwqDCoMKgwqDCoMKgICrCoCB8wqDCoMKgIENy YXNoIGR1bXAgc3RhdGUgaGVhZGVywqDCoMKgIHwKPj4gwqDCoMKgwqDCoMKgICrCoCArLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsgMzJCCj4+IC3CoMKgwqDCoCAqwqAgfMKgwqDCoMKg wqDCoCBEUEMgc3RhdGUgaGVhZGVywqDCoMKgwqDCoMKgwqAgfAo+PiArwqDCoMKgwqAgKsKgIHzC oMKgwqDCoMKgIERlYnVnIHN0YXRlIGhlYWRlcsKgwqDCoMKgwqDCoCB8Cj4+IMKgwqDCoMKgwqDC oCAqwqAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rIDY0Qgo+PiAtwqDCoMKgwqAg KsKgIHzCoMKgwqDCoMKgwqAgSVNSIHN0YXRlIGhlYWRlcsKgwqDCoMKgwqDCoMKgIHwKPj4gLcKg wqDCoMKgICrCoCArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsgOTZCCj4+IMKgwqDC oMKgwqDCoCAqwqAgfMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoCB8Cj4+IMKgwqDCoMKgwqDCoCAqwqAgKz09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0rIFBBR0VfU0laRSAoNEtCKQo+PiDCoMKgwqDCoMKgwqAgKsKgIHzCoMKg wqDCoMKgwqDCoCBDcmFzaCBEdW1wIGxvZ3PCoMKgwqDCoMKgwqDCoCB8Cj4+IMKgwqDCoMKgwqDC oCAqwqAgKz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0rICsgQ1JBU0hfU0laRQo+PiAt wqDCoMKgwqAgKsKgIHzCoMKgwqDCoMKgwqDCoMKgwqDCoCBEUEMgbG9nc8KgwqDCoMKgwqDCoMKg wqDCoMKgwqAgfAo+PiAtwqDCoMKgwqAgKsKgICs9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09KyArIERQQ19TSVpFCj4+IC3CoMKgwqDCoCAqwqAgfMKgwqDCoMKgwqDCoMKgwqDCoMKgIElT UiBsb2dzwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB8Cj4+IC3CoMKgwqDCoCAqwqAgKz09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0rICsgSVNSX1NJWkUKPj4gK8KgwqDCoMKgICrCoCB8wqDC oMKgwqDCoMKgwqDCoMKgIERlYnVnIGxvZ3PCoMKgwqDCoMKgwqDCoMKgwqDCoCB8Cj4+ICvCoMKg wqDCoCAqwqAgKz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0rICsgREVCVUdfU0laRQo+ PiDCoMKgwqDCoMKgwqAgKi8KPj4gLcKgwqDCoCBndWNfbG9nX3NpemUgPSBQQUdFX1NJWkUgKyBD UkFTSF9CVUZGRVJfU0laRSArIERQQ19CVUZGRVJfU0laRSArCj4+IC3CoMKgwqDCoMKgwqDCoMKg wqDCoMKgIElTUl9CVUZGRVJfU0laRTsKPj4gK8KgwqDCoCBndWNfbG9nX3NpemUgPSBQQUdFX1NJ WkUgKyBDUkFTSF9CVUZGRVJfU0laRSArIERFQlVHX0JVRkZFUl9TSVpFOwo+PiDCoCDCoMKgwqDC oMKgIHZtYSA9IGludGVsX2d1Y19hbGxvY2F0ZV92bWEoZ3VjLCBndWNfbG9nX3NpemUpOwo+PiDC oMKgwqDCoMKgIGlmIChJU19FUlIodm1hKSkgewo+PiBAQCAtNjc1LDEwICs2NjgsOCBAQCBzdGF0 aWMgY29uc3QgY2hhciAqCj4+IMKgIHN0cmluZ2lmeV9ndWNfbG9nX3R5cGUoZW51bSBndWNfbG9n X2J1ZmZlcl90eXBlIHR5cGUpCj4+IMKgIHsKPj4gwqDCoMKgwqDCoCBzd2l0Y2ggKHR5cGUpIHsK Pj4gLcKgwqDCoCBjYXNlIEdVQ19JU1JfTE9HX0JVRkZFUjoKPj4gLcKgwqDCoMKgwqDCoMKgIHJl dHVybiAiSVNSIjsKPj4gLcKgwqDCoCBjYXNlIEdVQ19EUENfTE9HX0JVRkZFUjoKPj4gLcKgwqDC oMKgwqDCoMKgIHJldHVybiAiRFBDIjsKPj4gK8KgwqDCoCBjYXNlIEdVQ19ERUJVR19MT0dfQlVG RkVSOgo+PiArwqDCoMKgwqDCoMKgwqAgcmV0dXJuICJERUJVRyI7Cj4+IMKgwqDCoMKgwqAgY2Fz ZSBHVUNfQ1JBU0hfRFVNUF9MT0dfQlVGRkVSOgo+PiDCoMKgwqDCoMKgwqDCoMKgwqAgcmV0dXJu ICJDUkFTSCI7Cj4+IMKgwqDCoMKgwqAgZGVmYXVsdDoKPj4gQEAgLTcwOCw3ICs2OTksNyBAQCB2 b2lkIGludGVsX2d1Y19sb2dfaW5mbyhzdHJ1Y3QgaW50ZWxfZ3VjX2xvZyAqbG9nLAo+PiBzdHJ1 Y3QgZHJtX3ByaW50ZXIgKnApCj4+IMKgIMKgwqDCoMKgwqAgZHJtX3ByaW50ZihwLCAiXHRSZWxh eSBmdWxsIGNvdW50OiAldVxuIiwgbG9nLT5yZWxheS5mdWxsX2NvdW50KTsKPj4gwqAgLcKgwqDC oCBmb3IgKHR5cGUgPSBHVUNfSVNSX0xPR19CVUZGRVI7IHR5cGUgPCBHVUNfTUFYX0xPR19CVUZG RVI7Cj4+IHR5cGUrKykgewo+PiArwqDCoMKgIGZvciAodHlwZSA9IEdVQ19ERUJVR19MT0dfQlVG RkVSOyB0eXBlIDwgR1VDX01BWF9MT0dfQlVGRkVSOwo+PiB0eXBlKyspIHsKPj4gwqDCoMKgwqDC oMKgwqDCoMKgIGRybV9wcmludGYocCwgIlx0JXM6XHRmbHVzaCBjb3VudCAlMTB1LCBvdmVyZmxv dyBjb3VudCAlMTB1XG4iLAo+PiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBzdHJp bmdpZnlfZ3VjX2xvZ190eXBlKHR5cGUpLAo+PiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoCBsb2ctPnN0YXRzW3R5cGVdLmZsdXNoLAo+PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX2xvZy5oCj4+IGIvZHJpdmVycy9ncHUvZHJtL2k5MTUv Z3QvdWMvaW50ZWxfZ3VjX2xvZy5oCj4+IGluZGV4IDExZmNjZDBiMjI5NC4uYWMxZWUxZDVjZTEw IDEwMDY0NAo+PiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRlbF9ndWNfbG9n LmgKPj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX2xvZy5oCj4+ IEBAIC0xNywxMiArMTcsMTAgQEAgc3RydWN0IGludGVsX2d1YzsKPj4gwqAgwqAgI2lmZGVmIENP TkZJR19EUk1fSTkxNV9ERUJVR19HVUMKPj4gwqAgI2RlZmluZSBDUkFTSF9CVUZGRVJfU0laRcKg wqDCoCBTWl8yTQo+PiAtI2RlZmluZSBEUENfQlVGRkVSX1NJWkXCoMKgwqDCoMKgwqDCoCBTWl84 TQo+PiAtI2RlZmluZSBJU1JfQlVGRkVSX1NJWkXCoMKgwqDCoMKgwqDCoCBTWl84TQo+PiArI2Rl ZmluZSBERUJVR19CVUZGRVJfU0laRcKgwqDCoCBTWl8xNk0KPj4gwqAgI2Vsc2UKPj4gwqAgI2Rl ZmluZSBDUkFTSF9CVUZGRVJfU0laRcKgwqDCoCBTWl84Swo+PiAtI2RlZmluZSBEUENfQlVGRkVS X1NJWkXCoMKgwqDCoMKgwqDCoCBTWl8zMksKPj4gLSNkZWZpbmUgSVNSX0JVRkZFUl9TSVpFwqDC oMKgwqDCoMKgwqAgU1pfMzJLCj4+ICsjZGVmaW5lIERFQlVHX0JVRkZFUl9TSVpFwqDCoMKgIFNa XzY0Swo+PiDCoCAjZW5kaWYKPj4gwqAgwqAgLyoKPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2d0L3VjL2ludGVsX3VjX2Z3LmMKPj4gYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9n dC91Yy9pbnRlbF91Y19mdy5jCj4+IGluZGV4IGRmNjQ3YzlhOGQ1Ni4uOWYyM2U5ZGUzMjM3IDEw MDY0NAo+PiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRlbF91Y19mdy5jCj4+ ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX3VjX2Z3LmMKPj4gQEAgLTQ4 LDE5ICs0OCwxOSBAQCB2b2lkIGludGVsX3VjX2Z3X2NoYW5nZV9zdGF0dXMoc3RydWN0IGludGVs X3VjX2Z3Cj4+ICp1Y19mdywKPj4gwqDCoCAqIGZpcm13YXJlIGFzIFRHTC4KPj4gwqDCoCAqLwo+ PiDCoCAjZGVmaW5lIElOVEVMX1VDX0ZJUk1XQVJFX0RFRlMoZndfZGVmLCBndWNfZGVmLCBodWNf ZGVmKSBcCj4+IC3CoMKgwqAgZndfZGVmKEFMREVSTEFLRV9TLCAwLCBndWNfZGVmKHRnbCwgNDks IDAsIDEpLCBodWNfZGVmKHRnbCzCoCA3LAo+PiA1LCAwKSkgXAo+PiAtwqDCoMKgIGZ3X2RlZihS T0NLRVRMQUtFLMKgIDAsIGd1Y19kZWYodGdsLCA0OSwgMCwgMSksIGh1Y19kZWYodGdsLMKgIDcs Cj4+IDUsIDApKSBcCj4+IC3CoMKgwqAgZndfZGVmKFRJR0VSTEFLRSzCoMKgIDAsIGd1Y19kZWYo dGdsLCA0OSwgMCwgMSksIGh1Y19kZWYodGdsLMKgIDcsCj4+IDUsIDApKSBcCj4+IC3CoMKgwqAg ZndfZGVmKEpBU1BFUkxBS0UswqAgMCwgZ3VjX2RlZihlaGwsIDQ5LCAwLCAxKSwgaHVjX2RlZihl aGwswqAgOSwKPj4gMCwgMCkpIFwKPj4gLcKgwqDCoCBmd19kZWYoRUxLSEFSVExBS0UsIDAsIGd1 Y19kZWYoZWhsLCA0OSwgMCwgMSksIGh1Y19kZWYoZWhsLMKgIDksCj4+IDAsIDApKSBcCj4+IC3C oMKgwqAgZndfZGVmKElDRUxBS0UswqDCoMKgwqAgMCwgZ3VjX2RlZihpY2wsIDQ5LCAwLCAxKSwg aHVjX2RlZihpY2wswqAgOSwKPj4gMCwgMCkpIFwKPj4gLcKgwqDCoCBmd19kZWYoQ09NRVRMQUtF LMKgwqAgNSwgZ3VjX2RlZihjbWwsIDQ5LCAwLCAxKSwgaHVjX2RlZihjbWwswqAgNCwKPj4gMCwg MCkpIFwKPj4gLcKgwqDCoCBmd19kZWYoQ09NRVRMQUtFLMKgwqAgMCwgZ3VjX2RlZihrYmwsIDQ5 LCAwLCAxKSwgaHVjX2RlZihrYmwswqAgNCwKPj4gMCwgMCkpIFwKPj4gLcKgwqDCoCBmd19kZWYo Q09GRkVFTEFLRSzCoCAwLCBndWNfZGVmKGtibCwgNDksIDAsIDEpLCBodWNfZGVmKGtibCzCoCA0 LAo+PiAwLCAwKSkgXAo+PiAtwqDCoMKgIGZ3X2RlZihHRU1JTklMQUtFLMKgIDAsIGd1Y19kZWYo Z2xrLCA0OSwgMCwgMSksIGh1Y19kZWYoZ2xrLMKgIDQsCj4+IDAsIDApKSBcCj4+IC3CoMKgwqAg ZndfZGVmKEtBQllMQUtFLMKgwqDCoCAwLCBndWNfZGVmKGtibCwgNDksIDAsIDEpLCBodWNfZGVm KGtibCzCoCA0LAo+PiAwLCAwKSkgXAo+PiAtwqDCoMKgIGZ3X2RlZihCUk9YVE9OLMKgwqDCoMKg IDAsIGd1Y19kZWYoYnh0LCA0OSwgMCwgMSksIGh1Y19kZWYoYnh0LMKgIDIsCj4+IDAsIDApKSBc Cj4+IC3CoMKgwqAgZndfZGVmKFNLWUxBS0UswqDCoMKgwqAgMCwgZ3VjX2RlZihza2wsIDQ5LCAw LCAxKSwgaHVjX2RlZihza2wswqAgMiwKPj4gMCwgMCkpCj4+ICvCoMKgwqAgZndfZGVmKEFMREVS TEFLRV9TLCAwLCBndWNfZGVmKHRnbCwgNjIsIDAsIDApLCBodWNfZGVmKHRnbCzCoCA3LAo+PiA1 LCAwKSkgXAo+PiArwqDCoMKgIGZ3X2RlZihST0NLRVRMQUtFLMKgIDAsIGd1Y19kZWYodGdsLCA2 MiwgMCwgMCksIGh1Y19kZWYodGdsLMKgIDcsCj4+IDUsIDApKSBcCj4+ICvCoMKgwqAgZndfZGVm KFRJR0VSTEFLRSzCoMKgIDAsIGd1Y19kZWYodGdsLCA2MiwgMCwgMCksIGh1Y19kZWYodGdsLMKg IDcsCj4+IDUsIDApKSBcCj4+ICvCoMKgwqAgZndfZGVmKEpBU1BFUkxBS0UswqAgMCwgZ3VjX2Rl ZihlaGwsIDYyLCAwLCAwKSwgaHVjX2RlZihlaGwswqAgOSwKPj4gMCwgMCkpIFwKPj4gK8KgwqDC oCBmd19kZWYoRUxLSEFSVExBS0UsIDAsIGd1Y19kZWYoZWhsLCA2MiwgMCwgMCksIGh1Y19kZWYo ZWhsLMKgIDksCj4+IDAsIDApKSBcCj4+ICvCoMKgwqAgZndfZGVmKElDRUxBS0UswqDCoMKgwqAg MCwgZ3VjX2RlZihpY2wsIDYyLCAwLCAwKSwgaHVjX2RlZihpY2wswqAgOSwKPj4gMCwgMCkpIFwK Pj4gK8KgwqDCoCBmd19kZWYoQ09NRVRMQUtFLMKgwqAgNSwgZ3VjX2RlZihjbWwsIDYyLCAwLCAw KSwgaHVjX2RlZihjbWwswqAgNCwKPj4gMCwgMCkpIFwKPj4gK8KgwqDCoCBmd19kZWYoQ09NRVRM QUtFLMKgwqAgMCwgZ3VjX2RlZihrYmwsIDYyLCAwLCAwKSwgaHVjX2RlZihrYmwswqAgNCwKPj4g MCwgMCkpIFwKPj4gK8KgwqDCoCBmd19kZWYoQ09GRkVFTEFLRSzCoCAwLCBndWNfZGVmKGtibCwg NjIsIDAsIDApLCBodWNfZGVmKGtibCzCoCA0LAo+PiAwLCAwKSkgXAo+PiArwqDCoMKgIGZ3X2Rl ZihHRU1JTklMQUtFLMKgIDAsIGd1Y19kZWYoZ2xrLCA2MiwgMCwgMCksIGh1Y19kZWYoZ2xrLMKg IDQsCj4+IDAsIDApKSBcCj4+ICvCoMKgwqAgZndfZGVmKEtBQllMQUtFLMKgwqDCoCAwLCBndWNf ZGVmKGtibCwgNjIsIDAsIDApLCBodWNfZGVmKGtibCzCoCA0LAo+PiAwLCAwKSkgXAo+PiArwqDC oMKgIGZ3X2RlZihCUk9YVE9OLMKgwqDCoMKgIDAsIGd1Y19kZWYoYnh0LCA2MiwgMCwgMCksIGh1 Y19kZWYoYnh0LMKgIDIsCj4+IDAsIDApKSBcCj4+ICvCoMKgwqAgZndfZGVmKFNLWUxBS0UswqDC oMKgwqAgMCwgZ3VjX2RlZihza2wsIDYyLCAwLCAwKSwgaHVjX2RlZihza2wswqAgMiwKPj4gMCwg MCkpCj4+IMKgIMKgICNkZWZpbmUgX19NQUtFX1VDX0ZXX1BBVEgocHJlZml4XywgbmFtZV8sIG1h am9yXywgbWlub3JfLCBwYXRjaF8pIFwKPj4gwqDCoMKgwqDCoCAiaTkxNS8iIFwKPiAKX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxp bmcgbGlzdApJbnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJl ZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vaW50ZWwtZ2Z4Cg==