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 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 436EEC433F5 for ; Wed, 13 Oct 2021 19:07:04 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 0A4E460273 for ; Wed, 13 Oct 2021 19:07:04 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S238794AbhJMTJF (ORCPT ); Wed, 13 Oct 2021 15:09:05 -0400 Received: from linux.microsoft.com ([13.77.154.182]:49068 "EHLO linux.microsoft.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S238337AbhJMTIq (ORCPT ); Wed, 13 Oct 2021 15:08:46 -0400 Received: from linuxonhyperv3.guj3yctzbm1etfxqx2vob5hsef.xx.internal.cloudapp.net (linux.microsoft.com [13.77.154.182]) by linux.microsoft.com (Postfix) with ESMTPSA id C6F4820B9D0C; Wed, 13 Oct 2021 12:06:40 -0700 (PDT) DKIM-Filter: OpenDKIM Filter v2.11.0 linux.microsoft.com C6F4820B9D0C DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.microsoft.com; s=default; t=1634152000; bh=dQ+u9TNfPDEJUjM64WZr/miBrXoUBKgng6ViWxPtixc=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=b29+pJ6FM1zVt4i4+Ggxjywi0M8X7qZH7waixVR0fsPRpL/piBDpiyAuyNzNbz4jC QDLyBe2h+hTdXATF3rhAnULcTDekL/bgYma24lzTqdbcoPJahAprHP5oS3HUEGlfDv 2VEsE4KlefPAKod+1IFdVvrg5PDcI2i/MqQTFPTI= From: deven.desai@linux.microsoft.com To: corbet@lwn.net, axboe@kernel.dk, agk@redhat.com, snitzer@redhat.com, ebiggers@kernel.org, tytso@mit.edu, paul@paul-moore.com, eparis@redhat.com, jmorris@namei.org, serge@hallyn.com Cc: jannh@google.com, dm-devel@redhat.com, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-block@vger.kernel.org, linux-fscrypt@vger.kernel.org, linux-audit@redhat.com, linux-security-module@vger.kernel.org Subject: [RFC PATCH v7 16/16] documentation: add ipe documentation Date: Wed, 13 Oct 2021 12:06:35 -0700 Message-Id: <1634151995-16266-17-git-send-email-deven.desai@linux.microsoft.com> X-Mailer: git-send-email 1.8.3.1 In-Reply-To: <1634151995-16266-1-git-send-email-deven.desai@linux.microsoft.com> References: <1634151995-16266-1-git-send-email-deven.desai@linux.microsoft.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-fscrypt@vger.kernel.org From: Deven Bowers Add IPE's admin and developer documentation to the kernel tree. Co-developed-by: Fan Wu Signed-off-by: Fan Wu Signed-off-by: Deven Bowers --- Relevant changes since v6: * Add additional developer-level documentation * Update admin-guide docs to reflect changes. * Drop Acked-by due to significant changes --- Documentation/admin-guide/LSM/index.rst | 1 + Documentation/admin-guide/LSM/ipe.rst | 587 ++++++++++++++++++ .../admin-guide/kernel-parameters.txt | 12 + Documentation/security/index.rst | 1 + Documentation/security/ipe.rst | 339 ++++++++++ MAINTAINERS | 2 + 6 files changed, 942 insertions(+) create mode 100644 Documentation/admin-guide/LSM/ipe.rst create mode 100644 Documentation/security/ipe.rst diff --git a/Documentation/admin-guide/LSM/index.rst b/Documentation/admin-guide/LSM/index.rst index a6ba95fbaa9f..ce63be6d64ad 100644 --- a/Documentation/admin-guide/LSM/index.rst +++ b/Documentation/admin-guide/LSM/index.rst @@ -47,3 +47,4 @@ subdirectories. tomoyo Yama SafeSetID + ipe diff --git a/Documentation/admin-guide/LSM/ipe.rst b/Documentation/admin-guide/LSM/ipe.rst new file mode 100644 index 000000000000..56a9fa2fe59b --- /dev/null +++ b/Documentation/admin-guide/LSM/ipe.rst @@ -0,0 +1,587 @@ +.. SPDX-License-Identifier: GPL-2.0 + +Integrity Policy Enforcement (IPE) +================================== + +.. NOTE:: + + This is the documentation for admins, system builders, or individuals + attempting to use IPE, without understanding all of its internal systems. + If you're looking for documentation to extend IPE, understand the design + decisions behind IPE, or are just curious about the internals, please + see :ref:`Documentation/security/ipe.rst` + +Overview +-------- + +IPE is a Linux Security Module which imposes a complimentary model +of mandatory access control to other LSMs. Whereas the existing LSMs +impose access control based on labels or paths, IPE imposes access +control based on the trust of the resource. Simply put, IPE +or restricts access to a resource based on the trust of said resource. + +Trust requirements are established via IPE's policy, sourcing multiple +different implementations within the kernel to build a cohesive trust +model, based on how the system was built. + +Trust vs Integrity +------------------ + +Trust, with respect to computing, is a concept that designates a set +of entities who will endorse a set of resources as non-malicious. +Traditionally, this is done via signatures, which is the act of endorsing +a resource. Integrity, on the other hand, is the concept of ensuring that a +resource has not been modified since a point of time. This is typically done +through cryptography or signatures. + +Trust and integrity are very closely tied together concepts, as integrity +is the way you can prove trust for a resource; otherwise it could have +been modified by an entity who is untrusted. + +IPE provides a way for a user to express trust of resources, by using +pre-existing systems which provide the integrity half of the equation. + +Use Cases +--------- + +IPE works best in fixed-function devices: Devices in which their purpose +is clearly defined and not supposed to be changed (e.g. network firewall +device in a data center, an IoT device, etcetera), where all software and +configuration is built and provisioned by the system owner. + +IPE is a long-way off for use in general-purpose computing: +the Linux community as a whole tends to follow a decentralized trust +model, known as the Web of Trust, which IPE has no support for as of yet. +Instead, IPE supports the PKI Trust Model, which generally designates a +set of entities that provide a measure absolute trust. + +Additionally, while most packages are signed today, the files inside +the packages (for instance, the executables), tend to be unsigned. This +makes it difficult to utilize IPE in systems where a package manager is +expected to be functional, without major changes to the package manager +and ecosystem behind it. + +For the highest level of security, platform firmware should verify the +the kernel and optionally the root filesystem (for example, via U-Boot +verified boot). This forms a chain of trust from the hardware, ensuring +that every stage of the system is trusted. + +Known Gaps +---------- + +IPE cannot verify the integrity of anonymous executable memory, such as +the trampolines created by gcc closures and libffi (<3.4.2), or JIT'd code. +Unfortunately, as this is dynamically generated code, there is no way +for IPE to ensure the integrity of this code to form a trust basis. In all +cases, the return result for these operations will be whatever the admin +configures the DEFAULT action for "EXECUTE". + +IPE cannot verify the integrity of interpreted languages' programs when +these scripts invoked via `` ``. This is because the +way interpreters execute these files, the scripts themselves are not +evaluated as executable code through one of IPE's hooks. Interpreters +can be enlightened to the usage of IPE by trying to mmap a file into +executable memory (+X), after opening the file and responding to the +error code appropriately. This also applies to included files, or high +value files, such as configuration files of critical system components [#]_. + +.. [#] Mickaël Salaün's `trusted_for patchset `_ + can be used to leverage this. + +Threat Model +------------ + +The threat type addressed by IPE is tampering of executable user-land +code beyond the initially booted kernel, and the initial verification of +kernel modules that are loaded in userland through ``modprobe`` or +``insmod``. + +Tampering violates integrity, and being unable to verify the integrity, +results in a lack of trust. IPE's role in mitigating this threat is to +verify the integrity (and authenticity) of all executable code and to +deny their use if they cannot be trusted (as integrity verification fails). +IPE generates audit logs which may be utilized to detect failures resulting +from failure to pass policy. + +Tampering threat scenarios include modification or replacement of +executable code by a range of actors including: + +- Actors with physical access to the hardware +- Actors with local network access to the system +- Actors with access to the deployment system +- Compromised internal systems under external control +- Malicious end users of the system +- Compromised end users of the system +- Remote (external) compromise of the system + +IPE does not mitigate threats arising from malicious authorized +developers, or compromised developer tools used by authorized +developers. Additionally, IPE draws hard security boundary between user +mode and kernel mode. As a result, IPE does not provide any protections +against a kernel level exploit, and a kernel-level exploit can disable +or tamper with IPE's protections. + +Policy +------ + +IPE policy is a plain-text [#]_ policy composed of multiple statements +over several lines. There is one required line, at the top of the +policy, indicating the policy name, and the policy version, for +instance:: + + policy_name="Ex Policy" policy_version=0.0.0 + +The policy name is a unique key identifying this policy in a human +readable name. This is used to create nodes under securityfs as well as +uniquely identify policies to deploy new policies vs update existing +policies. + +The policy version indicates the current version of the policy (NOT the +policy syntax version). This is used to prevent rollback of policy to +potentially insecure previous versions of the policy. + +The next portion of IPE policy, are rules. Rules are formed by key=value +pairs, known as properties. IPE rules require two properties: "action", +which determines what IPE does when it encounters a match against the +rule, and "op", which determines when that rule should be evaluated. +The ordering is significant, a rule must start with "op", and end with +"action". Thus, a minimal rule is:: + + op=EXECUTE action=ALLOW + +This example will allow any execution. Additional properties are used to +restrict attributes about the files being evaluated. These properties +are intended to be descriptions of systems within the kernel, that can +provide a measure of integrity verification, such that IPE can determine +the trust of the resource based on the "value" half of the property. + +Rules are evaluated top-to-bottom. As a result, any revocation rules, +or denies should be placed early in the file to ensure that these rules +are evaluated before as rule with "action=ALLOW" is hit. + +IPE policy is designed to be only forward compatible. Userspace can read +what the parser's current configuration (supported statements, properties, +etcetera) via reading the securityfs entry, 'ipe/config' + +IPE policy supports comments. The character '#' will function as a +comment, ignoring all characters to the right of '#' until the newline. + +The default behavior of IPE evaluations can also be expressed in policy, +through the ``DEFAULT`` statement. This can be done at a global level, +or a per-operation level:: + + # Global + DEFAULT action=ALLOW + + # Operation Specific + DEFAULT op=EXECUTE action=ALLOW + +A default must be set for all known operations in IPE. If you want to +preserve older policies being compatible with newer kernels that can introduce +new operations, please set a global default of 'ALLOW', and override the +defaults on a per-operation basis. + +With configurable policy-based LSMs, there's several issues with +enforcing the configurable policies at startup, around reading and +parsing the policy: + +1. The kernel *should* not read files from userland, so directly reading + the policy file is prohibited. +2. The kernel command line has a character limit, and one kernel module + should not reserve the entire character limit for its own + configuration. +3. There are various boot loaders in the kernel ecosystem, so handing + off a memory block would be costly to maintain. + +As a result, IPE has addressed this problem through a concept of a "boot +policy". A boot policy is a minimal policy, compiled into the kernel. +This policy is intended to get the system to a state where userland is +setup and ready to receive commands, at which point a more complex +policy ("user policies") can be deployed via securityfs. The boot policy +can be specified via the Kconfig, ``SECURITY_IPE_BOOT_POLICY``, which +accepts a path to a plain-text version of the IPE policy to apply. This +policy will be compiled into the kernel. If not specified, IPE will be +disabled until a policy is deployed and activated through securityfs. + +.. [#] Please see the :ref:`Documentation/security/ipe.rst` for more on this + topic. + +Deploying Policies +~~~~~~~~~~~~~~~~~~ + +User policies as explained above, are policies that are deployed from +userland, through securityfs. These policies are signed to enforce some +level of authorization of the policies (prohibiting an attacker from +gaining root, and deploying an "allow all" policy), through the PKCS#7 +enveloped data format. These policies must be signed by a certificate +that chains to the ``SYSTEM_TRUSTED_KEYRING``. Through openssl, the +signing can be done via:: + + openssl smime -sign -in "$MY_POLICY" -signer "$MY_CERTIFICATE" \ + -inkey "$MY_PRIVATE_KEY" -binary -outform der -noattr -nodetach \ + -out "$MY_POLICY.p7s" + +Deploying the policies is done through securityfs, through the +``new_policy`` node. To deploy a policy, simply cat the file into the +securityfs node:: + + cat "$MY_POLICY.p7s" > /sys/kernel/security/ipe/new_policy + +Upon success, this will create one subdirectory under +``/sys/kernel/security/ipe/policies/``. The subdirectory will be the +``policy_name`` field of the policy deployed, so for the example above, +the directory will be ``/sys/kernel/security/ipe/policies/Ex\ Policy``. +Within this directory, there will be five files: ``pkcs7``, ``policy``, +``active``, ``update``, and ``delete``. + +The ``pkcs7`` file is rw, reading will provide the raw PKCS#7 data that +was provided to the kernel, representing the policy. Writing, will +deploy an in-place policy update - if this policy is the currently +running policy, the new updated policy will replace it immediately upon +success. If the policy being read is the boot policy, when read, this +will return ENOENT. + +The ``policy`` file is read only. Reading will provide the PKCS#7 inner +content of the policy, which will be the plain text policy. + +The ``active`` file is used to set a policy as the currently active policy. +This file is rw, and accepts a value of ``"1"`` to set the policy as active. +Since only a single policy can be active at one time, all other policies +will be marked inactive. The policy being marked active must have a policy +version greater or equal to the currently-running version. + +The ``update`` file is used to update a policy that is already present in +the kernel. This file is write-only and accepts a PKCS#7 signed policy. +One check will be performed on this policy: the policy_names must match +with the updated version and the existing version. If the policy being +updated is the active policy, the updated policy must have a policy version +greater or equal to the currently-running version. + +The ``delete`` file is used to remove a policy that is no longer needed. +This file is write-only and accepts a value of ``"1"`` to delete the policy. +On deletion, the securityfs node representing the policy will be removed. +The policy that is currently active, cannot be deleted. + +Similarly, the writes to both ``update`` and ``new_policy`` above will +result in an error upon syntactically invalid or untrusted policies. +It will also error if a policy already exists with the same ``policy_name``, +in the case of ``new_policy``. + +Deploying these policies will *not* cause IPE to start enforcing this +policy. Once deployment is successful, a policy can be marked as active, +via ``/sys/kernel/security/ipe/$policy_name/active``. IPE will enforce +whatever policy is marked as active. For our example, we can activate +the ``Ex Policy`` via:: + + echo "1" > "/sys/kernel/security/ipe/Ex Policy/active" + +At which point, ``Ex Policy`` will now be the enforced policy on the +system. + +IPE also provides a way to delete policies. This can be done via the +``delete`` securityfs node, ``/sys/kernel/security/ipe/$policy_name/delete``. +Writing ``1`` to that file will delete that node:: + + echo "1" > "/sys/kernel/security/ipe/$policy_name/delete" + +There is only one requirement to delete a policy: + +1. The policy being deleted must not be the active policy. + +.. NOTE:: + + If a traditional MAC system is enabled (SELinux, apparmor, smack), all + writes to ipe's securityfs nodes require ``CAP_MAC_ADMIN``. + +Modes +~~~~~ + +IPE supports two modes of operation: permissive (similar to SELinux's +permissive mode) and enforce. Permissive mode performs the same checks +as enforce mode, and logs policy violations, but will not enforce the +policy. This allows users to test policies before enforcing them. + +The default mode is enforce, and can be changed via the kernel command +line parameter ``ipe.enforce=(0|1)``, or the securityfs node +``/sys/kernel/security/ipe/enforce``. + +.. NOTE:: + + If a traditional MAC system is enabled (SELinux, apparmor, smack, etcetera), + all writes to ipe's securityfs nodes require ``CAP_MAC_ADMIN``. + +Audit Events +~~~~~~~~~~~~ + +Success Auditing +^^^^^^^^^^^^^^^^ + +IPE supports success auditing. When enabled, all events that pass IPE +policy and are not blocked will emit an audit event. This is disabled by +default, and can be enabled via the kernel command line +``ipe.success_audit=(0|1)`` or the securityfs node, +``/sys/kernel/security/ipe/success_audit``. + +This is very noisy, as IPE will check every user-mode binary on the +system, but is useful for debugging policies. + +.. NOTE:: + + If a traditional MAC system is enabled (SELinux, apparmor, smack, etcetera), + all writes to ipe's securityfs nodes require ``CAP_MAC_ADMIN``. + +Properties +-------------- + +As explained above, IPE properties are ``key=value`` pairs expressed in +IPE policy. Two properties are built-into the policy parser: 'op' and +'action'. The other properties are determinstic attributes to express +across files. Currently those properties are: 'boot_verified', +'dmverity_signature', 'dmverity_roothash', 'fsverity_signature', +'fsverity_digest'. A description of all properties supported by IPE +are listed below: + +op +~~ + +Indicates the operation for a rule to apply to. Must be in every rule, +as the first token. IPE supports the following operations: + +Version 1 +^^^^^^^^^ + +``EXECUTE`` + + Pertains to any file attempting to be executed, or loaded as an + executable. + +``FIRMWARE``: + + Pertains to firmware being loaded via the firmware_class interface. + This covers both the preallocated buffer and the firmware file + itself. + +``KMODULE``: + + Pertains to loading kernel modules via ``modprobe`` or ``insmod``. + +``KEXEC_IMAGE``: + + Pertains to kernel images loading via ``kexec``. + +``KEXEC_INITRAMFS`` + + Pertains to initrd images loading via ``kexec --initrd``. + +``POLICY``: + + Controls loading IMA policies through the + ``/sys/kernel/security/ima/policy`` securityfs entry. + +``X509_CERT``: + + Controls loading IMA certificates through the Kconfigs, + ``CONFIG_IMA_X509_PATH`` and ``CONFIG_EVM_X509_PATH``. + +``KERNEL_READ``: + + Short hand for all of the following: ``FIRMWARE``, ``KMODULE``, + ``KEXEC_IMAGE``, ``KEXEC_INITRAMFS``, ``POLICY``, and ``X509_CERT``. + +action +~~~~~~ + +Version 1 +^^^^^^^^^ + +Determines what IPE should do when a rule matches. Must be in every +rule, as the final clause. Can be one of: + +``ALLOW``: + + If the rule matches, explicitly allow access to the resource to proceed + without executing any more rules. + +``DENY``: + + If the rule matches, explicitly prohibit access to the resource to + proceed without executing any more rules. + +boot_verified +~~~~~~~~~~~~~ + +Version 1 +^^^^^^^^^ + +This property can be utilized for authorization of the first super-block +that executes a file. This is almost always init. Typically this is used +for systems with an initramfs or other initial disk, where this is unmounted +before the system becomes available, and is not covered by any other property. +This property is controlled by the Kconfig, ``CONFIG_IPE_PROP_BOOT_VERIFIED``. +The format of this property is:: + + boot_verified=(TRUE|FALSE) + + +.. WARNING:: + + This property will trust any disk where the first execution evaluation + occurs. If you do *NOT* have a startup disk that is unpacked and unmounted + (like initramfs), then it will automatically trust the root filesystem and + potentially overauthorize the entire disk. + +dmverity_roothash +~~~~~~~~~~~~~~~~~ + +Version 1 +^^^^^^^^^ + +This property can be utilized for authorization or revocation of +specific dm-verity volumes, identified via root hash. It has a +dependency on the DM_VERITY module. This property is controlled by the +Kconfig ``CONFIG_IPE_PROP_DM_VERITY_ROOTHASH``. The format of this property +is:: + + dmverity_roothash=HashHexDigest + +dmverity_signature +~~~~~~~~~~~~~~~~~~ + +Version 1 +^^^^^^^^^ + +This property can be utilized for authorization of all dm-verity volumes +that have a signed roothash that chains to a keyring specified by dm-verity's +configuration, either the system trusted keyring, or the secondary keyring. +It has an additional dependency on the ``DM_VERITY_VERIFY_ROOTHASH_SIG`` +Kconfig. This property is controlled by the Kconfig +``CONFIG_IPE_PROP_DM_VERITY_SIGNATURE``. The format of this property is:: + + dmverity_signature=(TRUE|FALSE) + +fsverity_digest +~~~~~~~~~~~~~~~ + +Version 1 +^^^^^^^^^ +This property can be utilized for authorization or revocation of +specific fsverity enabled file, identified via its fsverity digest, +which is the hash of a struct contains the file's roothash and hashing +parameters. It has a dependency on the FS_VERITY module. +This property is controlled by the Kconfig +``CONFIG_IPE_PROP_FS_VERITY_DIGEST``. The format of this property is:: + + fsverity_digest=HashHexDigest + +fsverity_signature +~~~~~~~~~~~~~~~~~~ + +Version 1 +^^^^^^^^^ + +This property can be utilized for authorization of all fsverity enabled +files that is verified by fsverity. The keyring that is verifies against +is subject to fsverity's configuration, which is typically the fsverity +keyring. It has a dependency on the ``CONFIG_FS_VERITY_BUILTIN_SIGNATURES`` +Kconfig. This property is controlled by the Kconfig +``CONFIG_IPE_PROP_FS_VERITY_SIGNATURE``. The format of this property is:: + + fsverity_signature=(TRUE|FALSE) + +Policy Examples +--------------- + +Allow all +~~~~~~~~~ + +:: + + policy_name="Allow All" policy_version=0.0.0 + DEFAULT action=ALLOW + +Allow only initial superblock +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +:: + + policy_name="Allow All Initial SB" policy_version=0.0.0 + DEFAULT action=DENY + + op=EXECUTE boot_verified=TRUE action=ALLOW + +Allow any signed dm-verity volume and the initial superblock +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +:: + + policy_name="AllowSignedAndInitial" policy_version=0.0.0 + DEFAULT action=DENY + + op=EXECUTE boot_verified=TRUE action=ALLOW + op=EXECUTE dmverity_signature=TRUE action=ALLOW + +Prohibit execution from a specific dm-verity volume +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +:: + + policy_name="AllowSignedAndInitial" policy_version=0.0.0 + DEFAULT action=DENY + + op=EXECUTE dmverity_roothash=401fcec5944823ae12f62726e8184407a5fa9599783f030dec146938 action=DENY + op=EXECUTE boot_verified=TRUE action=ALLOW + op=EXECUTE dmverity_signature=TRUE action=ALLOW + +Allow only a specific dm-verity volume +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +:: + + policy_name="AllowSignedAndInitial" policy_version=0.0.0 + DEFAULT action=DENY + + op=EXECUTE dmverity_roothash=401fcec5944823ae12f62726e8184407a5fa9599783f030dec146938 action=ALLOW + +Allow any signed fs-verity file +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +:: + + policy_name="AllowSignedFSVerity" policy_version=0.0.0 + DEFAULT action=DENY + + op=EXECUTE fsverity_signature=TRUE action=ALLOW + +Prohibit execution of a specific fs-verity file +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +:: + + policy_name="ProhibitSpecificFSVF" policy_version=0.0.0 + DEFAULT action=DENY + + op=EXECUTE fsverity_digest=fd88f2b8824e197f850bf4c5109bea5cf0ee38104f710843bb72da796ba5af9e action=DENY + op=EXECUTE boot_verified=TRUE action=ALLOW + op=EXECUTE dmverity_signature=TRUE action=ALLOW + +Additional Information +---------------------- + +- `Github Repository `_ +- `Design Documentation `_ + +FAQ +--- + +:Q: What's the difference between other LSMs which provide trust-based + access control, for instance, IMA? + +:A: IMA is a fantastic option when needing measurement in addition to the + trust-based access model. All of IMA is centered around their measurement + hashes, so you save time when doing both actions. IPE, on the other hand, + is a highly performant system that does not rely (and explicitly prohibits), + generating its own integrity mechanisms - separating measurement and access + control. Simply put, IPE provides only the enforcement of trust, while other + subsystems provide the integrity guarantee that IPE needs to determine the + trust of a resource. IMA provides both the integrity guarantee, and the + enforcement of trust. diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt index 43dc35fe5bc0..85dd654e642f 100644 --- a/Documentation/admin-guide/kernel-parameters.txt +++ b/Documentation/admin-guide/kernel-parameters.txt @@ -2096,6 +2096,18 @@ ipcmni_extend [KNL] Extend the maximum number of unique System V IPC identifiers from 32,768 to 16,777,216. + ipe.enforce= [IPE] + Format: + Determine whether IPE starts in permissive (0) or + enforce (1) mode. The default is enforce. + + ipe.success_audit= + [IPE] + Format: + Start IPE with success auditing enabled, emitting + an audit event when a binary is allowed. The default + is 0. + irqaffinity= [SMP] Set the default irq affinity mask The argument is a cpu list, as described above. diff --git a/Documentation/security/index.rst b/Documentation/security/index.rst index 16335de04e8c..c06530b50514 100644 --- a/Documentation/security/index.rst +++ b/Documentation/security/index.rst @@ -17,3 +17,4 @@ Security Documentation tpm/index digsig landlock + ipe diff --git a/Documentation/security/ipe.rst b/Documentation/security/ipe.rst new file mode 100644 index 000000000000..e691e08e0303 --- /dev/null +++ b/Documentation/security/ipe.rst @@ -0,0 +1,339 @@ +.. SPDX-License-Identifier: GPL-2.0 + +Integrity Policy Enforcement (IPE) - Design Documents +===================================================== + +.. NOTE:: + + This is the documentation for kernel developers and other individuals + who want to understand the reason behind why IPE is designed the way it + is, as well as a tour of the implementation. If you're looking for + documentation on the usage of IPE, please see + :ref:`Documentation/admin-guide/LSM/ipe.rst` + +Role and Scope +-------------- + +IPE originally started with a simple goal: create a system that can +ensure that only trusted usermode binaries are allowed to be executed. + +During the design phase it was apparent that there are multiple systems +within the Linux kernel that can provide some level of integrity +verification, and by association, trust for its content: + + 1. DM-Verity + 2. FS-Verity + 3. IMA + EVM + +However, of those systems only the third option has the ability to enforce +trust requirements on the whole system. Its architecture, however is centered +around its own form of verifications, and a multitude of actions surrounding +those verifications with various purposes, the most prominent being measurement +and verification (appraisal). This makes it unsuitable from a layering and +architectural purpose, as IPE's goal is limited to ensure just trusted usermode +binaries are executed, with the intentional goal of supporting multiple methods +from a higher subsystem layer (i.e. fs, block, or super_block). + +The two other options, dm-verity and fs-verity are missing a crucial component +to accomplish the goal of IPE: a policy to indicate the requirements of +answering the question "What is Trusted?" and a system-wide level of enforcing +those requirements. + +Therefore, IPE was designed around: + + 1. Easy configuration of trust mechanisms + 2. Ease of integration with other layers + 3. Ease of use for platform administrators. + +Design Decisions +---------------- + +Policy +~~~~~~ + +Plain Text +^^^^^^^^^^ + +Unlike other LSMs, IPE's policy is plain-text. This introduces slightly larger +policy files than other LSMs, but solves two major problems that occurs with +other trust-based access control systems. + +The first issue is one of code maintenance and duplication. To author policies, +the policy has to be some form of string representation (be it structured, +through XMl, JSON, YAML, etcetera), to allow the policy author to understand +what is being written. In a hypothetical binary policy design, that a serializer +must be written to write said binary form, for a *majority* of humans to be +able to utilize it properly. + +Additionally, a deserializer will eventually be needed to transform the binary +back into text with as much information preserved. Without a deserializer, a +user of this access control system will have to keep a lookup table of either +a checksum, or the file itself to try to understand what policies have been +deployed on this system and what policies have not. For a single user, this +may be alright, as old policies can be discarded almost immediately after +the update takes hold. + +For users that manage fleets in the thousands, if not hundreds of thousands, +this quickly becomes an issue, as stale policies from years ago may be present, +quickly resulting in the need to recover the policy or fund extensive +infrastructure to track what each policy contains. + +Secondly, a serializer is still needed with a plain-text policy (as the plain +text policy still has to be serialized to a data structure in the kernel), so +not much is saved. + +The second issue is one of transparency. As IPE controls access based on trust, +it's policy must also be trusted to be changed. This is done through signatures, +chaining to the SYSTEM_TRUSTED_KEYRING. The confidence of signing a plain-text +policy in which you can see every aspect of what is being signed is a step higher +than signing an opaque binary blob. + +Boot Policy +~~~~~~~~~~~ + +Additionally, IPE shouldn't have any obvious gaps in its enforcement story. +That means, a policy that configures trust requirements, if specified, must +be enforced as soon as the kernel starts up. That can be accomplished one +of three ways: + + 1. The policy file(s) live on disk and the kernel loads the policy prior + to an code path that would result in an enforcement decision. + 2. The policy file(s) are passed by the bootloader to the kernel, who + parses the policy. + 3. There is a policy file that is compiled into the kernel that is + parsed and enforced on initialization. + +The first option has problems: the kernel reading files from userspace +is typically discouraged and very uncommon in the kernel. + +The second option also has problems: Linux supports a variety of bootloaders +across its entire ecosystem - every bootloader would have to support this +new methodology or there must be an independent source. Additionally, it +would likely result in more drastic changes to the kernel startup than +necessary. + +The third option is the best but it's important to be aware that the policy +will take disk space against the kernel it's compiled in. It's important to +keep this policy generalized enough that userspace can load a new, more +complicated policy, but restrictive enough that it will not overauthorize +and cause security issues. + +The initramfs, provides a way that this bootup path can be established. The +kernel starts with a minimal policy, that just trusts the initramfs. Inside +the initramfs, when the real rootfs is mounted, but not yet transferred to, +it deploys and activates a policy that trusts the new root filesystem(s). +This prevents overauthorization at any step, and keeps the kernel policy +to a minimal size. + +Startup +^^^^^^^ + +Not every system, however starts with an initramfs, so the startup policy +compiled into the kernel will need some flexibility to express how trust +is established for the next phase of the bootup. To this end, if we just +make the compiled-in policy a full IPE policy, it allows system builders +to express the first stage bootup requirements appropriately. + +Updatable, Rebootless Policy +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +As time goes on, trust requirements are changed (vulnerabilities are found in +previously trusted applcations, keys roll, etcetera). Updating a kernel to +change the trust requirements is not always a suitable option, as updates +are not always risk-free and without consequence. This means IPE requires +a policy that can be completely updated from a source external to the kernel. + +Additionally, since the kernel is relatively stateless between invocations, +and we've established that reading policy files off the disk from kernel +space is a *bad idea*, then the policy updates have to be done rebootlessly. + +To allow an update from an external source, it could be potentially malicious, +so this policy needs to have a way to be identified as trusted. This will be +done via a signature, chained to a trust source in the kernel. Arbitrarily, +this will be the ``SYSTEM_TRUSTED_KEYRING``, a keyring that is initially +populated at kernel compile-time, as this matches the expectation that the +author of the compiled-in policy described above is the same entity that can +deploy policy updates. + +Anti-Rollback / Anti-Replay +~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Over time, vulnerabilities are found and trusted resources may not be +trusted anymore. IPE's policy has no exception to this. There can be +instances where a mistaken policy author deploys an insecure policy, +before correcting it with a secure policy. + +Assuming that as soon as the insecure policy was signed, an attacker +can acquire the insecure policy, IPE needs a way to prevent rollback +from the secure policy update, to the insecure policy update. + +Initially, IPE's policy can have a policy_version that states the +minimum required version across all policies that can be active on +the system. This will prevent rollback while the system is live. + +.. WARNING:: + + However, since the kernel is stateless across boots, this policy + version will be reset to 0.0.0 on the next boot. System builders + need to be aware of this, and ensure the new secure policies are + deployed ASAP after a boot to ensure that the window of + opportunity is minimal for an attacker to deploy the insecure policy[#]_. + +Implementation +-------------- + +Context +~~~~~~~ + +An ``ipe_context`` structure represent a context in which IPE can be enforced. +It contains all the typical values that one would expect are global: + + 1. Enforce/Permissive State + 2. Active Policy + 3. List of Policies + 4. Success Auditing State + +A context is created at boot time and attached to the ``task_struct`` as a +security blob. All new ``task_struct`` will inherit the original ``ipe_context`` +that the system boots with. This structure is reference counted. + +Initially, a system will only ever have one context; for ``init``, and since +all userspace processes are descendents of ``init``, all of usermode will have +this execution context. + +This architecture has some advantages - namely, it allows for a natural +extension for IPE to create new contexts - such as applying a different +policy for trust for a privledged container from that of its host. + +Anonymous Memory +~~~~~~~~~~~~~~~~ + +Anonymous memory isn't treated any differently than any other access in IPE. +When anonymous memory is mapped with ``+X``, it still comes into the ``file_mmap`` +hook, but with a ``NULL`` file object. This is submitted to the evaluation, like +any other file, however, all trust mechanisms will return false as there is +nothing to evaluate. This means anonymous memory execution is subject to +whatever the ``DEFAULT`` is for ``EXECUTE``. + +.. WARNING:: + + This also occurs with the ``kernel_load_data`` hook, which is used by signed + and compressed kernel modules. Using this with IPE will result in the + ``DEFAULT`` for ``KMODULE`` being taken. + +Policy Parser +~~~~~~~~~~~~~ + +The policy parser is the staple of IPE's functionality, providing a +modular way to introduce new integrations. As such, it's functionality +is divided into 4 passes. This gives the benefit of clearly defined pre +and post-condition states after each pass, giving debugging benefits +when something goes wrong. + +In pass1, the policy is transformed into a 2D, jagged, array of tokens, +where a token is defined as a "key=value" pair, or a singular token, +for example, "DEFAULT". Quoted values are parsed as a single value-pair, +which is why ```` parser is insufficient - it does not +understand quoted values. + +In pass2, the jagged array produced in pass1 is partially ingested, +creating a partially populated policy, where no rules have been parsed +yet, but metadata and references are created that can be now used in +pass3. + +Examples of parsing that would be done in pass2:: + + policy_name="my-policy" policy_version=0.0.0 + DEFAULT action=DENY + +As these lines are not rules in of themselves, but effect the policy +itself. + +In pass3, the remaining lines in the jagged array produced in pass1 and +partially-consumed in pass2 is consumed completely, parsing all the +rules in IPE policy. This can leverage the data used in pass2. +Example lines parsed in pass3:: + + op=EXECUTE dmverity_signature=TRUE action=DENY + +A rule is strictly defined as starts with the op token and ends with +the action token. + +After this pass, a policy is deemed fully constructed but not yet valid, +as there could be missing elements (such as a required DEFAULT for all +actions, missing a policy_name), etc. + +Additionally, as IPE policy supports operation aliases (an operation +that maps to two or more other operations), support is added here. + +The purpose in the division of pass2 and pass3 is to allow for +declarations in IPE's syntax. For example, in the future, if we were +to introduce this syntax:: + + CERTIFICATE=FakeCert thumbprint=DEADBEEF CN="Contoso" + +And use it like so:: + + op=EXECUTE dmverity_signature=FakeCert action=ALLOW + +The ``CERTIFICATE`` lines can be grouped together at any place in the policy. + +After pass3, an IPE policy can still be technically invalid for use, as +a policy can be lacking required elements to eliminated the possibility +of undefined or unknown behavior. + +A concrete example is when a policy does not define a default action for +all possibilities:: + + DEFAULT op=EXECUTE action=ALLOW + +At this point, while a technically syntactically and semantically valid +policy, it does not contain enough information to determine what should +be done for an operation other than "EXECUTE". As IPE's design +explicitly prohibits the implicit setting of a DEFAULT, it is important +for cases like these are prevented from occurring. + +To resolve all these cases, a final check on the policy is done to ensure +it valid for use. + +In all cases, the parser is the number one bottleneck when it comes to +IPE's performance, but has the benefit of happening rarely, and as a +direct consequence of user-input. + +Module vs Parser +~~~~~~~~~~~~~~~~ + +A "module", "trust provider", or "property" as defined in IPE's code and +commits is an integration with an external subsystem that provides a way +to identify a resource as trusted. It's the code that powers the key=value +pairs in between the ``op`` token and the ``action`` token. These are called +in pass3 when parsing a policy (via the ``parse`` method), and during +evaluation when evaluating a access attempt (via the ``eval`` method). These +discrete modules are single files in ``security/ipe/modules`` and are +versioned independently. The documentation in the admin guide and be used +to cross reference what version supports what syntax. + +A "parser", on the other hand is a discrete unit of code that is *only* +used when parsing a policy in pass2. The intention is to make it easy +to introduce statements, like the ``DEFAULT`` statement:: + + DEFAULT op=EXECUTE action=ALLOW + DEFAULT action=ALLOW + +or, the policy header:: + + policy_name="MyPolicy" policy_version=0.0.0 + +These individual fragments of code, as such, gain access to manipulating +IPE's policy structure directly, as opposed to the opaque ``void *`` that +modules get. + +.. [#] This is something we're interested in solving, using some + persistent storage + +Tests +~~~~~ + +IPE initially has KUnit Tests, testing primarily the parser and the context +structures. A majority of these are table-based testing, please contribute +to them, especially when adding new properties. diff --git a/MAINTAINERS b/MAINTAINERS index a84ca781199b..909db5ba6f87 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -9283,6 +9283,8 @@ INTEGRITY POLICY ENFORCEMENT (IPE) M: Deven Bowers M: Fan Wu S: Supported +F: Documentation/admin-guide/LSM/ipe.rst +F: Documentation/security/ipe.rst F: scripts/ipe/ F: security/ipe/ -- 2.33.0 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 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 08ED0C433F5 for ; Wed, 13 Oct 2021 19:17:23 +0000 (UTC) Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) (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 82DDF61181 for ; Wed, 13 Oct 2021 19:17:22 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.1 mail.kernel.org 82DDF61181 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.microsoft.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=redhat.com Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-51-dU7z1IeuOECupUxCPMT9EA-1; Wed, 13 Oct 2021 15:17:16 -0400 X-MC-Unique: dU7z1IeuOECupUxCPMT9EA-1 Received: from smtp.corp.redhat.com (int-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.12]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 6BCA318D6A33; Wed, 13 Oct 2021 19:17:10 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.21]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 4EAE960CA1; Wed, 13 Oct 2021 19:17:10 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id 1BA0E4EA37; Wed, 13 Oct 2021 19:17:10 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx05.intmail.prod.int.rdu2.redhat.com [10.11.54.5]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id 19DJD6XV018829 for ; Wed, 13 Oct 2021 15:13:06 -0400 Received: by smtp.corp.redhat.com (Postfix) id 29B416B5BF; Wed, 13 Oct 2021 19:13:06 +0000 (UTC) Received: from mimecast-mx02.redhat.com (mimecast05.extmail.prod.ext.rdu2.redhat.com [10.11.55.21]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 2261D6B5B8 for ; Wed, 13 Oct 2021 19:13:00 +0000 (UTC) Received: from us-smtp-1.mimecast.com (us-smtp-2.mimecast.com [207.211.31.81]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 98DE8802E5E for ; Wed, 13 Oct 2021 19:13:00 +0000 (UTC) Received: from linux.microsoft.com (linux.microsoft.com [13.77.154.182]) by relay.mimecast.com with ESMTP id us-mta-547-UCvsE51aNuagaLSNFHbfbQ-1; Wed, 13 Oct 2021 15:12:56 -0400 X-MC-Unique: UCvsE51aNuagaLSNFHbfbQ-1 Received: from linuxonhyperv3.guj3yctzbm1etfxqx2vob5hsef.xx.internal.cloudapp.net (linux.microsoft.com [13.77.154.182]) by linux.microsoft.com (Postfix) with ESMTPSA id C6F4820B9D0C; Wed, 13 Oct 2021 12:06:40 -0700 (PDT) DKIM-Filter: OpenDKIM Filter v2.11.0 linux.microsoft.com C6F4820B9D0C From: deven.desai@linux.microsoft.com To: corbet@lwn.net, axboe@kernel.dk, agk@redhat.com, snitzer@redhat.com, ebiggers@kernel.org, tytso@mit.edu, paul@paul-moore.com, eparis@redhat.com, jmorris@namei.org, serge@hallyn.com Date: Wed, 13 Oct 2021 12:06:35 -0700 Message-Id: <1634151995-16266-17-git-send-email-deven.desai@linux.microsoft.com> In-Reply-To: <1634151995-16266-1-git-send-email-deven.desai@linux.microsoft.com> References: <1634151995-16266-1-git-send-email-deven.desai@linux.microsoft.com> MIME-Version: 1.0 X-Mimecast-Impersonation-Protect: Policy=CLT - Impersonation Protection Definition; Similar Internal Domain=false; Similar Monitored External Domain=false; Custom External Domain=false; Mimecast External Domain=false; Newly Observed Domain=false; Internal User Name=false; Custom Display Name List=false; Reply-to Address Mismatch=false; Targeted Threat Dictionary=false; Mimecast Threat Dictionary=false; Custom Threat Dictionary=false X-Scanned-By: MIMEDefang 2.79 on 10.11.54.5 X-MIME-Autoconverted: from quoted-printable to 8bit by lists01.pubmisc.prod.ext.phx2.redhat.com id 19DJD6XV018829 X-loop: dm-devel@redhat.com Cc: linux-security-module@vger.kernel.org, linux-doc@vger.kernel.org, jannh@google.com, linux-fscrypt@vger.kernel.org, linux-kernel@vger.kernel.org, linux-block@vger.kernel.org, dm-devel@redhat.com, linux-audit@redhat.com Subject: [dm-devel] [RFC PATCH v7 16/16] documentation: add ipe documentation X-BeenThere: dm-devel@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: device-mapper development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: dm-devel-bounces@redhat.com Errors-To: dm-devel-bounces@redhat.com X-Scanned-By: MIMEDefang 2.79 on 10.5.11.12 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=dm-devel-bounces@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 RnJvbTogRGV2ZW4gQm93ZXJzIDxkZXZlbi5kZXNhaUBsaW51eC5taWNyb3NvZnQuY29tPgoKQWRk IElQRSdzIGFkbWluIGFuZCBkZXZlbG9wZXIgZG9jdW1lbnRhdGlvbiB0byB0aGUga2VybmVsIHRy ZWUuCgpDby1kZXZlbG9wZWQtYnk6IEZhbiBXdSA8d3VmYW5AbGludXgubWljcm9zb2Z0LmNvbT4K U2lnbmVkLW9mZi1ieTogRmFuIFd1IDx3dWZhbkBsaW51eC5taWNyb3NvZnQuY29tPgpTaWduZWQt b2ZmLWJ5OiBEZXZlbiBCb3dlcnMgPGRldmVuLmRlc2FpQGxpbnV4Lm1pY3Jvc29mdC5jb20+Ci0t LQoKUmVsZXZhbnQgY2hhbmdlcyBzaW5jZSB2NjoKICAqIEFkZCBhZGRpdGlvbmFsIGRldmVsb3Bl ci1sZXZlbCBkb2N1bWVudGF0aW9uCiAgKiBVcGRhdGUgYWRtaW4tZ3VpZGUgZG9jcyB0byByZWZs ZWN0IGNoYW5nZXMuCiAgKiBEcm9wIEFja2VkLWJ5IGR1ZSB0byBzaWduaWZpY2FudCBjaGFuZ2Vz CgotLS0KIERvY3VtZW50YXRpb24vYWRtaW4tZ3VpZGUvTFNNL2luZGV4LnJzdCAgICAgICB8ICAg MSArCiBEb2N1bWVudGF0aW9uL2FkbWluLWd1aWRlL0xTTS9pcGUucnN0ICAgICAgICAgfCA1ODcg KysrKysrKysrKysrKysrKysrCiAuLi4vYWRtaW4tZ3VpZGUva2VybmVsLXBhcmFtZXRlcnMudHh0 ICAgICAgICAgfCAgMTIgKwogRG9jdW1lbnRhdGlvbi9zZWN1cml0eS9pbmRleC5yc3QgICAgICAg ICAgICAgIHwgICAxICsKIERvY3VtZW50YXRpb24vc2VjdXJpdHkvaXBlLnJzdCAgICAgICAgICAg ICAgICB8IDMzOSArKysrKysrKysrCiBNQUlOVEFJTkVSUyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgfCAgIDIgKwogNiBmaWxlcyBjaGFuZ2VkLCA5NDIgaW5zZXJ0aW9ucygrKQog Y3JlYXRlIG1vZGUgMTAwNjQ0IERvY3VtZW50YXRpb24vYWRtaW4tZ3VpZGUvTFNNL2lwZS5yc3QK IGNyZWF0ZSBtb2RlIDEwMDY0NCBEb2N1bWVudGF0aW9uL3NlY3VyaXR5L2lwZS5yc3QKCmRpZmYg LS1naXQgYS9Eb2N1bWVudGF0aW9uL2FkbWluLWd1aWRlL0xTTS9pbmRleC5yc3QgYi9Eb2N1bWVu dGF0aW9uL2FkbWluLWd1aWRlL0xTTS9pbmRleC5yc3QKaW5kZXggYTZiYTk1ZmJhYTlmLi5jZTYz YmU2ZDY0YWQgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vYWRtaW4tZ3VpZGUvTFNNL2luZGV4 LnJzdAorKysgYi9Eb2N1bWVudGF0aW9uL2FkbWluLWd1aWRlL0xTTS9pbmRleC5yc3QKQEAgLTQ3 LDMgKzQ3LDQgQEAgc3ViZGlyZWN0b3JpZXMuCiAgICB0b21veW8KICAgIFlhbWEKICAgIFNhZmVT ZXRJRAorICAgaXBlCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2FkbWluLWd1aWRlL0xTTS9p cGUucnN0IGIvRG9jdW1lbnRhdGlvbi9hZG1pbi1ndWlkZS9MU00vaXBlLnJzdApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjU2YTlmYTJmZTU5YgotLS0gL2Rldi9udWxs CisrKyBiL0RvY3VtZW50YXRpb24vYWRtaW4tZ3VpZGUvTFNNL2lwZS5yc3QKQEAgLTAsMCArMSw1 ODcgQEAKKy4uIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCisKK0ludGVncml0eSBQ b2xpY3kgRW5mb3JjZW1lbnQgKElQRSkKKz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KKworLi4gTk9URTo6CisKKyAgIFRoaXMgaXMgdGhlIGRvY3VtZW50YXRpb24gZm9yIGFkbWlu cywgc3lzdGVtIGJ1aWxkZXJzLCBvciBpbmRpdmlkdWFscworICAgYXR0ZW1wdGluZyB0byB1c2Ug SVBFLCB3aXRob3V0IHVuZGVyc3RhbmRpbmcgYWxsIG9mIGl0cyBpbnRlcm5hbCBzeXN0ZW1zLgor ICAgSWYgeW91J3JlIGxvb2tpbmcgZm9yIGRvY3VtZW50YXRpb24gdG8gZXh0ZW5kIElQRSwgdW5k ZXJzdGFuZCB0aGUgZGVzaWduCisgICBkZWNpc2lvbnMgYmVoaW5kIElQRSwgb3IgYXJlIGp1c3Qg Y3VyaW91cyBhYm91dCB0aGUgaW50ZXJuYWxzLCBwbGVhc2UKKyAgIHNlZSA6cmVmOmBEb2N1bWVu dGF0aW9uL3NlY3VyaXR5L2lwZS5yc3RgCisKK092ZXJ2aWV3CistLS0tLS0tLQorCitJUEUgaXMg YSBMaW51eCBTZWN1cml0eSBNb2R1bGUgd2hpY2ggaW1wb3NlcyBhIGNvbXBsaW1lbnRhcnkgbW9k ZWwKK29mIG1hbmRhdG9yeSBhY2Nlc3MgY29udHJvbCB0byBvdGhlciBMU01zLiBXaGVyZWFzIHRo ZSBleGlzdGluZyBMU01zCitpbXBvc2UgYWNjZXNzIGNvbnRyb2wgYmFzZWQgb24gbGFiZWxzIG9y IHBhdGhzLCBJUEUgaW1wb3NlcyBhY2Nlc3MKK2NvbnRyb2wgYmFzZWQgb24gdGhlIHRydXN0IG9m IHRoZSByZXNvdXJjZS4gU2ltcGx5IHB1dCwgSVBFCitvciByZXN0cmljdHMgYWNjZXNzIHRvIGEg cmVzb3VyY2UgYmFzZWQgb24gdGhlIHRydXN0IG9mIHNhaWQgcmVzb3VyY2UuCisKK1RydXN0IHJl cXVpcmVtZW50cyBhcmUgZXN0YWJsaXNoZWQgdmlhIElQRSdzIHBvbGljeSwgc291cmNpbmcgbXVs dGlwbGUKK2RpZmZlcmVudCBpbXBsZW1lbnRhdGlvbnMgd2l0aGluIHRoZSBrZXJuZWwgdG8gYnVp bGQgYSBjb2hlc2l2ZSB0cnVzdAorbW9kZWwsIGJhc2VkIG9uIGhvdyB0aGUgc3lzdGVtIHdhcyBi dWlsdC4KKworVHJ1c3QgdnMgSW50ZWdyaXR5CistLS0tLS0tLS0tLS0tLS0tLS0KKworVHJ1c3Qs IHdpdGggcmVzcGVjdCB0byBjb21wdXRpbmcsIGlzIGEgY29uY2VwdCB0aGF0IGRlc2lnbmF0ZXMg YSBzZXQKK29mIGVudGl0aWVzIHdobyB3aWxsIGVuZG9yc2UgYSBzZXQgb2YgcmVzb3VyY2VzIGFz IG5vbi1tYWxpY2lvdXMuCitUcmFkaXRpb25hbGx5LCB0aGlzIGlzIGRvbmUgdmlhIHNpZ25hdHVy ZXMsIHdoaWNoIGlzIHRoZSBhY3Qgb2YgZW5kb3JzaW5nCithIHJlc291cmNlLiBJbnRlZ3JpdHks IG9uIHRoZSBvdGhlciBoYW5kLCBpcyB0aGUgY29uY2VwdCBvZiBlbnN1cmluZyB0aGF0IGEKK3Jl c291cmNlIGhhcyBub3QgYmVlbiBtb2RpZmllZCBzaW5jZSBhIHBvaW50IG9mIHRpbWUuIFRoaXMg aXMgdHlwaWNhbGx5IGRvbmUKK3Rocm91Z2ggY3J5cHRvZ3JhcGh5IG9yIHNpZ25hdHVyZXMuCisK K1RydXN0IGFuZCBpbnRlZ3JpdHkgYXJlIHZlcnkgY2xvc2VseSB0aWVkIHRvZ2V0aGVyIGNvbmNl cHRzLCBhcyBpbnRlZ3JpdHkKK2lzIHRoZSB3YXkgeW91IGNhbiBwcm92ZSB0cnVzdCBmb3IgYSBy ZXNvdXJjZTsgb3RoZXJ3aXNlIGl0IGNvdWxkIGhhdmUKK2JlZW4gbW9kaWZpZWQgYnkgYW4gZW50 aXR5IHdobyBpcyB1bnRydXN0ZWQuCisKK0lQRSBwcm92aWRlcyBhIHdheSBmb3IgYSB1c2VyIHRv IGV4cHJlc3MgdHJ1c3Qgb2YgcmVzb3VyY2VzLCBieSB1c2luZworcHJlLWV4aXN0aW5nIHN5c3Rl bXMgd2hpY2ggcHJvdmlkZSB0aGUgaW50ZWdyaXR5IGhhbGYgb2YgdGhlIGVxdWF0aW9uLgorCitV c2UgQ2FzZXMKKy0tLS0tLS0tLQorCitJUEUgd29ya3MgYmVzdCBpbiBmaXhlZC1mdW5jdGlvbiBk ZXZpY2VzOiBEZXZpY2VzIGluIHdoaWNoIHRoZWlyIHB1cnBvc2UKK2lzIGNsZWFybHkgZGVmaW5l ZCBhbmQgbm90IHN1cHBvc2VkIHRvIGJlIGNoYW5nZWQgKGUuZy4gbmV0d29yayBmaXJld2FsbAor ZGV2aWNlIGluIGEgZGF0YSBjZW50ZXIsIGFuIElvVCBkZXZpY2UsIGV0Y2V0ZXJhKSwgd2hlcmUg YWxsIHNvZnR3YXJlIGFuZAorY29uZmlndXJhdGlvbiBpcyBidWlsdCBhbmQgcHJvdmlzaW9uZWQg YnkgdGhlIHN5c3RlbSBvd25lci4KKworSVBFIGlzIGEgbG9uZy13YXkgb2ZmIGZvciB1c2UgaW4g Z2VuZXJhbC1wdXJwb3NlIGNvbXB1dGluZzoKK3RoZSBMaW51eCBjb21tdW5pdHkgYXMgYSB3aG9s ZSB0ZW5kcyB0byBmb2xsb3cgYSBkZWNlbnRyYWxpemVkIHRydXN0Cittb2RlbCwga25vd24gYXMg dGhlIFdlYiBvZiBUcnVzdCwgd2hpY2ggSVBFIGhhcyBubyBzdXBwb3J0IGZvciBhcyBvZiB5ZXQu CitJbnN0ZWFkLCBJUEUgc3VwcG9ydHMgdGhlIFBLSSBUcnVzdCBNb2RlbCwgd2hpY2ggZ2VuZXJh bGx5IGRlc2lnbmF0ZXMgYQorc2V0IG9mIGVudGl0aWVzIHRoYXQgcHJvdmlkZSBhIG1lYXN1cmUg YWJzb2x1dGUgdHJ1c3QuCisKK0FkZGl0aW9uYWxseSwgd2hpbGUgbW9zdCBwYWNrYWdlcyBhcmUg c2lnbmVkIHRvZGF5LCB0aGUgZmlsZXMgaW5zaWRlCit0aGUgcGFja2FnZXMgKGZvciBpbnN0YW5j ZSwgdGhlIGV4ZWN1dGFibGVzKSwgdGVuZCB0byBiZSB1bnNpZ25lZC4gVGhpcworbWFrZXMgaXQg ZGlmZmljdWx0IHRvIHV0aWxpemUgSVBFIGluIHN5c3RlbXMgd2hlcmUgYSBwYWNrYWdlIG1hbmFn ZXIgaXMKK2V4cGVjdGVkIHRvIGJlIGZ1bmN0aW9uYWwsIHdpdGhvdXQgbWFqb3IgY2hhbmdlcyB0 byB0aGUgcGFja2FnZSBtYW5hZ2VyCithbmQgZWNvc3lzdGVtIGJlaGluZCBpdC4KKworRm9yIHRo ZSBoaWdoZXN0IGxldmVsIG9mIHNlY3VyaXR5LCBwbGF0Zm9ybSBmaXJtd2FyZSBzaG91bGQgdmVy aWZ5IHRoZQordGhlIGtlcm5lbCBhbmQgb3B0aW9uYWxseSB0aGUgcm9vdCBmaWxlc3lzdGVtIChm b3IgZXhhbXBsZSwgdmlhIFUtQm9vdAordmVyaWZpZWQgYm9vdCkuIFRoaXMgZm9ybXMgYSBjaGFp biBvZiB0cnVzdCBmcm9tIHRoZSBoYXJkd2FyZSwgZW5zdXJpbmcKK3RoYXQgZXZlcnkgc3RhZ2Ug b2YgdGhlIHN5c3RlbSBpcyB0cnVzdGVkLgorCitLbm93biBHYXBzCistLS0tLS0tLS0tCisKK0lQ RSBjYW5ub3QgdmVyaWZ5IHRoZSBpbnRlZ3JpdHkgb2YgYW5vbnltb3VzIGV4ZWN1dGFibGUgbWVt b3J5LCBzdWNoIGFzCit0aGUgdHJhbXBvbGluZXMgY3JlYXRlZCBieSBnY2MgY2xvc3VyZXMgYW5k IGxpYmZmaSAoPDMuNC4yKSwgb3IgSklUJ2QgY29kZS4KK1VuZm9ydHVuYXRlbHksIGFzIHRoaXMg aXMgZHluYW1pY2FsbHkgZ2VuZXJhdGVkIGNvZGUsIHRoZXJlIGlzIG5vIHdheQorZm9yIElQRSB0 byBlbnN1cmUgdGhlIGludGVncml0eSBvZiB0aGlzIGNvZGUgdG8gZm9ybSBhIHRydXN0IGJhc2lz LiBJbiBhbGwKK2Nhc2VzLCB0aGUgcmV0dXJuIHJlc3VsdCBmb3IgdGhlc2Ugb3BlcmF0aW9ucyB3 aWxsIGJlIHdoYXRldmVyIHRoZSBhZG1pbgorY29uZmlndXJlcyB0aGUgREVGQVVMVCBhY3Rpb24g Zm9yICJFWEVDVVRFIi4KKworSVBFIGNhbm5vdCB2ZXJpZnkgdGhlIGludGVncml0eSBvZiBpbnRl cnByZXRlZCBsYW5ndWFnZXMnIHByb2dyYW1zIHdoZW4KK3RoZXNlIHNjcmlwdHMgaW52b2tlZCB2 aWEgYGA8aW50ZXJwcmV0ZXI+IDxmaWxlPmBgLiBUaGlzIGlzIGJlY2F1c2UgdGhlCit3YXkgaW50 ZXJwcmV0ZXJzIGV4ZWN1dGUgdGhlc2UgZmlsZXMsIHRoZSBzY3JpcHRzIHRoZW1zZWx2ZXMgYXJl IG5vdAorZXZhbHVhdGVkIGFzIGV4ZWN1dGFibGUgY29kZSB0aHJvdWdoIG9uZSBvZiBJUEUncyBo b29rcy4gSW50ZXJwcmV0ZXJzCitjYW4gYmUgZW5saWdodGVuZWQgdG8gdGhlIHVzYWdlIG9mIElQ RSBieSB0cnlpbmcgdG8gbW1hcCBhIGZpbGUgaW50bworZXhlY3V0YWJsZSBtZW1vcnkgKCtYKSwg YWZ0ZXIgb3BlbmluZyB0aGUgZmlsZSBhbmQgcmVzcG9uZGluZyB0byB0aGUKK2Vycm9yIGNvZGUg YXBwcm9wcmlhdGVseS4gVGhpcyBhbHNvIGFwcGxpZXMgdG8gaW5jbHVkZWQgZmlsZXMsIG9yIGhp Z2gKK3ZhbHVlIGZpbGVzLCBzdWNoIGFzIGNvbmZpZ3VyYXRpb24gZmlsZXMgb2YgY3JpdGljYWwg c3lzdGVtIGNvbXBvbmVudHMgWyNdXy4KKworLi4gWyNdIE1pY2thw6tsIFNhbGHDvG4ncyBgdHJ1 c3RlZF9mb3IgcGF0Y2hzZXQgPGh0dHBzOi8vbG9yZS5rZXJuZWwub3JnL2FsbC8yMDIxMTAwODEw NDg0MC4xNzMzMzg1LTEtbWljQGRpZ2lrb2QubmV0Lz5gXworICAgY2FuIGJlIHVzZWQgdG8gbGV2 ZXJhZ2UgdGhpcy4KKworVGhyZWF0IE1vZGVsCistLS0tLS0tLS0tLS0KKworVGhlIHRocmVhdCB0 eXBlIGFkZHJlc3NlZCBieSBJUEUgaXMgdGFtcGVyaW5nIG9mIGV4ZWN1dGFibGUgdXNlci1sYW5k Citjb2RlIGJleW9uZCB0aGUgaW5pdGlhbGx5IGJvb3RlZCBrZXJuZWwsIGFuZCB0aGUgaW5pdGlh bCB2ZXJpZmljYXRpb24gb2YKK2tlcm5lbCBtb2R1bGVzIHRoYXQgYXJlIGxvYWRlZCBpbiB1c2Vy bGFuZCB0aHJvdWdoIGBgbW9kcHJvYmVgYCBvcgorYGBpbnNtb2RgYC4KKworVGFtcGVyaW5nIHZp b2xhdGVzIGludGVncml0eSwgYW5kIGJlaW5nIHVuYWJsZSB0byB2ZXJpZnkgdGhlIGludGVncml0 eSwKK3Jlc3VsdHMgaW4gYSBsYWNrIG9mIHRydXN0LiBJUEUncyByb2xlIGluIG1pdGlnYXRpbmcg dGhpcyB0aHJlYXQgaXMgdG8KK3ZlcmlmeSB0aGUgaW50ZWdyaXR5IChhbmQgYXV0aGVudGljaXR5 KSBvZiBhbGwgZXhlY3V0YWJsZSBjb2RlIGFuZCB0bworZGVueSB0aGVpciB1c2UgaWYgdGhleSBj YW5ub3QgYmUgdHJ1c3RlZCAoYXMgaW50ZWdyaXR5IHZlcmlmaWNhdGlvbiBmYWlscykuCitJUEUg Z2VuZXJhdGVzIGF1ZGl0IGxvZ3Mgd2hpY2ggbWF5IGJlIHV0aWxpemVkIHRvIGRldGVjdCBmYWls dXJlcyByZXN1bHRpbmcKK2Zyb20gZmFpbHVyZSB0byBwYXNzIHBvbGljeS4KKworVGFtcGVyaW5n IHRocmVhdCBzY2VuYXJpb3MgaW5jbHVkZSBtb2RpZmljYXRpb24gb3IgcmVwbGFjZW1lbnQgb2YK K2V4ZWN1dGFibGUgY29kZSBieSBhIHJhbmdlIG9mIGFjdG9ycyBpbmNsdWRpbmc6CisKKy0gIEFj dG9ycyB3aXRoIHBoeXNpY2FsIGFjY2VzcyB0byB0aGUgaGFyZHdhcmUKKy0gIEFjdG9ycyB3aXRo IGxvY2FsIG5ldHdvcmsgYWNjZXNzIHRvIHRoZSBzeXN0ZW0KKy0gIEFjdG9ycyB3aXRoIGFjY2Vz cyB0byB0aGUgZGVwbG95bWVudCBzeXN0ZW0KKy0gIENvbXByb21pc2VkIGludGVybmFsIHN5c3Rl bXMgdW5kZXIgZXh0ZXJuYWwgY29udHJvbAorLSAgTWFsaWNpb3VzIGVuZCB1c2VycyBvZiB0aGUg c3lzdGVtCistICBDb21wcm9taXNlZCBlbmQgdXNlcnMgb2YgdGhlIHN5c3RlbQorLSAgUmVtb3Rl IChleHRlcm5hbCkgY29tcHJvbWlzZSBvZiB0aGUgc3lzdGVtCisKK0lQRSBkb2VzIG5vdCBtaXRp Z2F0ZSB0aHJlYXRzIGFyaXNpbmcgZnJvbSBtYWxpY2lvdXMgYXV0aG9yaXplZAorZGV2ZWxvcGVy cywgb3IgY29tcHJvbWlzZWQgZGV2ZWxvcGVyIHRvb2xzIHVzZWQgYnkgYXV0aG9yaXplZAorZGV2 ZWxvcGVycy4gQWRkaXRpb25hbGx5LCBJUEUgZHJhd3MgaGFyZCBzZWN1cml0eSBib3VuZGFyeSBi ZXR3ZWVuIHVzZXIKK21vZGUgYW5kIGtlcm5lbCBtb2RlLiBBcyBhIHJlc3VsdCwgSVBFIGRvZXMg bm90IHByb3ZpZGUgYW55IHByb3RlY3Rpb25zCithZ2FpbnN0IGEga2VybmVsIGxldmVsIGV4cGxv aXQsIGFuZCBhIGtlcm5lbC1sZXZlbCBleHBsb2l0IGNhbiBkaXNhYmxlCitvciB0YW1wZXIgd2l0 aCBJUEUncyBwcm90ZWN0aW9ucy4KKworUG9saWN5CistLS0tLS0KKworSVBFIHBvbGljeSBpcyBh IHBsYWluLXRleHQgWyNdXyBwb2xpY3kgY29tcG9zZWQgb2YgbXVsdGlwbGUgc3RhdGVtZW50cwor b3ZlciBzZXZlcmFsIGxpbmVzLiBUaGVyZSBpcyBvbmUgcmVxdWlyZWQgbGluZSwgYXQgdGhlIHRv cCBvZiB0aGUKK3BvbGljeSwgaW5kaWNhdGluZyB0aGUgcG9saWN5IG5hbWUsIGFuZCB0aGUgcG9s aWN5IHZlcnNpb24sIGZvcgoraW5zdGFuY2U6OgorCisgICBwb2xpY3lfbmFtZT0iRXggUG9saWN5 IiBwb2xpY3lfdmVyc2lvbj0wLjAuMAorCitUaGUgcG9saWN5IG5hbWUgaXMgYSB1bmlxdWUga2V5 IGlkZW50aWZ5aW5nIHRoaXMgcG9saWN5IGluIGEgaHVtYW4KK3JlYWRhYmxlIG5hbWUuIFRoaXMg aXMgdXNlZCB0byBjcmVhdGUgbm9kZXMgdW5kZXIgc2VjdXJpdHlmcyBhcyB3ZWxsIGFzCit1bmlx dWVseSBpZGVudGlmeSBwb2xpY2llcyB0byBkZXBsb3kgbmV3IHBvbGljaWVzIHZzIHVwZGF0ZSBl eGlzdGluZworcG9saWNpZXMuCisKK1RoZSBwb2xpY3kgdmVyc2lvbiBpbmRpY2F0ZXMgdGhlIGN1 cnJlbnQgdmVyc2lvbiBvZiB0aGUgcG9saWN5IChOT1QgdGhlCitwb2xpY3kgc3ludGF4IHZlcnNp b24pLiBUaGlzIGlzIHVzZWQgdG8gcHJldmVudCByb2xsYmFjayBvZiBwb2xpY3kgdG8KK3BvdGVu dGlhbGx5IGluc2VjdXJlIHByZXZpb3VzIHZlcnNpb25zIG9mIHRoZSBwb2xpY3kuCisKK1RoZSBu ZXh0IHBvcnRpb24gb2YgSVBFIHBvbGljeSwgYXJlIHJ1bGVzLiBSdWxlcyBhcmUgZm9ybWVkIGJ5 IGtleT12YWx1ZQorcGFpcnMsIGtub3duIGFzIHByb3BlcnRpZXMuIElQRSBydWxlcyByZXF1aXJl IHR3byBwcm9wZXJ0aWVzOiAiYWN0aW9uIiwKK3doaWNoIGRldGVybWluZXMgd2hhdCBJUEUgZG9l cyB3aGVuIGl0IGVuY291bnRlcnMgYSBtYXRjaCBhZ2FpbnN0IHRoZQorcnVsZSwgYW5kICJvcCIs IHdoaWNoIGRldGVybWluZXMgd2hlbiB0aGF0IHJ1bGUgc2hvdWxkIGJlIGV2YWx1YXRlZC4KK1Ro ZSBvcmRlcmluZyBpcyBzaWduaWZpY2FudCwgYSBydWxlIG11c3Qgc3RhcnQgd2l0aCAib3AiLCBh bmQgZW5kIHdpdGgKKyJhY3Rpb24iLiBUaHVzLCBhIG1pbmltYWwgcnVsZSBpczo6CisKKyAgIG9w PUVYRUNVVEUgYWN0aW9uPUFMTE9XCisKK1RoaXMgZXhhbXBsZSB3aWxsIGFsbG93IGFueSBleGVj dXRpb24uIEFkZGl0aW9uYWwgcHJvcGVydGllcyBhcmUgdXNlZCB0bworcmVzdHJpY3QgYXR0cmli dXRlcyBhYm91dCB0aGUgZmlsZXMgYmVpbmcgZXZhbHVhdGVkLiBUaGVzZSBwcm9wZXJ0aWVzCith cmUgaW50ZW5kZWQgdG8gYmUgZGVzY3JpcHRpb25zIG9mIHN5c3RlbXMgd2l0aGluIHRoZSBrZXJu ZWwsIHRoYXQgY2FuCitwcm92aWRlIGEgbWVhc3VyZSBvZiBpbnRlZ3JpdHkgdmVyaWZpY2F0aW9u LCBzdWNoIHRoYXQgSVBFIGNhbiBkZXRlcm1pbmUKK3RoZSB0cnVzdCBvZiB0aGUgcmVzb3VyY2Ug YmFzZWQgb24gdGhlICJ2YWx1ZSIgaGFsZiBvZiB0aGUgcHJvcGVydHkuCisKK1J1bGVzIGFyZSBl dmFsdWF0ZWQgdG9wLXRvLWJvdHRvbS4gQXMgYSByZXN1bHQsIGFueSByZXZvY2F0aW9uIHJ1bGVz LAorb3IgZGVuaWVzIHNob3VsZCBiZSBwbGFjZWQgZWFybHkgaW4gdGhlIGZpbGUgdG8gZW5zdXJl IHRoYXQgdGhlc2UgcnVsZXMKK2FyZSBldmFsdWF0ZWQgYmVmb3JlIGFzIHJ1bGUgd2l0aCAiYWN0 aW9uPUFMTE9XIiBpcyBoaXQuCisKK0lQRSBwb2xpY3kgaXMgZGVzaWduZWQgdG8gYmUgb25seSBm b3J3YXJkIGNvbXBhdGlibGUuIFVzZXJzcGFjZSBjYW4gcmVhZAord2hhdCB0aGUgcGFyc2VyJ3Mg Y3VycmVudCBjb25maWd1cmF0aW9uIChzdXBwb3J0ZWQgc3RhdGVtZW50cywgcHJvcGVydGllcywK K2V0Y2V0ZXJhKSB2aWEgcmVhZGluZyB0aGUgc2VjdXJpdHlmcyBlbnRyeSwgJ2lwZS9jb25maWcn CisKK0lQRSBwb2xpY3kgc3VwcG9ydHMgY29tbWVudHMuIFRoZSBjaGFyYWN0ZXIgJyMnIHdpbGwg ZnVuY3Rpb24gYXMgYQorY29tbWVudCwgaWdub3JpbmcgYWxsIGNoYXJhY3RlcnMgdG8gdGhlIHJp Z2h0IG9mICcjJyB1bnRpbCB0aGUgbmV3bGluZS4KKworVGhlIGRlZmF1bHQgYmVoYXZpb3Igb2Yg SVBFIGV2YWx1YXRpb25zIGNhbiBhbHNvIGJlIGV4cHJlc3NlZCBpbiBwb2xpY3ksCit0aHJvdWdo IHRoZSBgYERFRkFVTFRgYCBzdGF0ZW1lbnQuIFRoaXMgY2FuIGJlIGRvbmUgYXQgYSBnbG9iYWwg bGV2ZWwsCitvciBhIHBlci1vcGVyYXRpb24gbGV2ZWw6OgorCisgICAjIEdsb2JhbAorICAgREVG QVVMVCBhY3Rpb249QUxMT1cKKworICAgIyBPcGVyYXRpb24gU3BlY2lmaWMKKyAgIERFRkFVTFQg b3A9RVhFQ1VURSBhY3Rpb249QUxMT1cKKworQSBkZWZhdWx0IG11c3QgYmUgc2V0IGZvciBhbGwg a25vd24gb3BlcmF0aW9ucyBpbiBJUEUuIElmIHlvdSB3YW50IHRvCitwcmVzZXJ2ZSBvbGRlciBw b2xpY2llcyBiZWluZyBjb21wYXRpYmxlIHdpdGggbmV3ZXIga2VybmVscyB0aGF0IGNhbiBpbnRy b2R1Y2UKK25ldyBvcGVyYXRpb25zLCBwbGVhc2Ugc2V0IGEgZ2xvYmFsIGRlZmF1bHQgb2YgJ0FM TE9XJywgYW5kIG92ZXJyaWRlIHRoZQorZGVmYXVsdHMgb24gYSBwZXItb3BlcmF0aW9uIGJhc2lz LgorCitXaXRoIGNvbmZpZ3VyYWJsZSBwb2xpY3ktYmFzZWQgTFNNcywgdGhlcmUncyBzZXZlcmFs IGlzc3VlcyB3aXRoCitlbmZvcmNpbmcgdGhlIGNvbmZpZ3VyYWJsZSBwb2xpY2llcyBhdCBzdGFy dHVwLCBhcm91bmQgcmVhZGluZyBhbmQKK3BhcnNpbmcgdGhlIHBvbGljeToKKworMS4gVGhlIGtl cm5lbCAqc2hvdWxkKiBub3QgcmVhZCBmaWxlcyBmcm9tIHVzZXJsYW5kLCBzbyBkaXJlY3RseSBy ZWFkaW5nCisgICB0aGUgcG9saWN5IGZpbGUgaXMgcHJvaGliaXRlZC4KKzIuIFRoZSBrZXJuZWwg Y29tbWFuZCBsaW5lIGhhcyBhIGNoYXJhY3RlciBsaW1pdCwgYW5kIG9uZSBrZXJuZWwgbW9kdWxl CisgICBzaG91bGQgbm90IHJlc2VydmUgdGhlIGVudGlyZSBjaGFyYWN0ZXIgbGltaXQgZm9yIGl0 cyBvd24KKyAgIGNvbmZpZ3VyYXRpb24uCiszLiBUaGVyZSBhcmUgdmFyaW91cyBib290IGxvYWRl cnMgaW4gdGhlIGtlcm5lbCBlY29zeXN0ZW0sIHNvIGhhbmRpbmcKKyAgIG9mZiBhIG1lbW9yeSBi bG9jayB3b3VsZCBiZSBjb3N0bHkgdG8gbWFpbnRhaW4uCisKK0FzIGEgcmVzdWx0LCBJUEUgaGFz IGFkZHJlc3NlZCB0aGlzIHByb2JsZW0gdGhyb3VnaCBhIGNvbmNlcHQgb2YgYSAiYm9vdAorcG9s aWN5Ii4gQSBib290IHBvbGljeSBpcyBhIG1pbmltYWwgcG9saWN5LCBjb21waWxlZCBpbnRvIHRo ZSBrZXJuZWwuCitUaGlzIHBvbGljeSBpcyBpbnRlbmRlZCB0byBnZXQgdGhlIHN5c3RlbSB0byBh IHN0YXRlIHdoZXJlIHVzZXJsYW5kIGlzCitzZXR1cCBhbmQgcmVhZHkgdG8gcmVjZWl2ZSBjb21t YW5kcywgYXQgd2hpY2ggcG9pbnQgYSBtb3JlIGNvbXBsZXgKK3BvbGljeSAoInVzZXIgcG9saWNp ZXMiKSBjYW4gYmUgZGVwbG95ZWQgdmlhIHNlY3VyaXR5ZnMuIFRoZSBib290IHBvbGljeQorY2Fu IGJlIHNwZWNpZmllZCB2aWEgdGhlIEtjb25maWcsIGBgU0VDVVJJVFlfSVBFX0JPT1RfUE9MSUNZ YGAsIHdoaWNoCithY2NlcHRzIGEgcGF0aCB0byBhIHBsYWluLXRleHQgdmVyc2lvbiBvZiB0aGUg SVBFIHBvbGljeSB0byBhcHBseS4gVGhpcworcG9saWN5IHdpbGwgYmUgY29tcGlsZWQgaW50byB0 aGUga2VybmVsLiBJZiBub3Qgc3BlY2lmaWVkLCBJUEUgd2lsbCBiZQorZGlzYWJsZWQgdW50aWwg YSBwb2xpY3kgaXMgZGVwbG95ZWQgYW5kIGFjdGl2YXRlZCB0aHJvdWdoIHNlY3VyaXR5ZnMuCisK Ky4uIFsjXSBQbGVhc2Ugc2VlIHRoZSA6cmVmOmBEb2N1bWVudGF0aW9uL3NlY3VyaXR5L2lwZS5y c3RgIGZvciBtb3JlIG9uIHRoaXMKKyAgIHRvcGljLgorCitEZXBsb3lpbmcgUG9saWNpZXMKK35+ fn5+fn5+fn5+fn5+fn5+fgorCitVc2VyIHBvbGljaWVzIGFzIGV4cGxhaW5lZCBhYm92ZSwgYXJl IHBvbGljaWVzIHRoYXQgYXJlIGRlcGxveWVkIGZyb20KK3VzZXJsYW5kLCB0aHJvdWdoIHNlY3Vy aXR5ZnMuIFRoZXNlIHBvbGljaWVzIGFyZSBzaWduZWQgdG8gZW5mb3JjZSBzb21lCitsZXZlbCBv ZiBhdXRob3JpemF0aW9uIG9mIHRoZSBwb2xpY2llcyAocHJvaGliaXRpbmcgYW4gYXR0YWNrZXIg ZnJvbQorZ2FpbmluZyByb290LCBhbmQgZGVwbG95aW5nIGFuICJhbGxvdyBhbGwiIHBvbGljeSks IHRocm91Z2ggdGhlIFBLQ1MjNworZW52ZWxvcGVkIGRhdGEgZm9ybWF0LiBUaGVzZSBwb2xpY2ll cyBtdXN0IGJlIHNpZ25lZCBieSBhIGNlcnRpZmljYXRlCit0aGF0IGNoYWlucyB0byB0aGUgYGBT WVNURU1fVFJVU1RFRF9LRVlSSU5HYGAuIFRocm91Z2ggb3BlbnNzbCwgdGhlCitzaWduaW5nIGNh biBiZSBkb25lIHZpYTo6CisKKyAgIG9wZW5zc2wgc21pbWUgLXNpZ24gLWluICIkTVlfUE9MSUNZ IiAtc2lnbmVyICIkTVlfQ0VSVElGSUNBVEUiIFwKKyAgICAgLWlua2V5ICIkTVlfUFJJVkFURV9L RVkiIC1iaW5hcnkgLW91dGZvcm0gZGVyIC1ub2F0dHIgLW5vZGV0YWNoIFwKKyAgICAgLW91dCAi JE1ZX1BPTElDWS5wN3MiCisKK0RlcGxveWluZyB0aGUgcG9saWNpZXMgaXMgZG9uZSB0aHJvdWdo IHNlY3VyaXR5ZnMsIHRocm91Z2ggdGhlCitgYG5ld19wb2xpY3lgYCBub2RlLiBUbyBkZXBsb3kg YSBwb2xpY3ksIHNpbXBseSBjYXQgdGhlIGZpbGUgaW50byB0aGUKK3NlY3VyaXR5ZnMgbm9kZTo6 CisKKyAgIGNhdCAiJE1ZX1BPTElDWS5wN3MiID4gL3N5cy9rZXJuZWwvc2VjdXJpdHkvaXBlL25l d19wb2xpY3kKKworVXBvbiBzdWNjZXNzLCB0aGlzIHdpbGwgY3JlYXRlIG9uZSBzdWJkaXJlY3Rv cnkgdW5kZXIKK2BgL3N5cy9rZXJuZWwvc2VjdXJpdHkvaXBlL3BvbGljaWVzL2BgLiBUaGUgc3Vi ZGlyZWN0b3J5IHdpbGwgYmUgdGhlCitgYHBvbGljeV9uYW1lYGAgZmllbGQgb2YgdGhlIHBvbGlj eSBkZXBsb3llZCwgc28gZm9yIHRoZSBleGFtcGxlIGFib3ZlLAordGhlIGRpcmVjdG9yeSB3aWxs IGJlIGBgL3N5cy9rZXJuZWwvc2VjdXJpdHkvaXBlL3BvbGljaWVzL0V4XCBQb2xpY3lgYC4KK1dp dGhpbiB0aGlzIGRpcmVjdG9yeSwgdGhlcmUgd2lsbCBiZSBmaXZlIGZpbGVzOiBgYHBrY3M3YGAs IGBgcG9saWN5YGAsCitgYGFjdGl2ZWBgLCBgYHVwZGF0ZWBgLCBhbmQgYGBkZWxldGVgYC4KKwor VGhlIGBgcGtjczdgYCBmaWxlIGlzIHJ3LCByZWFkaW5nIHdpbGwgcHJvdmlkZSB0aGUgcmF3IFBL Q1MjNyBkYXRhIHRoYXQKK3dhcyBwcm92aWRlZCB0byB0aGUga2VybmVsLCByZXByZXNlbnRpbmcg dGhlIHBvbGljeS4gV3JpdGluZywgd2lsbAorZGVwbG95IGFuIGluLXBsYWNlIHBvbGljeSB1cGRh dGUgLSBpZiB0aGlzIHBvbGljeSBpcyB0aGUgY3VycmVudGx5CitydW5uaW5nIHBvbGljeSwgdGhl IG5ldyB1cGRhdGVkIHBvbGljeSB3aWxsIHJlcGxhY2UgaXQgaW1tZWRpYXRlbHkgdXBvbgorc3Vj Y2Vzcy4gSWYgdGhlIHBvbGljeSBiZWluZyByZWFkIGlzIHRoZSBib290IHBvbGljeSwgd2hlbiBy ZWFkLCB0aGlzCit3aWxsIHJldHVybiBFTk9FTlQuCisKK1RoZSBgYHBvbGljeWBgIGZpbGUgaXMg cmVhZCBvbmx5LiBSZWFkaW5nIHdpbGwgcHJvdmlkZSB0aGUgUEtDUyM3IGlubmVyCitjb250ZW50 IG9mIHRoZSBwb2xpY3ksIHdoaWNoIHdpbGwgYmUgdGhlIHBsYWluIHRleHQgcG9saWN5LgorCitU aGUgYGBhY3RpdmVgYCBmaWxlIGlzIHVzZWQgdG8gc2V0IGEgcG9saWN5IGFzIHRoZSBjdXJyZW50 bHkgYWN0aXZlIHBvbGljeS4KK1RoaXMgZmlsZSBpcyBydywgYW5kIGFjY2VwdHMgYSB2YWx1ZSBv ZiBgYCIxImBgIHRvIHNldCB0aGUgcG9saWN5IGFzIGFjdGl2ZS4KK1NpbmNlIG9ubHkgYSBzaW5n bGUgcG9saWN5IGNhbiBiZSBhY3RpdmUgYXQgb25lIHRpbWUsIGFsbCBvdGhlciBwb2xpY2llcwor d2lsbCBiZSBtYXJrZWQgaW5hY3RpdmUuIFRoZSBwb2xpY3kgYmVpbmcgbWFya2VkIGFjdGl2ZSBt dXN0IGhhdmUgYSBwb2xpY3kKK3ZlcnNpb24gZ3JlYXRlciBvciBlcXVhbCB0byB0aGUgY3VycmVu dGx5LXJ1bm5pbmcgdmVyc2lvbi4KKworVGhlIGBgdXBkYXRlYGAgZmlsZSBpcyB1c2VkIHRvIHVw ZGF0ZSBhIHBvbGljeSB0aGF0IGlzIGFscmVhZHkgcHJlc2VudCBpbgordGhlIGtlcm5lbC4gVGhp cyBmaWxlIGlzIHdyaXRlLW9ubHkgYW5kIGFjY2VwdHMgYSBQS0NTIzcgc2lnbmVkIHBvbGljeS4K K09uZSBjaGVjayB3aWxsIGJlIHBlcmZvcm1lZCBvbiB0aGlzIHBvbGljeTogdGhlIHBvbGljeV9u YW1lcyBtdXN0IG1hdGNoCit3aXRoIHRoZSB1cGRhdGVkIHZlcnNpb24gYW5kIHRoZSBleGlzdGlu ZyB2ZXJzaW9uLiBJZiB0aGUgcG9saWN5IGJlaW5nCit1cGRhdGVkIGlzIHRoZSBhY3RpdmUgcG9s aWN5LCB0aGUgdXBkYXRlZCBwb2xpY3kgbXVzdCBoYXZlIGEgcG9saWN5IHZlcnNpb24KK2dyZWF0 ZXIgb3IgZXF1YWwgdG8gdGhlIGN1cnJlbnRseS1ydW5uaW5nIHZlcnNpb24uCisKK1RoZSBgYGRl bGV0ZWBgIGZpbGUgaXMgdXNlZCB0byByZW1vdmUgYSBwb2xpY3kgdGhhdCBpcyBubyBsb25nZXIg bmVlZGVkLgorVGhpcyBmaWxlIGlzIHdyaXRlLW9ubHkgYW5kIGFjY2VwdHMgYSB2YWx1ZSBvZiBg YCIxImBgIHRvIGRlbGV0ZSB0aGUgcG9saWN5LgorT24gZGVsZXRpb24sIHRoZSBzZWN1cml0eWZz IG5vZGUgcmVwcmVzZW50aW5nIHRoZSBwb2xpY3kgd2lsbCBiZSByZW1vdmVkLgorVGhlIHBvbGlj eSB0aGF0IGlzIGN1cnJlbnRseSBhY3RpdmUsIGNhbm5vdCBiZSBkZWxldGVkLgorCitTaW1pbGFy bHksIHRoZSB3cml0ZXMgdG8gYm90aCBgYHVwZGF0ZWBgIGFuZCBgYG5ld19wb2xpY3lgYCBhYm92 ZSB3aWxsCityZXN1bHQgaW4gYW4gZXJyb3IgdXBvbiBzeW50YWN0aWNhbGx5IGludmFsaWQgb3Ig dW50cnVzdGVkIHBvbGljaWVzLgorSXQgd2lsbCBhbHNvIGVycm9yIGlmIGEgcG9saWN5IGFscmVh ZHkgZXhpc3RzIHdpdGggdGhlIHNhbWUgYGBwb2xpY3lfbmFtZWBgLAoraW4gdGhlIGNhc2Ugb2Yg YGBuZXdfcG9saWN5YGAuCisKK0RlcGxveWluZyB0aGVzZSBwb2xpY2llcyB3aWxsICpub3QqIGNh dXNlIElQRSB0byBzdGFydCBlbmZvcmNpbmcgdGhpcworcG9saWN5LiBPbmNlIGRlcGxveW1lbnQg aXMgc3VjY2Vzc2Z1bCwgYSBwb2xpY3kgY2FuIGJlIG1hcmtlZCBhcyBhY3RpdmUsCit2aWEgYGAv c3lzL2tlcm5lbC9zZWN1cml0eS9pcGUvJHBvbGljeV9uYW1lL2FjdGl2ZWBgLiBJUEUgd2lsbCBl bmZvcmNlCit3aGF0ZXZlciBwb2xpY3kgaXMgbWFya2VkIGFzIGFjdGl2ZS4gRm9yIG91ciBleGFt cGxlLCB3ZSBjYW4gYWN0aXZhdGUKK3RoZSBgYEV4IFBvbGljeWBgIHZpYTo6CisKKyAgIGVjaG8g IjEiID4gIi9zeXMva2VybmVsL3NlY3VyaXR5L2lwZS9FeCBQb2xpY3kvYWN0aXZlIgorCitBdCB3 aGljaCBwb2ludCwgYGBFeCBQb2xpY3lgYCB3aWxsIG5vdyBiZSB0aGUgZW5mb3JjZWQgcG9saWN5 IG9uIHRoZQorc3lzdGVtLgorCitJUEUgYWxzbyBwcm92aWRlcyBhIHdheSB0byBkZWxldGUgcG9s aWNpZXMuIFRoaXMgY2FuIGJlIGRvbmUgdmlhIHRoZQorYGBkZWxldGVgYCBzZWN1cml0eWZzIG5v ZGUsIGBgL3N5cy9rZXJuZWwvc2VjdXJpdHkvaXBlLyRwb2xpY3lfbmFtZS9kZWxldGVgYC4KK1dy aXRpbmcgYGAxYGAgdG8gdGhhdCBmaWxlIHdpbGwgZGVsZXRlIHRoYXQgbm9kZTo6CisKKyAgIGVj aG8gIjEiID4gIi9zeXMva2VybmVsL3NlY3VyaXR5L2lwZS8kcG9saWN5X25hbWUvZGVsZXRlIgor CitUaGVyZSBpcyBvbmx5IG9uZSByZXF1aXJlbWVudCB0byBkZWxldGUgYSBwb2xpY3k6CisKKzEu IFRoZSBwb2xpY3kgYmVpbmcgZGVsZXRlZCBtdXN0IG5vdCBiZSB0aGUgYWN0aXZlIHBvbGljeS4K KworLi4gTk9URTo6CisKKyAgIElmIGEgdHJhZGl0aW9uYWwgTUFDIHN5c3RlbSBpcyBlbmFibGVk IChTRUxpbnV4LCBhcHBhcm1vciwgc21hY2spLCBhbGwKKyAgIHdyaXRlcyB0byBpcGUncyBzZWN1 cml0eWZzIG5vZGVzIHJlcXVpcmUgYGBDQVBfTUFDX0FETUlOYGAuCisKK01vZGVzCit+fn5+fgor CitJUEUgc3VwcG9ydHMgdHdvIG1vZGVzIG9mIG9wZXJhdGlvbjogcGVybWlzc2l2ZSAoc2ltaWxh ciB0byBTRUxpbnV4J3MKK3Blcm1pc3NpdmUgbW9kZSkgYW5kIGVuZm9yY2UuIFBlcm1pc3NpdmUg bW9kZSBwZXJmb3JtcyB0aGUgc2FtZSBjaGVja3MKK2FzIGVuZm9yY2UgbW9kZSwgYW5kIGxvZ3Mg cG9saWN5IHZpb2xhdGlvbnMsIGJ1dCB3aWxsIG5vdCBlbmZvcmNlIHRoZQorcG9saWN5LiBUaGlz IGFsbG93cyB1c2VycyB0byB0ZXN0IHBvbGljaWVzIGJlZm9yZSBlbmZvcmNpbmcgdGhlbS4KKwor VGhlIGRlZmF1bHQgbW9kZSBpcyBlbmZvcmNlLCBhbmQgY2FuIGJlIGNoYW5nZWQgdmlhIHRoZSBr ZXJuZWwgY29tbWFuZAorbGluZSBwYXJhbWV0ZXIgYGBpcGUuZW5mb3JjZT0oMHwxKWBgLCBvciB0 aGUgc2VjdXJpdHlmcyBub2RlCitgYC9zeXMva2VybmVsL3NlY3VyaXR5L2lwZS9lbmZvcmNlYGAu CisKKy4uIE5PVEU6OgorCisgICBJZiBhIHRyYWRpdGlvbmFsIE1BQyBzeXN0ZW0gaXMgZW5hYmxl ZCAoU0VMaW51eCwgYXBwYXJtb3IsIHNtYWNrLCBldGNldGVyYSksCisgICBhbGwgd3JpdGVzIHRv IGlwZSdzIHNlY3VyaXR5ZnMgbm9kZXMgcmVxdWlyZSBgYENBUF9NQUNfQURNSU5gYC4KKworQXVk aXQgRXZlbnRzCit+fn5+fn5+fn5+fn4KKworU3VjY2VzcyBBdWRpdGluZworXl5eXl5eXl5eXl5e Xl5eXgorCitJUEUgc3VwcG9ydHMgc3VjY2VzcyBhdWRpdGluZy4gV2hlbiBlbmFibGVkLCBhbGwg ZXZlbnRzIHRoYXQgcGFzcyBJUEUKK3BvbGljeSBhbmQgYXJlIG5vdCBibG9ja2VkIHdpbGwgZW1p dCBhbiBhdWRpdCBldmVudC4gVGhpcyBpcyBkaXNhYmxlZCBieQorZGVmYXVsdCwgYW5kIGNhbiBi ZSBlbmFibGVkIHZpYSB0aGUga2VybmVsIGNvbW1hbmQgbGluZQorYGBpcGUuc3VjY2Vzc19hdWRp dD0oMHwxKWBgIG9yIHRoZSBzZWN1cml0eWZzIG5vZGUsCitgYC9zeXMva2VybmVsL3NlY3VyaXR5 L2lwZS9zdWNjZXNzX2F1ZGl0YGAuCisKK1RoaXMgaXMgdmVyeSBub2lzeSwgYXMgSVBFIHdpbGwg Y2hlY2sgZXZlcnkgdXNlci1tb2RlIGJpbmFyeSBvbiB0aGUKK3N5c3RlbSwgYnV0IGlzIHVzZWZ1 bCBmb3IgZGVidWdnaW5nIHBvbGljaWVzLgorCisuLiBOT1RFOjoKKworICAgSWYgYSB0cmFkaXRp b25hbCBNQUMgc3lzdGVtIGlzIGVuYWJsZWQgKFNFTGludXgsIGFwcGFybW9yLCBzbWFjaywgZXRj ZXRlcmEpLAorICAgYWxsIHdyaXRlcyB0byBpcGUncyBzZWN1cml0eWZzIG5vZGVzIHJlcXVpcmUg YGBDQVBfTUFDX0FETUlOYGAuCisKK1Byb3BlcnRpZXMKKy0tLS0tLS0tLS0tLS0tCisKK0FzIGV4 cGxhaW5lZCBhYm92ZSwgSVBFIHByb3BlcnRpZXMgYXJlIGBga2V5PXZhbHVlYGAgcGFpcnMgZXhw cmVzc2VkIGluCitJUEUgcG9saWN5LiBUd28gcHJvcGVydGllcyBhcmUgYnVpbHQtaW50byB0aGUg cG9saWN5IHBhcnNlcjogJ29wJyBhbmQKKydhY3Rpb24nLiBUaGUgb3RoZXIgcHJvcGVydGllcyBh cmUgZGV0ZXJtaW5zdGljIGF0dHJpYnV0ZXMgdG8gZXhwcmVzcworYWNyb3NzIGZpbGVzLiBDdXJy ZW50bHkgdGhvc2UgcHJvcGVydGllcyBhcmU6ICdib290X3ZlcmlmaWVkJywKKydkbXZlcml0eV9z aWduYXR1cmUnLCAnZG12ZXJpdHlfcm9vdGhhc2gnLCAnZnN2ZXJpdHlfc2lnbmF0dXJlJywKKydm c3Zlcml0eV9kaWdlc3QnLiBBIGRlc2NyaXB0aW9uIG9mIGFsbCBwcm9wZXJ0aWVzIHN1cHBvcnRl ZCBieSBJUEUKK2FyZSBsaXN0ZWQgYmVsb3c6CisKK29wCit+fgorCitJbmRpY2F0ZXMgdGhlIG9w ZXJhdGlvbiBmb3IgYSBydWxlIHRvIGFwcGx5IHRvLiBNdXN0IGJlIGluIGV2ZXJ5IHJ1bGUsCith cyB0aGUgZmlyc3QgdG9rZW4uIElQRSBzdXBwb3J0cyB0aGUgZm9sbG93aW5nIG9wZXJhdGlvbnM6 CisKK1ZlcnNpb24gMQorXl5eXl5eXl5eCisKK2BgRVhFQ1VURWBgCisKKyAgIFBlcnRhaW5zIHRv IGFueSBmaWxlIGF0dGVtcHRpbmcgdG8gYmUgZXhlY3V0ZWQsIG9yIGxvYWRlZCBhcyBhbgorICAg ZXhlY3V0YWJsZS4KKworYGBGSVJNV0FSRWBgOgorCisgICBQZXJ0YWlucyB0byBmaXJtd2FyZSBi ZWluZyBsb2FkZWQgdmlhIHRoZSBmaXJtd2FyZV9jbGFzcyBpbnRlcmZhY2UuCisgICBUaGlzIGNv dmVycyBib3RoIHRoZSBwcmVhbGxvY2F0ZWQgYnVmZmVyIGFuZCB0aGUgZmlybXdhcmUgZmlsZQor ICAgaXRzZWxmLgorCitgYEtNT0RVTEVgYDoKKworICAgUGVydGFpbnMgdG8gbG9hZGluZyBrZXJu ZWwgbW9kdWxlcyB2aWEgYGBtb2Rwcm9iZWBgIG9yIGBgaW5zbW9kYGAuCisKK2BgS0VYRUNfSU1B R0VgYDoKKworICAgUGVydGFpbnMgdG8ga2VybmVsIGltYWdlcyBsb2FkaW5nIHZpYSBgYGtleGVj YGAuCisKK2BgS0VYRUNfSU5JVFJBTUZTYGAKKworICAgUGVydGFpbnMgdG8gaW5pdHJkIGltYWdl cyBsb2FkaW5nIHZpYSBgYGtleGVjIC0taW5pdHJkYGAuCisKK2BgUE9MSUNZYGA6CisKKyAgIENv bnRyb2xzIGxvYWRpbmcgSU1BIHBvbGljaWVzIHRocm91Z2ggdGhlCisgICBgYC9zeXMva2VybmVs L3NlY3VyaXR5L2ltYS9wb2xpY3lgYCBzZWN1cml0eWZzIGVudHJ5LgorCitgYFg1MDlfQ0VSVGBg OgorCisgICBDb250cm9scyBsb2FkaW5nIElNQSBjZXJ0aWZpY2F0ZXMgdGhyb3VnaCB0aGUgS2Nv bmZpZ3MsCisgICBgYENPTkZJR19JTUFfWDUwOV9QQVRIYGAgYW5kIGBgQ09ORklHX0VWTV9YNTA5 X1BBVEhgYC4KKworYGBLRVJORUxfUkVBRGBgOgorCisgICBTaG9ydCBoYW5kIGZvciBhbGwgb2Yg dGhlIGZvbGxvd2luZzogYGBGSVJNV0FSRWBgLCBgYEtNT0RVTEVgYCwKKyAgIGBgS0VYRUNfSU1B R0VgYCwgYGBLRVhFQ19JTklUUkFNRlNgYCwgYGBQT0xJQ1lgYCwgYW5kIGBgWDUwOV9DRVJUYGAu CisKK2FjdGlvbgorfn5+fn5+CisKK1ZlcnNpb24gMQorXl5eXl5eXl5eCisKK0RldGVybWluZXMg d2hhdCBJUEUgc2hvdWxkIGRvIHdoZW4gYSBydWxlIG1hdGNoZXMuIE11c3QgYmUgaW4gZXZlcnkK K3J1bGUsIGFzIHRoZSBmaW5hbCBjbGF1c2UuIENhbiBiZSBvbmUgb2Y6CisKK2BgQUxMT1dgYDoK KworICAgSWYgdGhlIHJ1bGUgbWF0Y2hlcywgZXhwbGljaXRseSBhbGxvdyBhY2Nlc3MgdG8gdGhl IHJlc291cmNlIHRvIHByb2NlZWQKKyAgIHdpdGhvdXQgZXhlY3V0aW5nIGFueSBtb3JlIHJ1bGVz LgorCitgYERFTllgYDoKKworICAgSWYgdGhlIHJ1bGUgbWF0Y2hlcywgZXhwbGljaXRseSBwcm9o aWJpdCBhY2Nlc3MgdG8gdGhlIHJlc291cmNlIHRvCisgICBwcm9jZWVkIHdpdGhvdXQgZXhlY3V0 aW5nIGFueSBtb3JlIHJ1bGVzLgorCitib290X3ZlcmlmaWVkCit+fn5+fn5+fn5+fn5+CisKK1Zl cnNpb24gMQorXl5eXl5eXl5eCisKK1RoaXMgcHJvcGVydHkgY2FuIGJlIHV0aWxpemVkIGZvciBh dXRob3JpemF0aW9uIG9mIHRoZSBmaXJzdCBzdXBlci1ibG9jawordGhhdCBleGVjdXRlcyBhIGZp bGUuIFRoaXMgaXMgYWxtb3N0IGFsd2F5cyBpbml0LiBUeXBpY2FsbHkgdGhpcyBpcyB1c2VkCitm b3Igc3lzdGVtcyB3aXRoIGFuIGluaXRyYW1mcyBvciBvdGhlciBpbml0aWFsIGRpc2ssIHdoZXJl IHRoaXMgaXMgdW5tb3VudGVkCitiZWZvcmUgdGhlIHN5c3RlbSBiZWNvbWVzIGF2YWlsYWJsZSwg YW5kIGlzIG5vdCBjb3ZlcmVkIGJ5IGFueSBvdGhlciBwcm9wZXJ0eS4KK1RoaXMgcHJvcGVydHkg aXMgY29udHJvbGxlZCBieSB0aGUgS2NvbmZpZywgYGBDT05GSUdfSVBFX1BST1BfQk9PVF9WRVJJ RklFRGBgLgorVGhlIGZvcm1hdCBvZiB0aGlzIHByb3BlcnR5IGlzOjoKKworICAgICAgIGJvb3Rf dmVyaWZpZWQ9KFRSVUV8RkFMU0UpCisKKworLi4gV0FSTklORzo6CisKKyAgVGhpcyBwcm9wZXJ0 eSB3aWxsIHRydXN0IGFueSBkaXNrIHdoZXJlIHRoZSBmaXJzdCBleGVjdXRpb24gZXZhbHVhdGlv bgorICBvY2N1cnMuIElmIHlvdSBkbyAqTk9UKiBoYXZlIGEgc3RhcnR1cCBkaXNrIHRoYXQgaXMg dW5wYWNrZWQgYW5kIHVubW91bnRlZAorICAobGlrZSBpbml0cmFtZnMpLCB0aGVuIGl0IHdpbGwg YXV0b21hdGljYWxseSB0cnVzdCB0aGUgcm9vdCBmaWxlc3lzdGVtIGFuZAorICBwb3RlbnRpYWxs eSBvdmVyYXV0aG9yaXplIHRoZSBlbnRpcmUgZGlzay4KKworZG12ZXJpdHlfcm9vdGhhc2gKK35+ fn5+fn5+fn5+fn5+fn5+CisKK1ZlcnNpb24gMQorXl5eXl5eXl5eCisKK1RoaXMgcHJvcGVydHkg Y2FuIGJlIHV0aWxpemVkIGZvciBhdXRob3JpemF0aW9uIG9yIHJldm9jYXRpb24gb2YKK3NwZWNp ZmljIGRtLXZlcml0eSB2b2x1bWVzLCBpZGVudGlmaWVkIHZpYSByb290IGhhc2guIEl0IGhhcyBh CitkZXBlbmRlbmN5IG9uIHRoZSBETV9WRVJJVFkgbW9kdWxlLiBUaGlzIHByb3BlcnR5IGlzIGNv bnRyb2xsZWQgYnkgdGhlCitLY29uZmlnIGBgQ09ORklHX0lQRV9QUk9QX0RNX1ZFUklUWV9ST09U SEFTSGBgLiBUaGUgZm9ybWF0IG9mIHRoaXMgcHJvcGVydHkKK2lzOjoKKworICAgZG12ZXJpdHlf cm9vdGhhc2g9SGFzaEhleERpZ2VzdAorCitkbXZlcml0eV9zaWduYXR1cmUKK35+fn5+fn5+fn5+ fn5+fn5+fgorCitWZXJzaW9uIDEKK15eXl5eXl5eXgorCitUaGlzIHByb3BlcnR5IGNhbiBiZSB1 dGlsaXplZCBmb3IgYXV0aG9yaXphdGlvbiBvZiBhbGwgZG0tdmVyaXR5IHZvbHVtZXMKK3RoYXQg aGF2ZSBhIHNpZ25lZCByb290aGFzaCB0aGF0IGNoYWlucyB0byBhIGtleXJpbmcgc3BlY2lmaWVk IGJ5IGRtLXZlcml0eSdzCitjb25maWd1cmF0aW9uLCBlaXRoZXIgdGhlIHN5c3RlbSB0cnVzdGVk IGtleXJpbmcsIG9yIHRoZSBzZWNvbmRhcnkga2V5cmluZy4KK0l0IGhhcyBhbiBhZGRpdGlvbmFs IGRlcGVuZGVuY3kgb24gdGhlIGBgRE1fVkVSSVRZX1ZFUklGWV9ST09USEFTSF9TSUdgYAorS2Nv bmZpZy4gVGhpcyBwcm9wZXJ0eSBpcyBjb250cm9sbGVkIGJ5IHRoZSBLY29uZmlnCitgYENPTkZJ R19JUEVfUFJPUF9ETV9WRVJJVFlfU0lHTkFUVVJFYGAuIFRoZSBmb3JtYXQgb2YgdGhpcyBwcm9w ZXJ0eSBpczo6CisKKyAgIGRtdmVyaXR5X3NpZ25hdHVyZT0oVFJVRXxGQUxTRSkKKworZnN2ZXJp dHlfZGlnZXN0Cit+fn5+fn5+fn5+fn5+fn4KKworVmVyc2lvbiAxCiteXl5eXl5eXl4KK1RoaXMg cHJvcGVydHkgY2FuIGJlIHV0aWxpemVkIGZvciBhdXRob3JpemF0aW9uIG9yIHJldm9jYXRpb24g b2YKK3NwZWNpZmljIGZzdmVyaXR5IGVuYWJsZWQgZmlsZSwgaWRlbnRpZmllZCB2aWEgaXRzIGZz dmVyaXR5IGRpZ2VzdCwKK3doaWNoIGlzIHRoZSBoYXNoIG9mIGEgc3RydWN0IGNvbnRhaW5zIHRo ZSBmaWxlJ3Mgcm9vdGhhc2ggYW5kIGhhc2hpbmcKK3BhcmFtZXRlcnMuIEl0IGhhcyBhIGRlcGVu ZGVuY3kgb24gdGhlIEZTX1ZFUklUWSBtb2R1bGUuCitUaGlzIHByb3BlcnR5IGlzIGNvbnRyb2xs ZWQgYnkgdGhlIEtjb25maWcKK2BgQ09ORklHX0lQRV9QUk9QX0ZTX1ZFUklUWV9ESUdFU1RgYC4g VGhlIGZvcm1hdCBvZiB0aGlzIHByb3BlcnR5IGlzOjoKKworICAgZnN2ZXJpdHlfZGlnZXN0PUhh c2hIZXhEaWdlc3QKKworZnN2ZXJpdHlfc2lnbmF0dXJlCit+fn5+fn5+fn5+fn5+fn5+fn4KKwor VmVyc2lvbiAxCiteXl5eXl5eXl4KKworVGhpcyBwcm9wZXJ0eSBjYW4gYmUgdXRpbGl6ZWQgZm9y IGF1dGhvcml6YXRpb24gb2YgYWxsIGZzdmVyaXR5IGVuYWJsZWQKK2ZpbGVzIHRoYXQgaXMgdmVy aWZpZWQgYnkgZnN2ZXJpdHkuIFRoZSBrZXlyaW5nIHRoYXQgaXMgdmVyaWZpZXMgYWdhaW5zdAor aXMgc3ViamVjdCB0byBmc3Zlcml0eSdzIGNvbmZpZ3VyYXRpb24sIHdoaWNoIGlzIHR5cGljYWxs eSB0aGUgZnN2ZXJpdHkKK2tleXJpbmcuIEl0IGhhcyBhIGRlcGVuZGVuY3kgb24gdGhlIGBgQ09O RklHX0ZTX1ZFUklUWV9CVUlMVElOX1NJR05BVFVSRVNgYAorS2NvbmZpZy4gVGhpcyBwcm9wZXJ0 eSBpcyBjb250cm9sbGVkIGJ5IHRoZSBLY29uZmlnCitgYENPTkZJR19JUEVfUFJPUF9GU19WRVJJ VFlfU0lHTkFUVVJFYGAuIFRoZSBmb3JtYXQgb2YgdGhpcyBwcm9wZXJ0eSBpczo6CisKKyAgIGZz dmVyaXR5X3NpZ25hdHVyZT0oVFJVRXxGQUxTRSkKKworUG9saWN5IEV4YW1wbGVzCistLS0tLS0t LS0tLS0tLS0KKworQWxsb3cgYWxsCit+fn5+fn5+fn4KKworOjoKKworICAgcG9saWN5X25hbWU9 IkFsbG93IEFsbCIgcG9saWN5X3ZlcnNpb249MC4wLjAKKyAgIERFRkFVTFQgYWN0aW9uPUFMTE9X CisKK0FsbG93IG9ubHkgaW5pdGlhbCBzdXBlcmJsb2NrCit+fn5+fn5+fn5+fn5+fn5+fn5+fn5+ fn5+fn5+fgorCis6OgorCisgICBwb2xpY3lfbmFtZT0iQWxsb3cgQWxsIEluaXRpYWwgU0IiIHBv bGljeV92ZXJzaW9uPTAuMC4wCisgICBERUZBVUxUIGFjdGlvbj1ERU5ZCisKKyAgIG9wPUVYRUNV VEUgYm9vdF92ZXJpZmllZD1UUlVFIGFjdGlvbj1BTExPVworCitBbGxvdyBhbnkgc2lnbmVkIGRt LXZlcml0eSB2b2x1bWUgYW5kIHRoZSBpbml0aWFsIHN1cGVyYmxvY2sKK35+fn5+fn5+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fgorCis6OgorCisg ICBwb2xpY3lfbmFtZT0iQWxsb3dTaWduZWRBbmRJbml0aWFsIiBwb2xpY3lfdmVyc2lvbj0wLjAu MAorICAgREVGQVVMVCBhY3Rpb249REVOWQorCisgICBvcD1FWEVDVVRFIGJvb3RfdmVyaWZpZWQ9 VFJVRSBhY3Rpb249QUxMT1cKKyAgIG9wPUVYRUNVVEUgZG12ZXJpdHlfc2lnbmF0dXJlPVRSVUUg YWN0aW9uPUFMTE9XCisKK1Byb2hpYml0IGV4ZWN1dGlvbiBmcm9tIGEgc3BlY2lmaWMgZG0tdmVy aXR5IHZvbHVtZQorfn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+ fn5+fn5+CisKKzo6CisKKyAgIHBvbGljeV9uYW1lPSJBbGxvd1NpZ25lZEFuZEluaXRpYWwiIHBv bGljeV92ZXJzaW9uPTAuMC4wCisgICBERUZBVUxUIGFjdGlvbj1ERU5ZCisKKyAgIG9wPUVYRUNV VEUgZG12ZXJpdHlfcm9vdGhhc2g9NDAxZmNlYzU5NDQ4MjNhZTEyZjYyNzI2ZTgxODQ0MDdhNWZh OTU5OTc4M2YwMzBkZWMxNDY5MzggYWN0aW9uPURFTlkKKyAgIG9wPUVYRUNVVEUgYm9vdF92ZXJp ZmllZD1UUlVFIGFjdGlvbj1BTExPVworICAgb3A9RVhFQ1VURSBkbXZlcml0eV9zaWduYXR1cmU9 VFJVRSBhY3Rpb249QUxMT1cKKworQWxsb3cgb25seSBhIHNwZWNpZmljIGRtLXZlcml0eSB2b2x1 bWUKK35+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+CisKKzo6CisKKyAgIHBv bGljeV9uYW1lPSJBbGxvd1NpZ25lZEFuZEluaXRpYWwiIHBvbGljeV92ZXJzaW9uPTAuMC4wCisg ICBERUZBVUxUIGFjdGlvbj1ERU5ZCisKKyAgIG9wPUVYRUNVVEUgZG12ZXJpdHlfcm9vdGhhc2g9 NDAxZmNlYzU5NDQ4MjNhZTEyZjYyNzI2ZTgxODQ0MDdhNWZhOTU5OTc4M2YwMzBkZWMxNDY5Mzgg YWN0aW9uPUFMTE9XCisKK0FsbG93IGFueSBzaWduZWQgZnMtdmVyaXR5IGZpbGUKK35+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fgorCis6 OgorCisgICBwb2xpY3lfbmFtZT0iQWxsb3dTaWduZWRGU1Zlcml0eSIgcG9saWN5X3ZlcnNpb249 MC4wLjAKKyAgIERFRkFVTFQgYWN0aW9uPURFTlkKKworICAgb3A9RVhFQ1VURSBmc3Zlcml0eV9z aWduYXR1cmU9VFJVRSBhY3Rpb249QUxMT1cKKworUHJvaGliaXQgZXhlY3V0aW9uIG9mIGEgc3Bl Y2lmaWMgZnMtdmVyaXR5IGZpbGUKK35+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fgorCis6OgorCisgICBwb2xpY3lfbmFtZT0iUHJvaGliaXRTcGVjaWZp Y0ZTVkYiIHBvbGljeV92ZXJzaW9uPTAuMC4wCisgICBERUZBVUxUIGFjdGlvbj1ERU5ZCisKKyAg IG9wPUVYRUNVVEUgZnN2ZXJpdHlfZGlnZXN0PWZkODhmMmI4ODI0ZTE5N2Y4NTBiZjRjNTEwOWJl YTVjZjBlZTM4MTA0ZjcxMDg0M2JiNzJkYTc5NmJhNWFmOWUgYWN0aW9uPURFTlkKKyAgIG9wPUVY RUNVVEUgYm9vdF92ZXJpZmllZD1UUlVFIGFjdGlvbj1BTExPVworICAgb3A9RVhFQ1VURSBkbXZl cml0eV9zaWduYXR1cmU9VFJVRSBhY3Rpb249QUxMT1cKKworQWRkaXRpb25hbCBJbmZvcm1hdGlv bgorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCistIGBHaXRodWIgUmVwb3NpdG9yeSA8aHR0cHM6 Ly9naXRodWIuY29tL21pY3Jvc29mdC9pcGU+YF8KKy0gYERlc2lnbiBEb2N1bWVudGF0aW9uIDwv c2VjdXJpdHkvaXBlPmBfCisKK0ZBUQorLS0tCisKKzpROiBXaGF0J3MgdGhlIGRpZmZlcmVuY2Ug YmV0d2VlbiBvdGhlciBMU01zIHdoaWNoIHByb3ZpZGUgdHJ1c3QtYmFzZWQKKyAgIGFjY2VzcyBj b250cm9sLCBmb3IgaW5zdGFuY2UsIElNQT8KKworOkE6IElNQSBpcyBhIGZhbnRhc3RpYyBvcHRp b24gd2hlbiBuZWVkaW5nIG1lYXN1cmVtZW50IGluIGFkZGl0aW9uIHRvIHRoZQorICAgdHJ1c3Qt YmFzZWQgYWNjZXNzIG1vZGVsLiBBbGwgb2YgSU1BIGlzIGNlbnRlcmVkIGFyb3VuZCB0aGVpciBt ZWFzdXJlbWVudAorICAgaGFzaGVzLCBzbyB5b3Ugc2F2ZSB0aW1lIHdoZW4gZG9pbmcgYm90aCBh Y3Rpb25zLiBJUEUsIG9uIHRoZSBvdGhlciBoYW5kLAorICAgaXMgYSBoaWdobHkgcGVyZm9ybWFu dCBzeXN0ZW0gdGhhdCBkb2VzIG5vdCByZWx5IChhbmQgZXhwbGljaXRseSBwcm9oaWJpdHMpLAor ICAgZ2VuZXJhdGluZyBpdHMgb3duIGludGVncml0eSBtZWNoYW5pc21zIC0gc2VwYXJhdGluZyBt ZWFzdXJlbWVudCBhbmQgYWNjZXNzCisgICBjb250cm9sLiBTaW1wbHkgcHV0LCBJUEUgcHJvdmlk ZXMgb25seSB0aGUgZW5mb3JjZW1lbnQgb2YgdHJ1c3QsIHdoaWxlIG90aGVyCisgICBzdWJzeXN0 ZW1zIHByb3ZpZGUgdGhlIGludGVncml0eSBndWFyYW50ZWUgdGhhdCBJUEUgbmVlZHMgdG8gZGV0 ZXJtaW5lIHRoZQorICAgdHJ1c3Qgb2YgYSByZXNvdXJjZS4gSU1BIHByb3ZpZGVzIGJvdGggdGhl IGludGVncml0eSBndWFyYW50ZWUsIGFuZCB0aGUKKyAgIGVuZm9yY2VtZW50IG9mIHRydXN0Lgpk aWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9hZG1pbi1ndWlkZS9rZXJuZWwtcGFyYW1ldGVycy50 eHQgYi9Eb2N1bWVudGF0aW9uL2FkbWluLWd1aWRlL2tlcm5lbC1wYXJhbWV0ZXJzLnR4dAppbmRl eCA0M2RjMzVmZTViYzAuLjg1ZGQ2NTRlNjQyZiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9h ZG1pbi1ndWlkZS9rZXJuZWwtcGFyYW1ldGVycy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9hZG1p bi1ndWlkZS9rZXJuZWwtcGFyYW1ldGVycy50eHQKQEAgLTIwOTYsNiArMjA5NiwxOCBAQAogCWlw Y21uaV9leHRlbmQJW0tOTF0gRXh0ZW5kIHRoZSBtYXhpbXVtIG51bWJlciBvZiB1bmlxdWUgU3lz dGVtIFYKIAkJCUlQQyBpZGVudGlmaWVycyBmcm9tIDMyLDc2OCB0byAxNiw3NzcsMjE2LgogCisJ aXBlLmVuZm9yY2U9CVtJUEVdCisJCQlGb3JtYXQ6IDxib29sPgorCQkJRGV0ZXJtaW5lIHdoZXRo ZXIgSVBFIHN0YXJ0cyBpbiBwZXJtaXNzaXZlICgwKSBvcgorCQkJZW5mb3JjZSAoMSkgbW9kZS4g VGhlIGRlZmF1bHQgaXMgZW5mb3JjZS4KKworCWlwZS5zdWNjZXNzX2F1ZGl0PQorCQkJW0lQRV0K KwkJCUZvcm1hdDogPGJvb2w+CisJCQlTdGFydCBJUEUgd2l0aCBzdWNjZXNzIGF1ZGl0aW5nIGVu YWJsZWQsIGVtaXR0aW5nCisJCQlhbiBhdWRpdCBldmVudCB3aGVuIGEgYmluYXJ5IGlzIGFsbG93 ZWQuIFRoZSBkZWZhdWx0CisJCQlpcyAwLgorCiAJaXJxYWZmaW5pdHk9CVtTTVBdIFNldCB0aGUg ZGVmYXVsdCBpcnEgYWZmaW5pdHkgbWFzawogCQkJVGhlIGFyZ3VtZW50IGlzIGEgY3B1IGxpc3Qs IGFzIGRlc2NyaWJlZCBhYm92ZS4KIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9zZWN1cml0 eS9pbmRleC5yc3QgYi9Eb2N1bWVudGF0aW9uL3NlY3VyaXR5L2luZGV4LnJzdAppbmRleCAxNjMz NWRlMDRlOGMuLmMwNjUzMGI1MDUxNCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9zZWN1cml0 eS9pbmRleC5yc3QKKysrIGIvRG9jdW1lbnRhdGlvbi9zZWN1cml0eS9pbmRleC5yc3QKQEAgLTE3 LDMgKzE3LDQgQEAgU2VjdXJpdHkgRG9jdW1lbnRhdGlvbgogICAgdHBtL2luZGV4CiAgICBkaWdz aWcKICAgIGxhbmRsb2NrCisgICBpcGUKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vc2VjdXJp dHkvaXBlLnJzdCBiL0RvY3VtZW50YXRpb24vc2VjdXJpdHkvaXBlLnJzdApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmU2OTFlMDhlMDMwMwotLS0gL2Rldi9udWxsCisr KyBiL0RvY3VtZW50YXRpb24vc2VjdXJpdHkvaXBlLnJzdApAQCAtMCwwICsxLDMzOSBAQAorLi4g U1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKKworSW50ZWdyaXR5IFBvbGljeSBFbmZv cmNlbWVudCAoSVBFKSAtIERlc2lnbiBEb2N1bWVudHMKKz09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CisKKy4uIE5PVEU6OgorCisgICBUaGlzIGlz IHRoZSBkb2N1bWVudGF0aW9uIGZvciBrZXJuZWwgZGV2ZWxvcGVycyBhbmQgb3RoZXIgaW5kaXZp ZHVhbHMKKyAgIHdobyB3YW50IHRvIHVuZGVyc3RhbmQgdGhlIHJlYXNvbiBiZWhpbmQgd2h5IElQ RSBpcyBkZXNpZ25lZCB0aGUgd2F5IGl0CisgICBpcywgYXMgd2VsbCBhcyBhIHRvdXIgb2YgdGhl IGltcGxlbWVudGF0aW9uLiBJZiB5b3UncmUgbG9va2luZyBmb3IKKyAgIGRvY3VtZW50YXRpb24g b24gdGhlIHVzYWdlIG9mIElQRSwgcGxlYXNlIHNlZQorICAgOnJlZjpgRG9jdW1lbnRhdGlvbi9h ZG1pbi1ndWlkZS9MU00vaXBlLnJzdGAKKworUm9sZSBhbmQgU2NvcGUKKy0tLS0tLS0tLS0tLS0t CisKK0lQRSBvcmlnaW5hbGx5IHN0YXJ0ZWQgd2l0aCBhIHNpbXBsZSBnb2FsOiBjcmVhdGUgYSBz eXN0ZW0gdGhhdCBjYW4KK2Vuc3VyZSB0aGF0IG9ubHkgdHJ1c3RlZCB1c2VybW9kZSBiaW5hcmll cyBhcmUgYWxsb3dlZCB0byBiZSBleGVjdXRlZC4KKworRHVyaW5nIHRoZSBkZXNpZ24gcGhhc2Ug aXQgd2FzIGFwcGFyZW50IHRoYXQgdGhlcmUgYXJlIG11bHRpcGxlIHN5c3RlbXMKK3dpdGhpbiB0 aGUgTGludXgga2VybmVsIHRoYXQgY2FuIHByb3ZpZGUgc29tZSBsZXZlbCBvZiBpbnRlZ3JpdHkK K3ZlcmlmaWNhdGlvbiwgYW5kIGJ5IGFzc29jaWF0aW9uLCB0cnVzdCBmb3IgaXRzIGNvbnRlbnQ6 CisKKyAgMS4gRE0tVmVyaXR5CisgIDIuIEZTLVZlcml0eQorICAzLiBJTUEgKyBFVk0KKworSG93 ZXZlciwgb2YgdGhvc2Ugc3lzdGVtcyBvbmx5IHRoZSB0aGlyZCBvcHRpb24gaGFzIHRoZSBhYmls aXR5IHRvIGVuZm9yY2UKK3RydXN0IHJlcXVpcmVtZW50cyBvbiB0aGUgd2hvbGUgc3lzdGVtLiBJ dHMgYXJjaGl0ZWN0dXJlLCBob3dldmVyIGlzIGNlbnRlcmVkCithcm91bmQgaXRzIG93biBmb3Jt IG9mIHZlcmlmaWNhdGlvbnMsIGFuZCBhIG11bHRpdHVkZSBvZiBhY3Rpb25zIHN1cnJvdW5kaW5n Cit0aG9zZSB2ZXJpZmljYXRpb25zIHdpdGggdmFyaW91cyBwdXJwb3NlcywgdGhlIG1vc3QgcHJv bWluZW50IGJlaW5nIG1lYXN1cmVtZW50CithbmQgdmVyaWZpY2F0aW9uIChhcHByYWlzYWwpLiBU aGlzIG1ha2VzIGl0IHVuc3VpdGFibGUgZnJvbSBhIGxheWVyaW5nIGFuZAorYXJjaGl0ZWN0dXJh bCBwdXJwb3NlLCBhcyBJUEUncyBnb2FsIGlzIGxpbWl0ZWQgdG8gZW5zdXJlIGp1c3QgdHJ1c3Rl ZCB1c2VybW9kZQorYmluYXJpZXMgYXJlIGV4ZWN1dGVkLCB3aXRoIHRoZSBpbnRlbnRpb25hbCBn b2FsIG9mIHN1cHBvcnRpbmcgbXVsdGlwbGUgbWV0aG9kcworZnJvbSBhIGhpZ2hlciBzdWJzeXN0 ZW0gbGF5ZXIgKGkuZS4gZnMsIGJsb2NrLCBvciBzdXBlcl9ibG9jaykuCisKK1RoZSB0d28gb3Ro ZXIgb3B0aW9ucywgZG0tdmVyaXR5IGFuZCBmcy12ZXJpdHkgYXJlIG1pc3NpbmcgYSBjcnVjaWFs IGNvbXBvbmVudAordG8gYWNjb21wbGlzaCB0aGUgZ29hbCBvZiBJUEU6IGEgcG9saWN5IHRvIGlu ZGljYXRlIHRoZSByZXF1aXJlbWVudHMgb2YKK2Fuc3dlcmluZyB0aGUgcXVlc3Rpb24gIldoYXQg aXMgVHJ1c3RlZD8iIGFuZCBhIHN5c3RlbS13aWRlIGxldmVsIG9mIGVuZm9yY2luZwordGhvc2Ug cmVxdWlyZW1lbnRzLgorCitUaGVyZWZvcmUsIElQRSB3YXMgZGVzaWduZWQgYXJvdW5kOgorCisg IDEuIEVhc3kgY29uZmlndXJhdGlvbiBvZiB0cnVzdCBtZWNoYW5pc21zCisgIDIuIEVhc2Ugb2Yg aW50ZWdyYXRpb24gd2l0aCBvdGhlciBsYXllcnMKKyAgMy4gRWFzZSBvZiB1c2UgZm9yIHBsYXRm b3JtIGFkbWluaXN0cmF0b3JzLgorCitEZXNpZ24gRGVjaXNpb25zCistLS0tLS0tLS0tLS0tLS0t CisKK1BvbGljeQorfn5+fn5+CisKK1BsYWluIFRleHQKK15eXl5eXl5eXl4KKworVW5saWtlIG90 aGVyIExTTXMsIElQRSdzIHBvbGljeSBpcyBwbGFpbi10ZXh0LiBUaGlzIGludHJvZHVjZXMgc2xp Z2h0bHkgbGFyZ2VyCitwb2xpY3kgZmlsZXMgdGhhbiBvdGhlciBMU01zLCBidXQgc29sdmVzIHR3 byBtYWpvciBwcm9ibGVtcyB0aGF0IG9jY3VycyB3aXRoCitvdGhlciB0cnVzdC1iYXNlZCBhY2Nl c3MgY29udHJvbCBzeXN0ZW1zLgorCitUaGUgZmlyc3QgaXNzdWUgaXMgb25lIG9mIGNvZGUgbWFp bnRlbmFuY2UgYW5kIGR1cGxpY2F0aW9uLiBUbyBhdXRob3IgcG9saWNpZXMsCit0aGUgcG9saWN5 IGhhcyB0byBiZSBzb21lIGZvcm0gb2Ygc3RyaW5nIHJlcHJlc2VudGF0aW9uIChiZSBpdCBzdHJ1 Y3R1cmVkLAordGhyb3VnaCBYTWwsIEpTT04sIFlBTUwsIGV0Y2V0ZXJhKSwgdG8gYWxsb3cgdGhl IHBvbGljeSBhdXRob3IgdG8gdW5kZXJzdGFuZAord2hhdCBpcyBiZWluZyB3cml0dGVuLiBJbiBh IGh5cG90aGV0aWNhbCBiaW5hcnkgcG9saWN5IGRlc2lnbiwgdGhhdCBhIHNlcmlhbGl6ZXIKK211 c3QgYmUgd3JpdHRlbiB0byB3cml0ZSBzYWlkIGJpbmFyeSBmb3JtLCBmb3IgYSAqbWFqb3JpdHkq IG9mIGh1bWFucyB0byBiZQorYWJsZSB0byB1dGlsaXplIGl0IHByb3Blcmx5LgorCitBZGRpdGlv bmFsbHksIGEgZGVzZXJpYWxpemVyIHdpbGwgZXZlbnR1YWxseSBiZSBuZWVkZWQgdG8gdHJhbnNm b3JtIHRoZSBiaW5hcnkKK2JhY2sgaW50byB0ZXh0IHdpdGggYXMgbXVjaCBpbmZvcm1hdGlvbiBw cmVzZXJ2ZWQuIFdpdGhvdXQgYSBkZXNlcmlhbGl6ZXIsIGEKK3VzZXIgb2YgdGhpcyBhY2Nlc3Mg Y29udHJvbCBzeXN0ZW0gd2lsbCBoYXZlIHRvIGtlZXAgYSBsb29rdXAgdGFibGUgb2YgZWl0aGVy CithIGNoZWNrc3VtLCBvciB0aGUgZmlsZSBpdHNlbGYgdG8gdHJ5IHRvIHVuZGVyc3RhbmQgd2hh dCBwb2xpY2llcyBoYXZlIGJlZW4KK2RlcGxveWVkIG9uIHRoaXMgc3lzdGVtIGFuZCB3aGF0IHBv bGljaWVzIGhhdmUgbm90LiBGb3IgYSBzaW5nbGUgdXNlciwgdGhpcworbWF5IGJlIGFscmlnaHQs IGFzIG9sZCBwb2xpY2llcyBjYW4gYmUgZGlzY2FyZGVkIGFsbW9zdCBpbW1lZGlhdGVseSBhZnRl cgordGhlIHVwZGF0ZSB0YWtlcyBob2xkLgorCitGb3IgdXNlcnMgdGhhdCBtYW5hZ2UgZmxlZXRz IGluIHRoZSB0aG91c2FuZHMsIGlmIG5vdCBodW5kcmVkcyBvZiB0aG91c2FuZHMsCit0aGlzIHF1 aWNrbHkgYmVjb21lcyBhbiBpc3N1ZSwgYXMgc3RhbGUgcG9saWNpZXMgZnJvbSB5ZWFycyBhZ28g bWF5IGJlIHByZXNlbnQsCitxdWlja2x5IHJlc3VsdGluZyBpbiB0aGUgbmVlZCB0byByZWNvdmVy IHRoZSBwb2xpY3kgb3IgZnVuZCBleHRlbnNpdmUKK2luZnJhc3RydWN0dXJlIHRvIHRyYWNrIHdo YXQgZWFjaCBwb2xpY3kgY29udGFpbnMuCisKK1NlY29uZGx5LCBhIHNlcmlhbGl6ZXIgaXMgc3Rp bGwgbmVlZGVkIHdpdGggYSBwbGFpbi10ZXh0IHBvbGljeSAoYXMgdGhlIHBsYWluCit0ZXh0IHBv bGljeSBzdGlsbCBoYXMgdG8gYmUgc2VyaWFsaXplZCB0byBhIGRhdGEgc3RydWN0dXJlIGluIHRo ZSBrZXJuZWwpLCBzbworbm90IG11Y2ggaXMgc2F2ZWQuCisKK1RoZSBzZWNvbmQgaXNzdWUgaXMg b25lIG9mIHRyYW5zcGFyZW5jeS4gQXMgSVBFIGNvbnRyb2xzIGFjY2VzcyBiYXNlZCBvbiB0cnVz dCwKK2l0J3MgcG9saWN5IG11c3QgYWxzbyBiZSB0cnVzdGVkIHRvIGJlIGNoYW5nZWQuIFRoaXMg aXMgZG9uZSB0aHJvdWdoIHNpZ25hdHVyZXMsCitjaGFpbmluZyB0byB0aGUgU1lTVEVNX1RSVVNU RURfS0VZUklORy4gVGhlIGNvbmZpZGVuY2Ugb2Ygc2lnbmluZyBhIHBsYWluLXRleHQKK3BvbGlj eSBpbiB3aGljaCB5b3UgY2FuIHNlZSBldmVyeSBhc3BlY3Qgb2Ygd2hhdCBpcyBiZWluZyBzaWdu ZWQgaXMgYSBzdGVwIGhpZ2hlcgordGhhbiBzaWduaW5nIGFuIG9wYXF1ZSBiaW5hcnkgYmxvYi4K KworQm9vdCBQb2xpY3kKK35+fn5+fn5+fn5+CisKK0FkZGl0aW9uYWxseSwgSVBFIHNob3VsZG4n dCBoYXZlIGFueSBvYnZpb3VzIGdhcHMgaW4gaXRzIGVuZm9yY2VtZW50IHN0b3J5LgorVGhhdCBt ZWFucywgYSBwb2xpY3kgdGhhdCBjb25maWd1cmVzIHRydXN0IHJlcXVpcmVtZW50cywgaWYgc3Bl Y2lmaWVkLCBtdXN0CitiZSBlbmZvcmNlZCBhcyBzb29uIGFzIHRoZSBrZXJuZWwgc3RhcnRzIHVw LiBUaGF0IGNhbiBiZSBhY2NvbXBsaXNoZWQgb25lCitvZiB0aHJlZSB3YXlzOgorCisgIDEuIFRo ZSBwb2xpY3kgZmlsZShzKSBsaXZlIG9uIGRpc2sgYW5kIHRoZSBrZXJuZWwgbG9hZHMgdGhlIHBv bGljeSBwcmlvcgorICAgICB0byBhbiBjb2RlIHBhdGggdGhhdCB3b3VsZCByZXN1bHQgaW4gYW4g ZW5mb3JjZW1lbnQgZGVjaXNpb24uCisgIDIuIFRoZSBwb2xpY3kgZmlsZShzKSBhcmUgcGFzc2Vk IGJ5IHRoZSBib290bG9hZGVyIHRvIHRoZSBrZXJuZWwsIHdobworICAgICBwYXJzZXMgdGhlIHBv bGljeS4KKyAgMy4gVGhlcmUgaXMgYSBwb2xpY3kgZmlsZSB0aGF0IGlzIGNvbXBpbGVkIGludG8g dGhlIGtlcm5lbCB0aGF0IGlzCisgICAgIHBhcnNlZCBhbmQgZW5mb3JjZWQgb24gaW5pdGlhbGl6 YXRpb24uCisKK1RoZSBmaXJzdCBvcHRpb24gaGFzIHByb2JsZW1zOiB0aGUga2VybmVsIHJlYWRp bmcgZmlsZXMgZnJvbSB1c2Vyc3BhY2UKK2lzIHR5cGljYWxseSBkaXNjb3VyYWdlZCBhbmQgdmVy eSB1bmNvbW1vbiBpbiB0aGUga2VybmVsLgorCitUaGUgc2Vjb25kIG9wdGlvbiBhbHNvIGhhcyBw cm9ibGVtczogTGludXggc3VwcG9ydHMgYSB2YXJpZXR5IG9mIGJvb3Rsb2FkZXJzCithY3Jvc3Mg aXRzIGVudGlyZSBlY29zeXN0ZW0gLSBldmVyeSBib290bG9hZGVyIHdvdWxkIGhhdmUgdG8gc3Vw cG9ydCB0aGlzCituZXcgbWV0aG9kb2xvZ3kgb3IgdGhlcmUgbXVzdCBiZSBhbiBpbmRlcGVuZGVu dCBzb3VyY2UuIEFkZGl0aW9uYWxseSwgaXQKK3dvdWxkIGxpa2VseSByZXN1bHQgaW4gbW9yZSBk cmFzdGljIGNoYW5nZXMgdG8gdGhlIGtlcm5lbCBzdGFydHVwIHRoYW4KK25lY2Vzc2FyeS4KKwor VGhlIHRoaXJkIG9wdGlvbiBpcyB0aGUgYmVzdCBidXQgaXQncyBpbXBvcnRhbnQgdG8gYmUgYXdh cmUgdGhhdCB0aGUgcG9saWN5Cit3aWxsIHRha2UgZGlzayBzcGFjZSBhZ2FpbnN0IHRoZSBrZXJu ZWwgaXQncyBjb21waWxlZCBpbi4gSXQncyBpbXBvcnRhbnQgdG8KK2tlZXAgdGhpcyBwb2xpY3kg Z2VuZXJhbGl6ZWQgZW5vdWdoIHRoYXQgdXNlcnNwYWNlIGNhbiBsb2FkIGEgbmV3LCBtb3JlCitj b21wbGljYXRlZCBwb2xpY3ksIGJ1dCByZXN0cmljdGl2ZSBlbm91Z2ggdGhhdCBpdCB3aWxsIG5v dCBvdmVyYXV0aG9yaXplCithbmQgY2F1c2Ugc2VjdXJpdHkgaXNzdWVzLgorCitUaGUgaW5pdHJh bWZzLCBwcm92aWRlcyBhIHdheSB0aGF0IHRoaXMgYm9vdHVwIHBhdGggY2FuIGJlIGVzdGFibGlz aGVkLiBUaGUKK2tlcm5lbCBzdGFydHMgd2l0aCBhIG1pbmltYWwgcG9saWN5LCB0aGF0IGp1c3Qg dHJ1c3RzIHRoZSBpbml0cmFtZnMuIEluc2lkZQordGhlIGluaXRyYW1mcywgd2hlbiB0aGUgcmVh bCByb290ZnMgaXMgbW91bnRlZCwgYnV0IG5vdCB5ZXQgdHJhbnNmZXJyZWQgdG8sCitpdCBkZXBs b3lzIGFuZCBhY3RpdmF0ZXMgYSBwb2xpY3kgdGhhdCB0cnVzdHMgdGhlIG5ldyByb290IGZpbGVz eXN0ZW0ocykuCitUaGlzIHByZXZlbnRzIG92ZXJhdXRob3JpemF0aW9uIGF0IGFueSBzdGVwLCBh bmQga2VlcHMgdGhlIGtlcm5lbCBwb2xpY3kKK3RvIGEgbWluaW1hbCBzaXplLgorCitTdGFydHVw CiteXl5eXl5eCisKK05vdCBldmVyeSBzeXN0ZW0sIGhvd2V2ZXIgc3RhcnRzIHdpdGggYW4gaW5p dHJhbWZzLCBzbyB0aGUgc3RhcnR1cCBwb2xpY3kKK2NvbXBpbGVkIGludG8gdGhlIGtlcm5lbCB3 aWxsIG5lZWQgc29tZSBmbGV4aWJpbGl0eSB0byBleHByZXNzIGhvdyB0cnVzdAoraXMgZXN0YWJs aXNoZWQgZm9yIHRoZSBuZXh0IHBoYXNlIG9mIHRoZSBib290dXAuIFRvIHRoaXMgZW5kLCBpZiB3 ZSBqdXN0CittYWtlIHRoZSBjb21waWxlZC1pbiBwb2xpY3kgYSBmdWxsIElQRSBwb2xpY3ksIGl0 IGFsbG93cyBzeXN0ZW0gYnVpbGRlcnMKK3RvIGV4cHJlc3MgdGhlIGZpcnN0IHN0YWdlIGJvb3R1 cCByZXF1aXJlbWVudHMgYXBwcm9wcmlhdGVseS4KKworVXBkYXRhYmxlLCBSZWJvb3RsZXNzIFBv bGljeQorfn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fgorCitBcyB0aW1lIGdvZXMgb24sIHRy dXN0IHJlcXVpcmVtZW50cyBhcmUgY2hhbmdlZCAodnVsbmVyYWJpbGl0aWVzIGFyZSBmb3VuZCBp bgorcHJldmlvdXNseSB0cnVzdGVkIGFwcGxjYXRpb25zLCBrZXlzIHJvbGwsIGV0Y2V0ZXJhKS4g VXBkYXRpbmcgYSBrZXJuZWwgdG8KK2NoYW5nZSB0aGUgdHJ1c3QgcmVxdWlyZW1lbnRzIGlzIG5v dCBhbHdheXMgYSBzdWl0YWJsZSBvcHRpb24sIGFzIHVwZGF0ZXMKK2FyZSBub3QgYWx3YXlzIHJp c2stZnJlZSBhbmQgd2l0aG91dCBjb25zZXF1ZW5jZS4gVGhpcyBtZWFucyBJUEUgcmVxdWlyZXMK K2EgcG9saWN5IHRoYXQgY2FuIGJlIGNvbXBsZXRlbHkgdXBkYXRlZCBmcm9tIGEgc291cmNlIGV4 dGVybmFsIHRvIHRoZSBrZXJuZWwuCisKK0FkZGl0aW9uYWxseSwgc2luY2UgdGhlIGtlcm5lbCBp cyByZWxhdGl2ZWx5IHN0YXRlbGVzcyBiZXR3ZWVuIGludm9jYXRpb25zLAorYW5kIHdlJ3ZlIGVz dGFibGlzaGVkIHRoYXQgcmVhZGluZyBwb2xpY3kgZmlsZXMgb2ZmIHRoZSBkaXNrIGZyb20ga2Vy bmVsCitzcGFjZSBpcyBhICpiYWQgaWRlYSosIHRoZW4gdGhlIHBvbGljeSB1cGRhdGVzIGhhdmUg dG8gYmUgZG9uZSByZWJvb3RsZXNzbHkuCisKK1RvIGFsbG93IGFuIHVwZGF0ZSBmcm9tIGFuIGV4 dGVybmFsIHNvdXJjZSwgaXQgY291bGQgYmUgcG90ZW50aWFsbHkgbWFsaWNpb3VzLAorc28gdGhp cyBwb2xpY3kgbmVlZHMgdG8gaGF2ZSBhIHdheSB0byBiZSBpZGVudGlmaWVkIGFzIHRydXN0ZWQu IFRoaXMgd2lsbCBiZQorZG9uZSB2aWEgYSBzaWduYXR1cmUsIGNoYWluZWQgdG8gYSB0cnVzdCBz b3VyY2UgaW4gdGhlIGtlcm5lbC4gQXJiaXRyYXJpbHksCit0aGlzIHdpbGwgYmUgdGhlIGBgU1lT VEVNX1RSVVNURURfS0VZUklOR2BgLCBhIGtleXJpbmcgdGhhdCBpcyBpbml0aWFsbHkKK3BvcHVs YXRlZCBhdCBrZXJuZWwgY29tcGlsZS10aW1lLCBhcyB0aGlzIG1hdGNoZXMgdGhlIGV4cGVjdGF0 aW9uIHRoYXQgdGhlCithdXRob3Igb2YgdGhlIGNvbXBpbGVkLWluIHBvbGljeSBkZXNjcmliZWQg YWJvdmUgaXMgdGhlIHNhbWUgZW50aXR5IHRoYXQgY2FuCitkZXBsb3kgcG9saWN5IHVwZGF0ZXMu CisKK0FudGktUm9sbGJhY2sgLyBBbnRpLVJlcGxheQorfn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+ fn5+CisKK092ZXIgdGltZSwgdnVsbmVyYWJpbGl0aWVzIGFyZSBmb3VuZCBhbmQgdHJ1c3RlZCBy ZXNvdXJjZXMgbWF5IG5vdCBiZQordHJ1c3RlZCBhbnltb3JlLiBJUEUncyBwb2xpY3kgaGFzIG5v IGV4Y2VwdGlvbiB0byB0aGlzLiBUaGVyZSBjYW4gYmUKK2luc3RhbmNlcyB3aGVyZSBhIG1pc3Rh a2VuIHBvbGljeSBhdXRob3IgZGVwbG95cyBhbiBpbnNlY3VyZSBwb2xpY3ksCitiZWZvcmUgY29y cmVjdGluZyBpdCB3aXRoIGEgc2VjdXJlIHBvbGljeS4KKworQXNzdW1pbmcgdGhhdCBhcyBzb29u IGFzIHRoZSBpbnNlY3VyZSBwb2xpY3kgd2FzIHNpZ25lZCwgYW4gYXR0YWNrZXIKK2NhbiBhY3F1 aXJlIHRoZSBpbnNlY3VyZSBwb2xpY3ksIElQRSBuZWVkcyBhIHdheSB0byBwcmV2ZW50IHJvbGxi YWNrCitmcm9tIHRoZSBzZWN1cmUgcG9saWN5IHVwZGF0ZSwgdG8gdGhlIGluc2VjdXJlIHBvbGlj eSB1cGRhdGUuCisKK0luaXRpYWxseSwgSVBFJ3MgcG9saWN5IGNhbiBoYXZlIGEgcG9saWN5X3Zl cnNpb24gdGhhdCBzdGF0ZXMgdGhlCittaW5pbXVtIHJlcXVpcmVkIHZlcnNpb24gYWNyb3NzIGFs bCBwb2xpY2llcyB0aGF0IGNhbiBiZSBhY3RpdmUgb24KK3RoZSBzeXN0ZW0uIFRoaXMgd2lsbCBw cmV2ZW50IHJvbGxiYWNrIHdoaWxlIHRoZSBzeXN0ZW0gaXMgbGl2ZS4KKworLi4gV0FSTklORzo6 CisKKyAgSG93ZXZlciwgc2luY2UgdGhlIGtlcm5lbCBpcyBzdGF0ZWxlc3MgYWNyb3NzIGJvb3Rz LCB0aGlzIHBvbGljeQorICB2ZXJzaW9uIHdpbGwgYmUgcmVzZXQgdG8gMC4wLjAgb24gdGhlIG5l eHQgYm9vdC4gU3lzdGVtIGJ1aWxkZXJzCisgIG5lZWQgdG8gYmUgYXdhcmUgb2YgdGhpcywgYW5k IGVuc3VyZSB0aGUgbmV3IHNlY3VyZSBwb2xpY2llcyBhcmUKKyAgZGVwbG95ZWQgQVNBUCBhZnRl ciBhIGJvb3QgdG8gZW5zdXJlIHRoYXQgdGhlIHdpbmRvdyBvZgorICBvcHBvcnR1bml0eSBpcyBt aW5pbWFsIGZvciBhbiBhdHRhY2tlciB0byBkZXBsb3kgdGhlIGluc2VjdXJlIHBvbGljeVsjXV8u CisKK0ltcGxlbWVudGF0aW9uCistLS0tLS0tLS0tLS0tLQorCitDb250ZXh0Cit+fn5+fn5+CisK K0FuIGBgaXBlX2NvbnRleHRgYCBzdHJ1Y3R1cmUgcmVwcmVzZW50IGEgY29udGV4dCBpbiB3aGlj aCBJUEUgY2FuIGJlIGVuZm9yY2VkLgorSXQgY29udGFpbnMgYWxsIHRoZSB0eXBpY2FsIHZhbHVl cyB0aGF0IG9uZSB3b3VsZCBleHBlY3QgYXJlIGdsb2JhbDoKKworICAxLiBFbmZvcmNlL1Blcm1p c3NpdmUgU3RhdGUKKyAgMi4gQWN0aXZlIFBvbGljeQorICAzLiBMaXN0IG9mIFBvbGljaWVzCisg IDQuIFN1Y2Nlc3MgQXVkaXRpbmcgU3RhdGUKKworQSBjb250ZXh0IGlzIGNyZWF0ZWQgYXQgYm9v dCB0aW1lIGFuZCBhdHRhY2hlZCB0byB0aGUgYGB0YXNrX3N0cnVjdGBgIGFzIGEKK3NlY3VyaXR5 IGJsb2IuIEFsbCBuZXcgYGB0YXNrX3N0cnVjdGBgIHdpbGwgaW5oZXJpdCB0aGUgb3JpZ2luYWwg YGBpcGVfY29udGV4dGBgCit0aGF0IHRoZSBzeXN0ZW0gYm9vdHMgd2l0aC4gVGhpcyBzdHJ1Y3R1 cmUgaXMgcmVmZXJlbmNlIGNvdW50ZWQuCisKK0luaXRpYWxseSwgYSBzeXN0ZW0gd2lsbCBvbmx5 IGV2ZXIgaGF2ZSBvbmUgY29udGV4dDsgZm9yIGBgaW5pdGBgLCBhbmQgc2luY2UKK2FsbCB1c2Vy c3BhY2UgcHJvY2Vzc2VzIGFyZSBkZXNjZW5kZW50cyBvZiBgYGluaXRgYCwgYWxsIG9mIHVzZXJt b2RlIHdpbGwgaGF2ZQordGhpcyBleGVjdXRpb24gY29udGV4dC4KKworVGhpcyBhcmNoaXRlY3R1 cmUgaGFzIHNvbWUgYWR2YW50YWdlcyAtIG5hbWVseSwgaXQgYWxsb3dzIGZvciBhIG5hdHVyYWwK K2V4dGVuc2lvbiBmb3IgSVBFIHRvIGNyZWF0ZSBuZXcgY29udGV4dHMgLSBzdWNoIGFzIGFwcGx5 aW5nIGEgZGlmZmVyZW50Citwb2xpY3kgZm9yIHRydXN0IGZvciBhIHByaXZsZWRnZWQgY29udGFp bmVyIGZyb20gdGhhdCBvZiBpdHMgaG9zdC4KKworQW5vbnltb3VzIE1lbW9yeQorfn5+fn5+fn5+ fn5+fn5+fgorCitBbm9ueW1vdXMgbWVtb3J5IGlzbid0IHRyZWF0ZWQgYW55IGRpZmZlcmVudGx5 IHRoYW4gYW55IG90aGVyIGFjY2VzcyBpbiBJUEUuCitXaGVuIGFub255bW91cyBtZW1vcnkgaXMg bWFwcGVkIHdpdGggYGArWGBgLCBpdCBzdGlsbCBjb21lcyBpbnRvIHRoZSBgYGZpbGVfbW1hcGBg Citob29rLCBidXQgd2l0aCBhIGBgTlVMTGBgIGZpbGUgb2JqZWN0LiBUaGlzIGlzIHN1Ym1pdHRl ZCB0byB0aGUgZXZhbHVhdGlvbiwgbGlrZQorYW55IG90aGVyIGZpbGUsIGhvd2V2ZXIsIGFsbCB0 cnVzdCBtZWNoYW5pc21zIHdpbGwgcmV0dXJuIGZhbHNlIGFzIHRoZXJlIGlzCitub3RoaW5nIHRv IGV2YWx1YXRlLiBUaGlzIG1lYW5zIGFub255bW91cyBtZW1vcnkgZXhlY3V0aW9uIGlzIHN1Ympl Y3QgdG8KK3doYXRldmVyIHRoZSBgYERFRkFVTFRgYCBpcyBmb3IgYGBFWEVDVVRFYGAuCisKKy4u IFdBUk5JTkc6OgorCisgIFRoaXMgYWxzbyBvY2N1cnMgd2l0aCB0aGUgYGBrZXJuZWxfbG9hZF9k YXRhYGAgaG9vaywgd2hpY2ggaXMgdXNlZCBieSBzaWduZWQKKyAgYW5kIGNvbXByZXNzZWQga2Vy bmVsIG1vZHVsZXMuIFVzaW5nIHRoaXMgd2l0aCBJUEUgd2lsbCByZXN1bHQgaW4gdGhlCisgIGBg REVGQVVMVGBgIGZvciBgYEtNT0RVTEVgYCBiZWluZyB0YWtlbi4KKworUG9saWN5IFBhcnNlcgor fn5+fn5+fn5+fn5+fgorCitUaGUgcG9saWN5IHBhcnNlciBpcyB0aGUgc3RhcGxlIG9mIElQRSdz IGZ1bmN0aW9uYWxpdHksIHByb3ZpZGluZyBhCittb2R1bGFyIHdheSB0byBpbnRyb2R1Y2UgbmV3 IGludGVncmF0aW9ucy4gQXMgc3VjaCwgaXQncyBmdW5jdGlvbmFsaXR5CitpcyBkaXZpZGVkIGlu dG8gNCBwYXNzZXMuIFRoaXMgZ2l2ZXMgdGhlIGJlbmVmaXQgb2YgY2xlYXJseSBkZWZpbmVkIHBy ZQorYW5kIHBvc3QtY29uZGl0aW9uIHN0YXRlcyBhZnRlciBlYWNoIHBhc3MsIGdpdmluZyBkZWJ1 Z2dpbmcgYmVuZWZpdHMKK3doZW4gc29tZXRoaW5nIGdvZXMgd3JvbmcuCisKK0luIHBhc3MxLCB0 aGUgcG9saWN5IGlzIHRyYW5zZm9ybWVkIGludG8gYSAyRCwgamFnZ2VkLCBhcnJheSBvZiB0b2tl bnMsCit3aGVyZSBhIHRva2VuIGlzIGRlZmluZWQgYXMgYSAia2V5PXZhbHVlIiBwYWlyLCBvciBh IHNpbmd1bGFyIHRva2VuLAorZm9yIGV4YW1wbGUsICJERUZBVUxUIi4gUXVvdGVkIHZhbHVlcyBh cmUgcGFyc2VkIGFzIGEgc2luZ2xlIHZhbHVlLXBhaXIsCit3aGljaCBpcyB3aHkgYGA8bGludXgv cGFyc2VyLmg+YGAgcGFyc2VyIGlzIGluc3VmZmljaWVudCAtIGl0IGRvZXMgbm90Cit1bmRlcnN0 YW5kIHF1b3RlZCB2YWx1ZXMuCisKK0luIHBhc3MyLCB0aGUgamFnZ2VkIGFycmF5IHByb2R1Y2Vk IGluIHBhc3MxIGlzIHBhcnRpYWxseSBpbmdlc3RlZCwKK2NyZWF0aW5nIGEgcGFydGlhbGx5IHBv cHVsYXRlZCBwb2xpY3ksIHdoZXJlIG5vIHJ1bGVzIGhhdmUgYmVlbiBwYXJzZWQKK3lldCwgYnV0 IG1ldGFkYXRhIGFuZCByZWZlcmVuY2VzIGFyZSBjcmVhdGVkIHRoYXQgY2FuIGJlIG5vdyB1c2Vk IGluCitwYXNzMy4KKworRXhhbXBsZXMgb2YgcGFyc2luZyB0aGF0IHdvdWxkIGJlIGRvbmUgaW4g cGFzczI6OgorCisgIHBvbGljeV9uYW1lPSJteS1wb2xpY3kiIHBvbGljeV92ZXJzaW9uPTAuMC4w CisgIERFRkFVTFQgYWN0aW9uPURFTlkKKworQXMgdGhlc2UgbGluZXMgYXJlIG5vdCBydWxlcyBp biBvZiB0aGVtc2VsdmVzLCBidXQgZWZmZWN0IHRoZSBwb2xpY3kKK2l0c2VsZi4KKworSW4gcGFz czMsIHRoZSByZW1haW5pbmcgbGluZXMgaW4gdGhlIGphZ2dlZCBhcnJheSBwcm9kdWNlZCBpbiBw YXNzMSBhbmQKK3BhcnRpYWxseS1jb25zdW1lZCBpbiBwYXNzMiBpcyBjb25zdW1lZCBjb21wbGV0 ZWx5LCBwYXJzaW5nIGFsbCB0aGUKK3J1bGVzIGluIElQRSBwb2xpY3kuIFRoaXMgY2FuIGxldmVy YWdlIHRoZSBkYXRhIHVzZWQgaW4gcGFzczIuCitFeGFtcGxlIGxpbmVzIHBhcnNlZCBpbiBwYXNz Mzo6CisKKyAgb3A9RVhFQ1VURSBkbXZlcml0eV9zaWduYXR1cmU9VFJVRSBhY3Rpb249REVOWQor CitBIHJ1bGUgaXMgc3RyaWN0bHkgZGVmaW5lZCBhcyBzdGFydHMgd2l0aCB0aGUgb3AgdG9rZW4g YW5kIGVuZHMgd2l0aAordGhlIGFjdGlvbiB0b2tlbi4KKworQWZ0ZXIgdGhpcyBwYXNzLCBhIHBv bGljeSBpcyBkZWVtZWQgZnVsbHkgY29uc3RydWN0ZWQgYnV0IG5vdCB5ZXQgdmFsaWQsCithcyB0 aGVyZSBjb3VsZCBiZSBtaXNzaW5nIGVsZW1lbnRzIChzdWNoIGFzIGEgcmVxdWlyZWQgREVGQVVM VCBmb3IgYWxsCithY3Rpb25zLCBtaXNzaW5nIGEgcG9saWN5X25hbWUpLCBldGMuCisKK0FkZGl0 aW9uYWxseSwgYXMgSVBFIHBvbGljeSBzdXBwb3J0cyBvcGVyYXRpb24gYWxpYXNlcyAoYW4gb3Bl cmF0aW9uCit0aGF0IG1hcHMgdG8gdHdvIG9yIG1vcmUgb3RoZXIgb3BlcmF0aW9ucyksIHN1cHBv cnQgaXMgYWRkZWQgaGVyZS4KKworVGhlIHB1cnBvc2UgaW4gdGhlIGRpdmlzaW9uIG9mIHBhc3My IGFuZCBwYXNzMyBpcyB0byBhbGxvdyBmb3IKK2RlY2xhcmF0aW9ucyBpbiBJUEUncyBzeW50YXgu IEZvciBleGFtcGxlLCBpbiB0aGUgZnV0dXJlLCBpZiB3ZSB3ZXJlCit0byBpbnRyb2R1Y2UgdGhp cyBzeW50YXg6OgorCisgIENFUlRJRklDQVRFPUZha2VDZXJ0IHRodW1icHJpbnQ9REVBREJFRUYg Q049IkNvbnRvc28iCisKK0FuZCB1c2UgaXQgbGlrZSBzbzo6CisKKyAgb3A9RVhFQ1VURSBkbXZl cml0eV9zaWduYXR1cmU9RmFrZUNlcnQgYWN0aW9uPUFMTE9XCisKK1RoZSBgYENFUlRJRklDQVRF YGAgbGluZXMgY2FuIGJlIGdyb3VwZWQgdG9nZXRoZXIgYXQgYW55IHBsYWNlIGluIHRoZSBwb2xp Y3kuCisKK0FmdGVyIHBhc3MzLCBhbiBJUEUgcG9saWN5IGNhbiBzdGlsbCBiZSB0ZWNobmljYWxs eSBpbnZhbGlkIGZvciB1c2UsIGFzCithIHBvbGljeSBjYW4gYmUgbGFja2luZyByZXF1aXJlZCBl bGVtZW50cyB0byBlbGltaW5hdGVkIHRoZSBwb3NzaWJpbGl0eQorb2YgdW5kZWZpbmVkIG9yIHVu a25vd24gYmVoYXZpb3IuCisKK0EgY29uY3JldGUgZXhhbXBsZSBpcyB3aGVuIGEgcG9saWN5IGRv ZXMgbm90IGRlZmluZSBhIGRlZmF1bHQgYWN0aW9uIGZvcgorYWxsIHBvc3NpYmlsaXRpZXM6Ogor CisgIERFRkFVTFQgb3A9RVhFQ1VURSBhY3Rpb249QUxMT1cKKworQXQgdGhpcyBwb2ludCwgd2hp bGUgYSB0ZWNobmljYWxseSBzeW50YWN0aWNhbGx5IGFuZCBzZW1hbnRpY2FsbHkgdmFsaWQKK3Bv bGljeSwgaXQgZG9lcyBub3QgY29udGFpbiBlbm91Z2ggaW5mb3JtYXRpb24gdG8gZGV0ZXJtaW5l IHdoYXQgc2hvdWxkCitiZSBkb25lIGZvciBhbiBvcGVyYXRpb24gb3RoZXIgdGhhbiAiRVhFQ1VU RSIuIEFzIElQRSdzIGRlc2lnbgorZXhwbGljaXRseSBwcm9oaWJpdHMgdGhlIGltcGxpY2l0IHNl dHRpbmcgb2YgYSBERUZBVUxULCBpdCBpcyBpbXBvcnRhbnQKK2ZvciBjYXNlcyBsaWtlIHRoZXNl IGFyZSBwcmV2ZW50ZWQgZnJvbSBvY2N1cnJpbmcuCisKK1RvIHJlc29sdmUgYWxsIHRoZXNlIGNh c2VzLCBhIGZpbmFsIGNoZWNrIG9uIHRoZSBwb2xpY3kgaXMgZG9uZSB0byBlbnN1cmUKK2l0IHZh bGlkIGZvciB1c2UuCisKK0luIGFsbCBjYXNlcywgdGhlIHBhcnNlciBpcyB0aGUgbnVtYmVyIG9u ZSBib3R0bGVuZWNrIHdoZW4gaXQgY29tZXMgdG8KK0lQRSdzIHBlcmZvcm1hbmNlLCBidXQgaGFz IHRoZSBiZW5lZml0IG9mIGhhcHBlbmluZyByYXJlbHksIGFuZCBhcyBhCitkaXJlY3QgY29uc2Vx dWVuY2Ugb2YgdXNlci1pbnB1dC4KKworTW9kdWxlIHZzIFBhcnNlcgorfn5+fn5+fn5+fn5+fn5+ fgorCitBICJtb2R1bGUiLCAidHJ1c3QgcHJvdmlkZXIiLCBvciAicHJvcGVydHkiIGFzIGRlZmlu ZWQgaW4gSVBFJ3MgY29kZSBhbmQKK2NvbW1pdHMgaXMgYW4gaW50ZWdyYXRpb24gd2l0aCBhbiBl eHRlcm5hbCBzdWJzeXN0ZW0gdGhhdCBwcm92aWRlcyBhIHdheQordG8gaWRlbnRpZnkgYSByZXNv dXJjZSBhcyB0cnVzdGVkLiBJdCdzIHRoZSBjb2RlIHRoYXQgcG93ZXJzIHRoZSBrZXk9dmFsdWUK K3BhaXJzIGluIGJldHdlZW4gdGhlIGBgb3BgYCB0b2tlbiBhbmQgdGhlIGBgYWN0aW9uYGAgdG9r ZW4uIFRoZXNlIGFyZSBjYWxsZWQKK2luIHBhc3MzIHdoZW4gcGFyc2luZyBhIHBvbGljeSAodmlh IHRoZSBgYHBhcnNlYGAgbWV0aG9kKSwgYW5kIGR1cmluZworZXZhbHVhdGlvbiB3aGVuIGV2YWx1 YXRpbmcgYSBhY2Nlc3MgYXR0ZW1wdCAodmlhIHRoZSBgYGV2YWxgYCBtZXRob2QpLiBUaGVzZQor ZGlzY3JldGUgbW9kdWxlcyBhcmUgc2luZ2xlIGZpbGVzIGluIGBgc2VjdXJpdHkvaXBlL21vZHVs ZXNgYCBhbmQgYXJlCit2ZXJzaW9uZWQgaW5kZXBlbmRlbnRseS4gVGhlIGRvY3VtZW50YXRpb24g aW4gdGhlIGFkbWluIGd1aWRlIGFuZCBiZSB1c2VkCit0byBjcm9zcyByZWZlcmVuY2Ugd2hhdCB2 ZXJzaW9uIHN1cHBvcnRzIHdoYXQgc3ludGF4LgorCitBICJwYXJzZXIiLCBvbiB0aGUgb3RoZXIg aGFuZCBpcyBhIGRpc2NyZXRlIHVuaXQgb2YgY29kZSB0aGF0IGlzICpvbmx5KgordXNlZCB3aGVu IHBhcnNpbmcgYSBwb2xpY3kgaW4gcGFzczIuIFRoZSBpbnRlbnRpb24gaXMgdG8gbWFrZSBpdCBl YXN5Cit0byBpbnRyb2R1Y2Ugc3RhdGVtZW50cywgbGlrZSB0aGUgYGBERUZBVUxUYGAgc3RhdGVt ZW50OjoKKworICBERUZBVUxUIG9wPUVYRUNVVEUgYWN0aW9uPUFMTE9XCisgIERFRkFVTFQgYWN0 aW9uPUFMTE9XCisKK29yLCB0aGUgcG9saWN5IGhlYWRlcjo6CisKKyAgcG9saWN5X25hbWU9Ik15 UG9saWN5IiBwb2xpY3lfdmVyc2lvbj0wLjAuMAorCitUaGVzZSBpbmRpdmlkdWFsIGZyYWdtZW50 cyBvZiBjb2RlLCBhcyBzdWNoLCBnYWluIGFjY2VzcyB0byBtYW5pcHVsYXRpbmcKK0lQRSdzIHBv bGljeSBzdHJ1Y3R1cmUgZGlyZWN0bHksIGFzIG9wcG9zZWQgdG8gdGhlIG9wYXF1ZSBgYHZvaWQg KmBgIHRoYXQKK21vZHVsZXMgZ2V0LgorCisuLiBbI10gVGhpcyBpcyBzb21ldGhpbmcgd2UncmUg aW50ZXJlc3RlZCBpbiBzb2x2aW5nLCB1c2luZyBzb21lCisgICAgICAgcGVyc2lzdGVudCBzdG9y YWdlCisKK1Rlc3RzCit+fn5+fgorCitJUEUgaW5pdGlhbGx5IGhhcyBLVW5pdCBUZXN0cywgdGVz dGluZyBwcmltYXJpbHkgdGhlIHBhcnNlciBhbmQgdGhlIGNvbnRleHQKK3N0cnVjdHVyZXMuIEEg bWFqb3JpdHkgb2YgdGhlc2UgYXJlIHRhYmxlLWJhc2VkIHRlc3RpbmcsIHBsZWFzZSBjb250cmli dXRlCit0byB0aGVtLCBlc3BlY2lhbGx5IHdoZW4gYWRkaW5nIG5ldyBwcm9wZXJ0aWVzLgpkaWZm IC0tZ2l0IGEvTUFJTlRBSU5FUlMgYi9NQUlOVEFJTkVSUwppbmRleCBhODRjYTc4MTE5OWIuLjkw OWRiNWJhNmY4NyAxMDA2NDQKLS0tIGEvTUFJTlRBSU5FUlMKKysrIGIvTUFJTlRBSU5FUlMKQEAg LTkyODMsNiArOTI4Myw4IEBAIElOVEVHUklUWSBQT0xJQ1kgRU5GT1JDRU1FTlQgKElQRSkKIE06 CURldmVuIEJvd2VycyA8ZGV2ZW4uZGVzYWlAbGludXgubWljcm9zb2Z0LmNvbT4KIE06CUZhbiBX dSA8d3VmYW5AbGludXgubWljcm9zb2Z0LmNvbT4KIFM6CVN1cHBvcnRlZAorRjoJRG9jdW1lbnRh dGlvbi9hZG1pbi1ndWlkZS9MU00vaXBlLnJzdAorRjoJRG9jdW1lbnRhdGlvbi9zZWN1cml0eS9p cGUucnN0CiBGOglzY3JpcHRzL2lwZS8KIEY6CXNlY3VyaXR5L2lwZS8KIAotLSAKMi4zMy4wCgoK LS0KZG0tZGV2ZWwgbWFpbGluZyBsaXN0CmRtLWRldmVsQHJlZGhhdC5jb20KaHR0cHM6Ly9saXN0 bWFuLnJlZGhhdC5jb20vbWFpbG1hbi9saXN0aW5mby9kbS1kZXZlbA== 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 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 46AA5C433EF for ; Wed, 13 Oct 2021 19:31:32 +0000 (UTC) Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [216.205.24.124]) (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 BBFC6611CA for ; Wed, 13 Oct 2021 19:31:31 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.1 mail.kernel.org BBFC6611CA Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.microsoft.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=redhat.com Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-517-28uBnkFsOp2i2PTPIYBi9w-1; Wed, 13 Oct 2021 15:31:28 -0400 X-MC-Unique: 28uBnkFsOp2i2PTPIYBi9w-1 Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.phx2.redhat.com [10.5.11.14]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 60AA9102CB2C; Wed, 13 Oct 2021 19:31:25 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.20]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 1DEE25DF36; Wed, 13 Oct 2021 19:31:25 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id F05581806D00; Wed, 13 Oct 2021 19:31:24 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.rdu2.redhat.com [10.11.54.6]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id 19DJD5iv018817 for ; Wed, 13 Oct 2021 15:13:06 -0400 Received: by smtp.corp.redhat.com (Postfix) id C9E062166B2D; Wed, 13 Oct 2021 19:13:05 +0000 (UTC) Received: from mimecast-mx02.redhat.com (mimecast04.extmail.prod.ext.rdu2.redhat.com [10.11.55.20]) by smtp.corp.redhat.com (Postfix) with ESMTPS id C3F342166B25 for ; Wed, 13 Oct 2021 19:13:00 +0000 (UTC) Received: from us-smtp-1.mimecast.com (us-smtp-delivery-1.mimecast.com [207.211.31.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 992FD100B8E3 for ; Wed, 13 Oct 2021 19:13:00 +0000 (UTC) Received: from linux.microsoft.com (linux.microsoft.com [13.77.154.182]) by relay.mimecast.com with ESMTP id us-mta-547-UCvsE51aNuagaLSNFHbfbQ-1; Wed, 13 Oct 2021 15:12:56 -0400 X-MC-Unique: UCvsE51aNuagaLSNFHbfbQ-1 Received: from linuxonhyperv3.guj3yctzbm1etfxqx2vob5hsef.xx.internal.cloudapp.net (linux.microsoft.com [13.77.154.182]) by linux.microsoft.com (Postfix) with ESMTPSA id C6F4820B9D0C; Wed, 13 Oct 2021 12:06:40 -0700 (PDT) DKIM-Filter: OpenDKIM Filter v2.11.0 linux.microsoft.com C6F4820B9D0C From: deven.desai@linux.microsoft.com To: corbet@lwn.net, axboe@kernel.dk, agk@redhat.com, snitzer@redhat.com, ebiggers@kernel.org, tytso@mit.edu, paul@paul-moore.com, eparis@redhat.com, jmorris@namei.org, serge@hallyn.com Subject: [RFC PATCH v7 16/16] documentation: add ipe documentation Date: Wed, 13 Oct 2021 12:06:35 -0700 Message-Id: <1634151995-16266-17-git-send-email-deven.desai@linux.microsoft.com> In-Reply-To: <1634151995-16266-1-git-send-email-deven.desai@linux.microsoft.com> References: <1634151995-16266-1-git-send-email-deven.desai@linux.microsoft.com> MIME-Version: 1.0 X-Mimecast-Impersonation-Protect: Policy=CLT - Impersonation Protection Definition; Similar Internal Domain=false; Similar Monitored External Domain=false; Custom External Domain=false; Mimecast External Domain=false; Newly Observed Domain=false; Internal User Name=false; Custom Display Name List=false; Reply-to Address Mismatch=false; Targeted Threat Dictionary=false; Mimecast Threat Dictionary=false; Custom Threat Dictionary=false X-Scanned-By: MIMEDefang 2.78 on 10.11.54.6 X-MIME-Autoconverted: from quoted-printable to 8bit by lists01.pubmisc.prod.ext.phx2.redhat.com id 19DJD5iv018817 X-loop: linux-audit@redhat.com X-Mailman-Approved-At: Wed, 13 Oct 2021 15:26:43 -0400 Cc: linux-security-module@vger.kernel.org, linux-doc@vger.kernel.org, jannh@google.com, linux-fscrypt@vger.kernel.org, linux-kernel@vger.kernel.org, linux-block@vger.kernel.org, dm-devel@redhat.com, linux-audit@redhat.com X-BeenThere: linux-audit@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: Linux Audit Discussion List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: linux-audit-bounces@redhat.com Errors-To: linux-audit-bounces@redhat.com X-Scanned-By: MIMEDefang 2.79 on 10.5.11.14 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=linux-audit-bounces@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 RnJvbTogRGV2ZW4gQm93ZXJzIDxkZXZlbi5kZXNhaUBsaW51eC5taWNyb3NvZnQuY29tPgoKQWRk IElQRSdzIGFkbWluIGFuZCBkZXZlbG9wZXIgZG9jdW1lbnRhdGlvbiB0byB0aGUga2VybmVsIHRy ZWUuCgpDby1kZXZlbG9wZWQtYnk6IEZhbiBXdSA8d3VmYW5AbGludXgubWljcm9zb2Z0LmNvbT4K U2lnbmVkLW9mZi1ieTogRmFuIFd1IDx3dWZhbkBsaW51eC5taWNyb3NvZnQuY29tPgpTaWduZWQt b2ZmLWJ5OiBEZXZlbiBCb3dlcnMgPGRldmVuLmRlc2FpQGxpbnV4Lm1pY3Jvc29mdC5jb20+Ci0t LQoKUmVsZXZhbnQgY2hhbmdlcyBzaW5jZSB2NjoKICAqIEFkZCBhZGRpdGlvbmFsIGRldmVsb3Bl ci1sZXZlbCBkb2N1bWVudGF0aW9uCiAgKiBVcGRhdGUgYWRtaW4tZ3VpZGUgZG9jcyB0byByZWZs ZWN0IGNoYW5nZXMuCiAgKiBEcm9wIEFja2VkLWJ5IGR1ZSB0byBzaWduaWZpY2FudCBjaGFuZ2Vz CgotLS0KIERvY3VtZW50YXRpb24vYWRtaW4tZ3VpZGUvTFNNL2luZGV4LnJzdCAgICAgICB8ICAg MSArCiBEb2N1bWVudGF0aW9uL2FkbWluLWd1aWRlL0xTTS9pcGUucnN0ICAgICAgICAgfCA1ODcg KysrKysrKysrKysrKysrKysrCiAuLi4vYWRtaW4tZ3VpZGUva2VybmVsLXBhcmFtZXRlcnMudHh0 ICAgICAgICAgfCAgMTIgKwogRG9jdW1lbnRhdGlvbi9zZWN1cml0eS9pbmRleC5yc3QgICAgICAg ICAgICAgIHwgICAxICsKIERvY3VtZW50YXRpb24vc2VjdXJpdHkvaXBlLnJzdCAgICAgICAgICAg ICAgICB8IDMzOSArKysrKysrKysrCiBNQUlOVEFJTkVSUyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgfCAgIDIgKwogNiBmaWxlcyBjaGFuZ2VkLCA5NDIgaW5zZXJ0aW9ucygrKQog Y3JlYXRlIG1vZGUgMTAwNjQ0IERvY3VtZW50YXRpb24vYWRtaW4tZ3VpZGUvTFNNL2lwZS5yc3QK IGNyZWF0ZSBtb2RlIDEwMDY0NCBEb2N1bWVudGF0aW9uL3NlY3VyaXR5L2lwZS5yc3QKCmRpZmYg LS1naXQgYS9Eb2N1bWVudGF0aW9uL2FkbWluLWd1aWRlL0xTTS9pbmRleC5yc3QgYi9Eb2N1bWVu dGF0aW9uL2FkbWluLWd1aWRlL0xTTS9pbmRleC5yc3QKaW5kZXggYTZiYTk1ZmJhYTlmLi5jZTYz YmU2ZDY0YWQgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vYWRtaW4tZ3VpZGUvTFNNL2luZGV4 LnJzdAorKysgYi9Eb2N1bWVudGF0aW9uL2FkbWluLWd1aWRlL0xTTS9pbmRleC5yc3QKQEAgLTQ3 LDMgKzQ3LDQgQEAgc3ViZGlyZWN0b3JpZXMuCiAgICB0b21veW8KICAgIFlhbWEKICAgIFNhZmVT ZXRJRAorICAgaXBlCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2FkbWluLWd1aWRlL0xTTS9p cGUucnN0IGIvRG9jdW1lbnRhdGlvbi9hZG1pbi1ndWlkZS9MU00vaXBlLnJzdApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjU2YTlmYTJmZTU5YgotLS0gL2Rldi9udWxs CisrKyBiL0RvY3VtZW50YXRpb24vYWRtaW4tZ3VpZGUvTFNNL2lwZS5yc3QKQEAgLTAsMCArMSw1 ODcgQEAKKy4uIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCisKK0ludGVncml0eSBQ b2xpY3kgRW5mb3JjZW1lbnQgKElQRSkKKz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KKworLi4gTk9URTo6CisKKyAgIFRoaXMgaXMgdGhlIGRvY3VtZW50YXRpb24gZm9yIGFkbWlu cywgc3lzdGVtIGJ1aWxkZXJzLCBvciBpbmRpdmlkdWFscworICAgYXR0ZW1wdGluZyB0byB1c2Ug SVBFLCB3aXRob3V0IHVuZGVyc3RhbmRpbmcgYWxsIG9mIGl0cyBpbnRlcm5hbCBzeXN0ZW1zLgor ICAgSWYgeW91J3JlIGxvb2tpbmcgZm9yIGRvY3VtZW50YXRpb24gdG8gZXh0ZW5kIElQRSwgdW5k ZXJzdGFuZCB0aGUgZGVzaWduCisgICBkZWNpc2lvbnMgYmVoaW5kIElQRSwgb3IgYXJlIGp1c3Qg Y3VyaW91cyBhYm91dCB0aGUgaW50ZXJuYWxzLCBwbGVhc2UKKyAgIHNlZSA6cmVmOmBEb2N1bWVu dGF0aW9uL3NlY3VyaXR5L2lwZS5yc3RgCisKK092ZXJ2aWV3CistLS0tLS0tLQorCitJUEUgaXMg YSBMaW51eCBTZWN1cml0eSBNb2R1bGUgd2hpY2ggaW1wb3NlcyBhIGNvbXBsaW1lbnRhcnkgbW9k ZWwKK29mIG1hbmRhdG9yeSBhY2Nlc3MgY29udHJvbCB0byBvdGhlciBMU01zLiBXaGVyZWFzIHRo ZSBleGlzdGluZyBMU01zCitpbXBvc2UgYWNjZXNzIGNvbnRyb2wgYmFzZWQgb24gbGFiZWxzIG9y IHBhdGhzLCBJUEUgaW1wb3NlcyBhY2Nlc3MKK2NvbnRyb2wgYmFzZWQgb24gdGhlIHRydXN0IG9m IHRoZSByZXNvdXJjZS4gU2ltcGx5IHB1dCwgSVBFCitvciByZXN0cmljdHMgYWNjZXNzIHRvIGEg cmVzb3VyY2UgYmFzZWQgb24gdGhlIHRydXN0IG9mIHNhaWQgcmVzb3VyY2UuCisKK1RydXN0IHJl cXVpcmVtZW50cyBhcmUgZXN0YWJsaXNoZWQgdmlhIElQRSdzIHBvbGljeSwgc291cmNpbmcgbXVs dGlwbGUKK2RpZmZlcmVudCBpbXBsZW1lbnRhdGlvbnMgd2l0aGluIHRoZSBrZXJuZWwgdG8gYnVp bGQgYSBjb2hlc2l2ZSB0cnVzdAorbW9kZWwsIGJhc2VkIG9uIGhvdyB0aGUgc3lzdGVtIHdhcyBi dWlsdC4KKworVHJ1c3QgdnMgSW50ZWdyaXR5CistLS0tLS0tLS0tLS0tLS0tLS0KKworVHJ1c3Qs IHdpdGggcmVzcGVjdCB0byBjb21wdXRpbmcsIGlzIGEgY29uY2VwdCB0aGF0IGRlc2lnbmF0ZXMg YSBzZXQKK29mIGVudGl0aWVzIHdobyB3aWxsIGVuZG9yc2UgYSBzZXQgb2YgcmVzb3VyY2VzIGFz IG5vbi1tYWxpY2lvdXMuCitUcmFkaXRpb25hbGx5LCB0aGlzIGlzIGRvbmUgdmlhIHNpZ25hdHVy ZXMsIHdoaWNoIGlzIHRoZSBhY3Qgb2YgZW5kb3JzaW5nCithIHJlc291cmNlLiBJbnRlZ3JpdHks IG9uIHRoZSBvdGhlciBoYW5kLCBpcyB0aGUgY29uY2VwdCBvZiBlbnN1cmluZyB0aGF0IGEKK3Jl c291cmNlIGhhcyBub3QgYmVlbiBtb2RpZmllZCBzaW5jZSBhIHBvaW50IG9mIHRpbWUuIFRoaXMg aXMgdHlwaWNhbGx5IGRvbmUKK3Rocm91Z2ggY3J5cHRvZ3JhcGh5IG9yIHNpZ25hdHVyZXMuCisK K1RydXN0IGFuZCBpbnRlZ3JpdHkgYXJlIHZlcnkgY2xvc2VseSB0aWVkIHRvZ2V0aGVyIGNvbmNl cHRzLCBhcyBpbnRlZ3JpdHkKK2lzIHRoZSB3YXkgeW91IGNhbiBwcm92ZSB0cnVzdCBmb3IgYSBy ZXNvdXJjZTsgb3RoZXJ3aXNlIGl0IGNvdWxkIGhhdmUKK2JlZW4gbW9kaWZpZWQgYnkgYW4gZW50 aXR5IHdobyBpcyB1bnRydXN0ZWQuCisKK0lQRSBwcm92aWRlcyBhIHdheSBmb3IgYSB1c2VyIHRv IGV4cHJlc3MgdHJ1c3Qgb2YgcmVzb3VyY2VzLCBieSB1c2luZworcHJlLWV4aXN0aW5nIHN5c3Rl bXMgd2hpY2ggcHJvdmlkZSB0aGUgaW50ZWdyaXR5IGhhbGYgb2YgdGhlIGVxdWF0aW9uLgorCitV c2UgQ2FzZXMKKy0tLS0tLS0tLQorCitJUEUgd29ya3MgYmVzdCBpbiBmaXhlZC1mdW5jdGlvbiBk ZXZpY2VzOiBEZXZpY2VzIGluIHdoaWNoIHRoZWlyIHB1cnBvc2UKK2lzIGNsZWFybHkgZGVmaW5l ZCBhbmQgbm90IHN1cHBvc2VkIHRvIGJlIGNoYW5nZWQgKGUuZy4gbmV0d29yayBmaXJld2FsbAor ZGV2aWNlIGluIGEgZGF0YSBjZW50ZXIsIGFuIElvVCBkZXZpY2UsIGV0Y2V0ZXJhKSwgd2hlcmUg YWxsIHNvZnR3YXJlIGFuZAorY29uZmlndXJhdGlvbiBpcyBidWlsdCBhbmQgcHJvdmlzaW9uZWQg YnkgdGhlIHN5c3RlbSBvd25lci4KKworSVBFIGlzIGEgbG9uZy13YXkgb2ZmIGZvciB1c2UgaW4g Z2VuZXJhbC1wdXJwb3NlIGNvbXB1dGluZzoKK3RoZSBMaW51eCBjb21tdW5pdHkgYXMgYSB3aG9s ZSB0ZW5kcyB0byBmb2xsb3cgYSBkZWNlbnRyYWxpemVkIHRydXN0Cittb2RlbCwga25vd24gYXMg dGhlIFdlYiBvZiBUcnVzdCwgd2hpY2ggSVBFIGhhcyBubyBzdXBwb3J0IGZvciBhcyBvZiB5ZXQu CitJbnN0ZWFkLCBJUEUgc3VwcG9ydHMgdGhlIFBLSSBUcnVzdCBNb2RlbCwgd2hpY2ggZ2VuZXJh bGx5IGRlc2lnbmF0ZXMgYQorc2V0IG9mIGVudGl0aWVzIHRoYXQgcHJvdmlkZSBhIG1lYXN1cmUg YWJzb2x1dGUgdHJ1c3QuCisKK0FkZGl0aW9uYWxseSwgd2hpbGUgbW9zdCBwYWNrYWdlcyBhcmUg c2lnbmVkIHRvZGF5LCB0aGUgZmlsZXMgaW5zaWRlCit0aGUgcGFja2FnZXMgKGZvciBpbnN0YW5j ZSwgdGhlIGV4ZWN1dGFibGVzKSwgdGVuZCB0byBiZSB1bnNpZ25lZC4gVGhpcworbWFrZXMgaXQg ZGlmZmljdWx0IHRvIHV0aWxpemUgSVBFIGluIHN5c3RlbXMgd2hlcmUgYSBwYWNrYWdlIG1hbmFn ZXIgaXMKK2V4cGVjdGVkIHRvIGJlIGZ1bmN0aW9uYWwsIHdpdGhvdXQgbWFqb3IgY2hhbmdlcyB0 byB0aGUgcGFja2FnZSBtYW5hZ2VyCithbmQgZWNvc3lzdGVtIGJlaGluZCBpdC4KKworRm9yIHRo ZSBoaWdoZXN0IGxldmVsIG9mIHNlY3VyaXR5LCBwbGF0Zm9ybSBmaXJtd2FyZSBzaG91bGQgdmVy aWZ5IHRoZQordGhlIGtlcm5lbCBhbmQgb3B0aW9uYWxseSB0aGUgcm9vdCBmaWxlc3lzdGVtIChm b3IgZXhhbXBsZSwgdmlhIFUtQm9vdAordmVyaWZpZWQgYm9vdCkuIFRoaXMgZm9ybXMgYSBjaGFp biBvZiB0cnVzdCBmcm9tIHRoZSBoYXJkd2FyZSwgZW5zdXJpbmcKK3RoYXQgZXZlcnkgc3RhZ2Ug b2YgdGhlIHN5c3RlbSBpcyB0cnVzdGVkLgorCitLbm93biBHYXBzCistLS0tLS0tLS0tCisKK0lQ RSBjYW5ub3QgdmVyaWZ5IHRoZSBpbnRlZ3JpdHkgb2YgYW5vbnltb3VzIGV4ZWN1dGFibGUgbWVt b3J5LCBzdWNoIGFzCit0aGUgdHJhbXBvbGluZXMgY3JlYXRlZCBieSBnY2MgY2xvc3VyZXMgYW5k IGxpYmZmaSAoPDMuNC4yKSwgb3IgSklUJ2QgY29kZS4KK1VuZm9ydHVuYXRlbHksIGFzIHRoaXMg aXMgZHluYW1pY2FsbHkgZ2VuZXJhdGVkIGNvZGUsIHRoZXJlIGlzIG5vIHdheQorZm9yIElQRSB0 byBlbnN1cmUgdGhlIGludGVncml0eSBvZiB0aGlzIGNvZGUgdG8gZm9ybSBhIHRydXN0IGJhc2lz LiBJbiBhbGwKK2Nhc2VzLCB0aGUgcmV0dXJuIHJlc3VsdCBmb3IgdGhlc2Ugb3BlcmF0aW9ucyB3 aWxsIGJlIHdoYXRldmVyIHRoZSBhZG1pbgorY29uZmlndXJlcyB0aGUgREVGQVVMVCBhY3Rpb24g Zm9yICJFWEVDVVRFIi4KKworSVBFIGNhbm5vdCB2ZXJpZnkgdGhlIGludGVncml0eSBvZiBpbnRl cnByZXRlZCBsYW5ndWFnZXMnIHByb2dyYW1zIHdoZW4KK3RoZXNlIHNjcmlwdHMgaW52b2tlZCB2 aWEgYGA8aW50ZXJwcmV0ZXI+IDxmaWxlPmBgLiBUaGlzIGlzIGJlY2F1c2UgdGhlCit3YXkgaW50 ZXJwcmV0ZXJzIGV4ZWN1dGUgdGhlc2UgZmlsZXMsIHRoZSBzY3JpcHRzIHRoZW1zZWx2ZXMgYXJl IG5vdAorZXZhbHVhdGVkIGFzIGV4ZWN1dGFibGUgY29kZSB0aHJvdWdoIG9uZSBvZiBJUEUncyBo b29rcy4gSW50ZXJwcmV0ZXJzCitjYW4gYmUgZW5saWdodGVuZWQgdG8gdGhlIHVzYWdlIG9mIElQ RSBieSB0cnlpbmcgdG8gbW1hcCBhIGZpbGUgaW50bworZXhlY3V0YWJsZSBtZW1vcnkgKCtYKSwg YWZ0ZXIgb3BlbmluZyB0aGUgZmlsZSBhbmQgcmVzcG9uZGluZyB0byB0aGUKK2Vycm9yIGNvZGUg YXBwcm9wcmlhdGVseS4gVGhpcyBhbHNvIGFwcGxpZXMgdG8gaW5jbHVkZWQgZmlsZXMsIG9yIGhp Z2gKK3ZhbHVlIGZpbGVzLCBzdWNoIGFzIGNvbmZpZ3VyYXRpb24gZmlsZXMgb2YgY3JpdGljYWwg c3lzdGVtIGNvbXBvbmVudHMgWyNdXy4KKworLi4gWyNdIE1pY2thw6tsIFNhbGHDvG4ncyBgdHJ1 c3RlZF9mb3IgcGF0Y2hzZXQgPGh0dHBzOi8vbG9yZS5rZXJuZWwub3JnL2FsbC8yMDIxMTAwODEw NDg0MC4xNzMzMzg1LTEtbWljQGRpZ2lrb2QubmV0Lz5gXworICAgY2FuIGJlIHVzZWQgdG8gbGV2 ZXJhZ2UgdGhpcy4KKworVGhyZWF0IE1vZGVsCistLS0tLS0tLS0tLS0KKworVGhlIHRocmVhdCB0 eXBlIGFkZHJlc3NlZCBieSBJUEUgaXMgdGFtcGVyaW5nIG9mIGV4ZWN1dGFibGUgdXNlci1sYW5k Citjb2RlIGJleW9uZCB0aGUgaW5pdGlhbGx5IGJvb3RlZCBrZXJuZWwsIGFuZCB0aGUgaW5pdGlh bCB2ZXJpZmljYXRpb24gb2YKK2tlcm5lbCBtb2R1bGVzIHRoYXQgYXJlIGxvYWRlZCBpbiB1c2Vy bGFuZCB0aHJvdWdoIGBgbW9kcHJvYmVgYCBvcgorYGBpbnNtb2RgYC4KKworVGFtcGVyaW5nIHZp b2xhdGVzIGludGVncml0eSwgYW5kIGJlaW5nIHVuYWJsZSB0byB2ZXJpZnkgdGhlIGludGVncml0 eSwKK3Jlc3VsdHMgaW4gYSBsYWNrIG9mIHRydXN0LiBJUEUncyByb2xlIGluIG1pdGlnYXRpbmcg dGhpcyB0aHJlYXQgaXMgdG8KK3ZlcmlmeSB0aGUgaW50ZWdyaXR5IChhbmQgYXV0aGVudGljaXR5 KSBvZiBhbGwgZXhlY3V0YWJsZSBjb2RlIGFuZCB0bworZGVueSB0aGVpciB1c2UgaWYgdGhleSBj YW5ub3QgYmUgdHJ1c3RlZCAoYXMgaW50ZWdyaXR5IHZlcmlmaWNhdGlvbiBmYWlscykuCitJUEUg Z2VuZXJhdGVzIGF1ZGl0IGxvZ3Mgd2hpY2ggbWF5IGJlIHV0aWxpemVkIHRvIGRldGVjdCBmYWls dXJlcyByZXN1bHRpbmcKK2Zyb20gZmFpbHVyZSB0byBwYXNzIHBvbGljeS4KKworVGFtcGVyaW5n IHRocmVhdCBzY2VuYXJpb3MgaW5jbHVkZSBtb2RpZmljYXRpb24gb3IgcmVwbGFjZW1lbnQgb2YK K2V4ZWN1dGFibGUgY29kZSBieSBhIHJhbmdlIG9mIGFjdG9ycyBpbmNsdWRpbmc6CisKKy0gIEFj dG9ycyB3aXRoIHBoeXNpY2FsIGFjY2VzcyB0byB0aGUgaGFyZHdhcmUKKy0gIEFjdG9ycyB3aXRo IGxvY2FsIG5ldHdvcmsgYWNjZXNzIHRvIHRoZSBzeXN0ZW0KKy0gIEFjdG9ycyB3aXRoIGFjY2Vz cyB0byB0aGUgZGVwbG95bWVudCBzeXN0ZW0KKy0gIENvbXByb21pc2VkIGludGVybmFsIHN5c3Rl bXMgdW5kZXIgZXh0ZXJuYWwgY29udHJvbAorLSAgTWFsaWNpb3VzIGVuZCB1c2VycyBvZiB0aGUg c3lzdGVtCistICBDb21wcm9taXNlZCBlbmQgdXNlcnMgb2YgdGhlIHN5c3RlbQorLSAgUmVtb3Rl IChleHRlcm5hbCkgY29tcHJvbWlzZSBvZiB0aGUgc3lzdGVtCisKK0lQRSBkb2VzIG5vdCBtaXRp Z2F0ZSB0aHJlYXRzIGFyaXNpbmcgZnJvbSBtYWxpY2lvdXMgYXV0aG9yaXplZAorZGV2ZWxvcGVy cywgb3IgY29tcHJvbWlzZWQgZGV2ZWxvcGVyIHRvb2xzIHVzZWQgYnkgYXV0aG9yaXplZAorZGV2 ZWxvcGVycy4gQWRkaXRpb25hbGx5LCBJUEUgZHJhd3MgaGFyZCBzZWN1cml0eSBib3VuZGFyeSBi ZXR3ZWVuIHVzZXIKK21vZGUgYW5kIGtlcm5lbCBtb2RlLiBBcyBhIHJlc3VsdCwgSVBFIGRvZXMg bm90IHByb3ZpZGUgYW55IHByb3RlY3Rpb25zCithZ2FpbnN0IGEga2VybmVsIGxldmVsIGV4cGxv aXQsIGFuZCBhIGtlcm5lbC1sZXZlbCBleHBsb2l0IGNhbiBkaXNhYmxlCitvciB0YW1wZXIgd2l0 aCBJUEUncyBwcm90ZWN0aW9ucy4KKworUG9saWN5CistLS0tLS0KKworSVBFIHBvbGljeSBpcyBh IHBsYWluLXRleHQgWyNdXyBwb2xpY3kgY29tcG9zZWQgb2YgbXVsdGlwbGUgc3RhdGVtZW50cwor b3ZlciBzZXZlcmFsIGxpbmVzLiBUaGVyZSBpcyBvbmUgcmVxdWlyZWQgbGluZSwgYXQgdGhlIHRv cCBvZiB0aGUKK3BvbGljeSwgaW5kaWNhdGluZyB0aGUgcG9saWN5IG5hbWUsIGFuZCB0aGUgcG9s aWN5IHZlcnNpb24sIGZvcgoraW5zdGFuY2U6OgorCisgICBwb2xpY3lfbmFtZT0iRXggUG9saWN5 IiBwb2xpY3lfdmVyc2lvbj0wLjAuMAorCitUaGUgcG9saWN5IG5hbWUgaXMgYSB1bmlxdWUga2V5 IGlkZW50aWZ5aW5nIHRoaXMgcG9saWN5IGluIGEgaHVtYW4KK3JlYWRhYmxlIG5hbWUuIFRoaXMg aXMgdXNlZCB0byBjcmVhdGUgbm9kZXMgdW5kZXIgc2VjdXJpdHlmcyBhcyB3ZWxsIGFzCit1bmlx dWVseSBpZGVudGlmeSBwb2xpY2llcyB0byBkZXBsb3kgbmV3IHBvbGljaWVzIHZzIHVwZGF0ZSBl eGlzdGluZworcG9saWNpZXMuCisKK1RoZSBwb2xpY3kgdmVyc2lvbiBpbmRpY2F0ZXMgdGhlIGN1 cnJlbnQgdmVyc2lvbiBvZiB0aGUgcG9saWN5IChOT1QgdGhlCitwb2xpY3kgc3ludGF4IHZlcnNp b24pLiBUaGlzIGlzIHVzZWQgdG8gcHJldmVudCByb2xsYmFjayBvZiBwb2xpY3kgdG8KK3BvdGVu dGlhbGx5IGluc2VjdXJlIHByZXZpb3VzIHZlcnNpb25zIG9mIHRoZSBwb2xpY3kuCisKK1RoZSBu ZXh0IHBvcnRpb24gb2YgSVBFIHBvbGljeSwgYXJlIHJ1bGVzLiBSdWxlcyBhcmUgZm9ybWVkIGJ5 IGtleT12YWx1ZQorcGFpcnMsIGtub3duIGFzIHByb3BlcnRpZXMuIElQRSBydWxlcyByZXF1aXJl IHR3byBwcm9wZXJ0aWVzOiAiYWN0aW9uIiwKK3doaWNoIGRldGVybWluZXMgd2hhdCBJUEUgZG9l cyB3aGVuIGl0IGVuY291bnRlcnMgYSBtYXRjaCBhZ2FpbnN0IHRoZQorcnVsZSwgYW5kICJvcCIs IHdoaWNoIGRldGVybWluZXMgd2hlbiB0aGF0IHJ1bGUgc2hvdWxkIGJlIGV2YWx1YXRlZC4KK1Ro ZSBvcmRlcmluZyBpcyBzaWduaWZpY2FudCwgYSBydWxlIG11c3Qgc3RhcnQgd2l0aCAib3AiLCBh bmQgZW5kIHdpdGgKKyJhY3Rpb24iLiBUaHVzLCBhIG1pbmltYWwgcnVsZSBpczo6CisKKyAgIG9w PUVYRUNVVEUgYWN0aW9uPUFMTE9XCisKK1RoaXMgZXhhbXBsZSB3aWxsIGFsbG93IGFueSBleGVj dXRpb24uIEFkZGl0aW9uYWwgcHJvcGVydGllcyBhcmUgdXNlZCB0bworcmVzdHJpY3QgYXR0cmli dXRlcyBhYm91dCB0aGUgZmlsZXMgYmVpbmcgZXZhbHVhdGVkLiBUaGVzZSBwcm9wZXJ0aWVzCith cmUgaW50ZW5kZWQgdG8gYmUgZGVzY3JpcHRpb25zIG9mIHN5c3RlbXMgd2l0aGluIHRoZSBrZXJu ZWwsIHRoYXQgY2FuCitwcm92aWRlIGEgbWVhc3VyZSBvZiBpbnRlZ3JpdHkgdmVyaWZpY2F0aW9u LCBzdWNoIHRoYXQgSVBFIGNhbiBkZXRlcm1pbmUKK3RoZSB0cnVzdCBvZiB0aGUgcmVzb3VyY2Ug YmFzZWQgb24gdGhlICJ2YWx1ZSIgaGFsZiBvZiB0aGUgcHJvcGVydHkuCisKK1J1bGVzIGFyZSBl dmFsdWF0ZWQgdG9wLXRvLWJvdHRvbS4gQXMgYSByZXN1bHQsIGFueSByZXZvY2F0aW9uIHJ1bGVz LAorb3IgZGVuaWVzIHNob3VsZCBiZSBwbGFjZWQgZWFybHkgaW4gdGhlIGZpbGUgdG8gZW5zdXJl IHRoYXQgdGhlc2UgcnVsZXMKK2FyZSBldmFsdWF0ZWQgYmVmb3JlIGFzIHJ1bGUgd2l0aCAiYWN0 aW9uPUFMTE9XIiBpcyBoaXQuCisKK0lQRSBwb2xpY3kgaXMgZGVzaWduZWQgdG8gYmUgb25seSBm b3J3YXJkIGNvbXBhdGlibGUuIFVzZXJzcGFjZSBjYW4gcmVhZAord2hhdCB0aGUgcGFyc2VyJ3Mg Y3VycmVudCBjb25maWd1cmF0aW9uIChzdXBwb3J0ZWQgc3RhdGVtZW50cywgcHJvcGVydGllcywK K2V0Y2V0ZXJhKSB2aWEgcmVhZGluZyB0aGUgc2VjdXJpdHlmcyBlbnRyeSwgJ2lwZS9jb25maWcn CisKK0lQRSBwb2xpY3kgc3VwcG9ydHMgY29tbWVudHMuIFRoZSBjaGFyYWN0ZXIgJyMnIHdpbGwg ZnVuY3Rpb24gYXMgYQorY29tbWVudCwgaWdub3JpbmcgYWxsIGNoYXJhY3RlcnMgdG8gdGhlIHJp Z2h0IG9mICcjJyB1bnRpbCB0aGUgbmV3bGluZS4KKworVGhlIGRlZmF1bHQgYmVoYXZpb3Igb2Yg SVBFIGV2YWx1YXRpb25zIGNhbiBhbHNvIGJlIGV4cHJlc3NlZCBpbiBwb2xpY3ksCit0aHJvdWdo IHRoZSBgYERFRkFVTFRgYCBzdGF0ZW1lbnQuIFRoaXMgY2FuIGJlIGRvbmUgYXQgYSBnbG9iYWwg bGV2ZWwsCitvciBhIHBlci1vcGVyYXRpb24gbGV2ZWw6OgorCisgICAjIEdsb2JhbAorICAgREVG QVVMVCBhY3Rpb249QUxMT1cKKworICAgIyBPcGVyYXRpb24gU3BlY2lmaWMKKyAgIERFRkFVTFQg b3A9RVhFQ1VURSBhY3Rpb249QUxMT1cKKworQSBkZWZhdWx0IG11c3QgYmUgc2V0IGZvciBhbGwg a25vd24gb3BlcmF0aW9ucyBpbiBJUEUuIElmIHlvdSB3YW50IHRvCitwcmVzZXJ2ZSBvbGRlciBw b2xpY2llcyBiZWluZyBjb21wYXRpYmxlIHdpdGggbmV3ZXIga2VybmVscyB0aGF0IGNhbiBpbnRy b2R1Y2UKK25ldyBvcGVyYXRpb25zLCBwbGVhc2Ugc2V0IGEgZ2xvYmFsIGRlZmF1bHQgb2YgJ0FM TE9XJywgYW5kIG92ZXJyaWRlIHRoZQorZGVmYXVsdHMgb24gYSBwZXItb3BlcmF0aW9uIGJhc2lz LgorCitXaXRoIGNvbmZpZ3VyYWJsZSBwb2xpY3ktYmFzZWQgTFNNcywgdGhlcmUncyBzZXZlcmFs IGlzc3VlcyB3aXRoCitlbmZvcmNpbmcgdGhlIGNvbmZpZ3VyYWJsZSBwb2xpY2llcyBhdCBzdGFy dHVwLCBhcm91bmQgcmVhZGluZyBhbmQKK3BhcnNpbmcgdGhlIHBvbGljeToKKworMS4gVGhlIGtl cm5lbCAqc2hvdWxkKiBub3QgcmVhZCBmaWxlcyBmcm9tIHVzZXJsYW5kLCBzbyBkaXJlY3RseSBy ZWFkaW5nCisgICB0aGUgcG9saWN5IGZpbGUgaXMgcHJvaGliaXRlZC4KKzIuIFRoZSBrZXJuZWwg Y29tbWFuZCBsaW5lIGhhcyBhIGNoYXJhY3RlciBsaW1pdCwgYW5kIG9uZSBrZXJuZWwgbW9kdWxl CisgICBzaG91bGQgbm90IHJlc2VydmUgdGhlIGVudGlyZSBjaGFyYWN0ZXIgbGltaXQgZm9yIGl0 cyBvd24KKyAgIGNvbmZpZ3VyYXRpb24uCiszLiBUaGVyZSBhcmUgdmFyaW91cyBib290IGxvYWRl cnMgaW4gdGhlIGtlcm5lbCBlY29zeXN0ZW0sIHNvIGhhbmRpbmcKKyAgIG9mZiBhIG1lbW9yeSBi bG9jayB3b3VsZCBiZSBjb3N0bHkgdG8gbWFpbnRhaW4uCisKK0FzIGEgcmVzdWx0LCBJUEUgaGFz IGFkZHJlc3NlZCB0aGlzIHByb2JsZW0gdGhyb3VnaCBhIGNvbmNlcHQgb2YgYSAiYm9vdAorcG9s aWN5Ii4gQSBib290IHBvbGljeSBpcyBhIG1pbmltYWwgcG9saWN5LCBjb21waWxlZCBpbnRvIHRo ZSBrZXJuZWwuCitUaGlzIHBvbGljeSBpcyBpbnRlbmRlZCB0byBnZXQgdGhlIHN5c3RlbSB0byBh IHN0YXRlIHdoZXJlIHVzZXJsYW5kIGlzCitzZXR1cCBhbmQgcmVhZHkgdG8gcmVjZWl2ZSBjb21t YW5kcywgYXQgd2hpY2ggcG9pbnQgYSBtb3JlIGNvbXBsZXgKK3BvbGljeSAoInVzZXIgcG9saWNp ZXMiKSBjYW4gYmUgZGVwbG95ZWQgdmlhIHNlY3VyaXR5ZnMuIFRoZSBib290IHBvbGljeQorY2Fu IGJlIHNwZWNpZmllZCB2aWEgdGhlIEtjb25maWcsIGBgU0VDVVJJVFlfSVBFX0JPT1RfUE9MSUNZ YGAsIHdoaWNoCithY2NlcHRzIGEgcGF0aCB0byBhIHBsYWluLXRleHQgdmVyc2lvbiBvZiB0aGUg SVBFIHBvbGljeSB0byBhcHBseS4gVGhpcworcG9saWN5IHdpbGwgYmUgY29tcGlsZWQgaW50byB0 aGUga2VybmVsLiBJZiBub3Qgc3BlY2lmaWVkLCBJUEUgd2lsbCBiZQorZGlzYWJsZWQgdW50aWwg YSBwb2xpY3kgaXMgZGVwbG95ZWQgYW5kIGFjdGl2YXRlZCB0aHJvdWdoIHNlY3VyaXR5ZnMuCisK Ky4uIFsjXSBQbGVhc2Ugc2VlIHRoZSA6cmVmOmBEb2N1bWVudGF0aW9uL3NlY3VyaXR5L2lwZS5y c3RgIGZvciBtb3JlIG9uIHRoaXMKKyAgIHRvcGljLgorCitEZXBsb3lpbmcgUG9saWNpZXMKK35+ fn5+fn5+fn5+fn5+fn5+fgorCitVc2VyIHBvbGljaWVzIGFzIGV4cGxhaW5lZCBhYm92ZSwgYXJl IHBvbGljaWVzIHRoYXQgYXJlIGRlcGxveWVkIGZyb20KK3VzZXJsYW5kLCB0aHJvdWdoIHNlY3Vy aXR5ZnMuIFRoZXNlIHBvbGljaWVzIGFyZSBzaWduZWQgdG8gZW5mb3JjZSBzb21lCitsZXZlbCBv ZiBhdXRob3JpemF0aW9uIG9mIHRoZSBwb2xpY2llcyAocHJvaGliaXRpbmcgYW4gYXR0YWNrZXIg ZnJvbQorZ2FpbmluZyByb290LCBhbmQgZGVwbG95aW5nIGFuICJhbGxvdyBhbGwiIHBvbGljeSks IHRocm91Z2ggdGhlIFBLQ1MjNworZW52ZWxvcGVkIGRhdGEgZm9ybWF0LiBUaGVzZSBwb2xpY2ll cyBtdXN0IGJlIHNpZ25lZCBieSBhIGNlcnRpZmljYXRlCit0aGF0IGNoYWlucyB0byB0aGUgYGBT WVNURU1fVFJVU1RFRF9LRVlSSU5HYGAuIFRocm91Z2ggb3BlbnNzbCwgdGhlCitzaWduaW5nIGNh biBiZSBkb25lIHZpYTo6CisKKyAgIG9wZW5zc2wgc21pbWUgLXNpZ24gLWluICIkTVlfUE9MSUNZ IiAtc2lnbmVyICIkTVlfQ0VSVElGSUNBVEUiIFwKKyAgICAgLWlua2V5ICIkTVlfUFJJVkFURV9L RVkiIC1iaW5hcnkgLW91dGZvcm0gZGVyIC1ub2F0dHIgLW5vZGV0YWNoIFwKKyAgICAgLW91dCAi JE1ZX1BPTElDWS5wN3MiCisKK0RlcGxveWluZyB0aGUgcG9saWNpZXMgaXMgZG9uZSB0aHJvdWdo IHNlY3VyaXR5ZnMsIHRocm91Z2ggdGhlCitgYG5ld19wb2xpY3lgYCBub2RlLiBUbyBkZXBsb3kg YSBwb2xpY3ksIHNpbXBseSBjYXQgdGhlIGZpbGUgaW50byB0aGUKK3NlY3VyaXR5ZnMgbm9kZTo6 CisKKyAgIGNhdCAiJE1ZX1BPTElDWS5wN3MiID4gL3N5cy9rZXJuZWwvc2VjdXJpdHkvaXBlL25l d19wb2xpY3kKKworVXBvbiBzdWNjZXNzLCB0aGlzIHdpbGwgY3JlYXRlIG9uZSBzdWJkaXJlY3Rv cnkgdW5kZXIKK2BgL3N5cy9rZXJuZWwvc2VjdXJpdHkvaXBlL3BvbGljaWVzL2BgLiBUaGUgc3Vi ZGlyZWN0b3J5IHdpbGwgYmUgdGhlCitgYHBvbGljeV9uYW1lYGAgZmllbGQgb2YgdGhlIHBvbGlj eSBkZXBsb3llZCwgc28gZm9yIHRoZSBleGFtcGxlIGFib3ZlLAordGhlIGRpcmVjdG9yeSB3aWxs IGJlIGBgL3N5cy9rZXJuZWwvc2VjdXJpdHkvaXBlL3BvbGljaWVzL0V4XCBQb2xpY3lgYC4KK1dp dGhpbiB0aGlzIGRpcmVjdG9yeSwgdGhlcmUgd2lsbCBiZSBmaXZlIGZpbGVzOiBgYHBrY3M3YGAs IGBgcG9saWN5YGAsCitgYGFjdGl2ZWBgLCBgYHVwZGF0ZWBgLCBhbmQgYGBkZWxldGVgYC4KKwor VGhlIGBgcGtjczdgYCBmaWxlIGlzIHJ3LCByZWFkaW5nIHdpbGwgcHJvdmlkZSB0aGUgcmF3IFBL Q1MjNyBkYXRhIHRoYXQKK3dhcyBwcm92aWRlZCB0byB0aGUga2VybmVsLCByZXByZXNlbnRpbmcg dGhlIHBvbGljeS4gV3JpdGluZywgd2lsbAorZGVwbG95IGFuIGluLXBsYWNlIHBvbGljeSB1cGRh dGUgLSBpZiB0aGlzIHBvbGljeSBpcyB0aGUgY3VycmVudGx5CitydW5uaW5nIHBvbGljeSwgdGhl IG5ldyB1cGRhdGVkIHBvbGljeSB3aWxsIHJlcGxhY2UgaXQgaW1tZWRpYXRlbHkgdXBvbgorc3Vj Y2Vzcy4gSWYgdGhlIHBvbGljeSBiZWluZyByZWFkIGlzIHRoZSBib290IHBvbGljeSwgd2hlbiBy ZWFkLCB0aGlzCit3aWxsIHJldHVybiBFTk9FTlQuCisKK1RoZSBgYHBvbGljeWBgIGZpbGUgaXMg cmVhZCBvbmx5LiBSZWFkaW5nIHdpbGwgcHJvdmlkZSB0aGUgUEtDUyM3IGlubmVyCitjb250ZW50 IG9mIHRoZSBwb2xpY3ksIHdoaWNoIHdpbGwgYmUgdGhlIHBsYWluIHRleHQgcG9saWN5LgorCitU aGUgYGBhY3RpdmVgYCBmaWxlIGlzIHVzZWQgdG8gc2V0IGEgcG9saWN5IGFzIHRoZSBjdXJyZW50 bHkgYWN0aXZlIHBvbGljeS4KK1RoaXMgZmlsZSBpcyBydywgYW5kIGFjY2VwdHMgYSB2YWx1ZSBv ZiBgYCIxImBgIHRvIHNldCB0aGUgcG9saWN5IGFzIGFjdGl2ZS4KK1NpbmNlIG9ubHkgYSBzaW5n bGUgcG9saWN5IGNhbiBiZSBhY3RpdmUgYXQgb25lIHRpbWUsIGFsbCBvdGhlciBwb2xpY2llcwor d2lsbCBiZSBtYXJrZWQgaW5hY3RpdmUuIFRoZSBwb2xpY3kgYmVpbmcgbWFya2VkIGFjdGl2ZSBt dXN0IGhhdmUgYSBwb2xpY3kKK3ZlcnNpb24gZ3JlYXRlciBvciBlcXVhbCB0byB0aGUgY3VycmVu dGx5LXJ1bm5pbmcgdmVyc2lvbi4KKworVGhlIGBgdXBkYXRlYGAgZmlsZSBpcyB1c2VkIHRvIHVw ZGF0ZSBhIHBvbGljeSB0aGF0IGlzIGFscmVhZHkgcHJlc2VudCBpbgordGhlIGtlcm5lbC4gVGhp cyBmaWxlIGlzIHdyaXRlLW9ubHkgYW5kIGFjY2VwdHMgYSBQS0NTIzcgc2lnbmVkIHBvbGljeS4K K09uZSBjaGVjayB3aWxsIGJlIHBlcmZvcm1lZCBvbiB0aGlzIHBvbGljeTogdGhlIHBvbGljeV9u YW1lcyBtdXN0IG1hdGNoCit3aXRoIHRoZSB1cGRhdGVkIHZlcnNpb24gYW5kIHRoZSBleGlzdGlu ZyB2ZXJzaW9uLiBJZiB0aGUgcG9saWN5IGJlaW5nCit1cGRhdGVkIGlzIHRoZSBhY3RpdmUgcG9s aWN5LCB0aGUgdXBkYXRlZCBwb2xpY3kgbXVzdCBoYXZlIGEgcG9saWN5IHZlcnNpb24KK2dyZWF0 ZXIgb3IgZXF1YWwgdG8gdGhlIGN1cnJlbnRseS1ydW5uaW5nIHZlcnNpb24uCisKK1RoZSBgYGRl bGV0ZWBgIGZpbGUgaXMgdXNlZCB0byByZW1vdmUgYSBwb2xpY3kgdGhhdCBpcyBubyBsb25nZXIg bmVlZGVkLgorVGhpcyBmaWxlIGlzIHdyaXRlLW9ubHkgYW5kIGFjY2VwdHMgYSB2YWx1ZSBvZiBg YCIxImBgIHRvIGRlbGV0ZSB0aGUgcG9saWN5LgorT24gZGVsZXRpb24sIHRoZSBzZWN1cml0eWZz IG5vZGUgcmVwcmVzZW50aW5nIHRoZSBwb2xpY3kgd2lsbCBiZSByZW1vdmVkLgorVGhlIHBvbGlj eSB0aGF0IGlzIGN1cnJlbnRseSBhY3RpdmUsIGNhbm5vdCBiZSBkZWxldGVkLgorCitTaW1pbGFy bHksIHRoZSB3cml0ZXMgdG8gYm90aCBgYHVwZGF0ZWBgIGFuZCBgYG5ld19wb2xpY3lgYCBhYm92 ZSB3aWxsCityZXN1bHQgaW4gYW4gZXJyb3IgdXBvbiBzeW50YWN0aWNhbGx5IGludmFsaWQgb3Ig dW50cnVzdGVkIHBvbGljaWVzLgorSXQgd2lsbCBhbHNvIGVycm9yIGlmIGEgcG9saWN5IGFscmVh ZHkgZXhpc3RzIHdpdGggdGhlIHNhbWUgYGBwb2xpY3lfbmFtZWBgLAoraW4gdGhlIGNhc2Ugb2Yg YGBuZXdfcG9saWN5YGAuCisKK0RlcGxveWluZyB0aGVzZSBwb2xpY2llcyB3aWxsICpub3QqIGNh dXNlIElQRSB0byBzdGFydCBlbmZvcmNpbmcgdGhpcworcG9saWN5LiBPbmNlIGRlcGxveW1lbnQg aXMgc3VjY2Vzc2Z1bCwgYSBwb2xpY3kgY2FuIGJlIG1hcmtlZCBhcyBhY3RpdmUsCit2aWEgYGAv c3lzL2tlcm5lbC9zZWN1cml0eS9pcGUvJHBvbGljeV9uYW1lL2FjdGl2ZWBgLiBJUEUgd2lsbCBl bmZvcmNlCit3aGF0ZXZlciBwb2xpY3kgaXMgbWFya2VkIGFzIGFjdGl2ZS4gRm9yIG91ciBleGFt cGxlLCB3ZSBjYW4gYWN0aXZhdGUKK3RoZSBgYEV4IFBvbGljeWBgIHZpYTo6CisKKyAgIGVjaG8g IjEiID4gIi9zeXMva2VybmVsL3NlY3VyaXR5L2lwZS9FeCBQb2xpY3kvYWN0aXZlIgorCitBdCB3 aGljaCBwb2ludCwgYGBFeCBQb2xpY3lgYCB3aWxsIG5vdyBiZSB0aGUgZW5mb3JjZWQgcG9saWN5 IG9uIHRoZQorc3lzdGVtLgorCitJUEUgYWxzbyBwcm92aWRlcyBhIHdheSB0byBkZWxldGUgcG9s aWNpZXMuIFRoaXMgY2FuIGJlIGRvbmUgdmlhIHRoZQorYGBkZWxldGVgYCBzZWN1cml0eWZzIG5v ZGUsIGBgL3N5cy9rZXJuZWwvc2VjdXJpdHkvaXBlLyRwb2xpY3lfbmFtZS9kZWxldGVgYC4KK1dy aXRpbmcgYGAxYGAgdG8gdGhhdCBmaWxlIHdpbGwgZGVsZXRlIHRoYXQgbm9kZTo6CisKKyAgIGVj aG8gIjEiID4gIi9zeXMva2VybmVsL3NlY3VyaXR5L2lwZS8kcG9saWN5X25hbWUvZGVsZXRlIgor CitUaGVyZSBpcyBvbmx5IG9uZSByZXF1aXJlbWVudCB0byBkZWxldGUgYSBwb2xpY3k6CisKKzEu IFRoZSBwb2xpY3kgYmVpbmcgZGVsZXRlZCBtdXN0IG5vdCBiZSB0aGUgYWN0aXZlIHBvbGljeS4K KworLi4gTk9URTo6CisKKyAgIElmIGEgdHJhZGl0aW9uYWwgTUFDIHN5c3RlbSBpcyBlbmFibGVk IChTRUxpbnV4LCBhcHBhcm1vciwgc21hY2spLCBhbGwKKyAgIHdyaXRlcyB0byBpcGUncyBzZWN1 cml0eWZzIG5vZGVzIHJlcXVpcmUgYGBDQVBfTUFDX0FETUlOYGAuCisKK01vZGVzCit+fn5+fgor CitJUEUgc3VwcG9ydHMgdHdvIG1vZGVzIG9mIG9wZXJhdGlvbjogcGVybWlzc2l2ZSAoc2ltaWxh ciB0byBTRUxpbnV4J3MKK3Blcm1pc3NpdmUgbW9kZSkgYW5kIGVuZm9yY2UuIFBlcm1pc3NpdmUg bW9kZSBwZXJmb3JtcyB0aGUgc2FtZSBjaGVja3MKK2FzIGVuZm9yY2UgbW9kZSwgYW5kIGxvZ3Mg cG9saWN5IHZpb2xhdGlvbnMsIGJ1dCB3aWxsIG5vdCBlbmZvcmNlIHRoZQorcG9saWN5LiBUaGlz IGFsbG93cyB1c2VycyB0byB0ZXN0IHBvbGljaWVzIGJlZm9yZSBlbmZvcmNpbmcgdGhlbS4KKwor VGhlIGRlZmF1bHQgbW9kZSBpcyBlbmZvcmNlLCBhbmQgY2FuIGJlIGNoYW5nZWQgdmlhIHRoZSBr ZXJuZWwgY29tbWFuZAorbGluZSBwYXJhbWV0ZXIgYGBpcGUuZW5mb3JjZT0oMHwxKWBgLCBvciB0 aGUgc2VjdXJpdHlmcyBub2RlCitgYC9zeXMva2VybmVsL3NlY3VyaXR5L2lwZS9lbmZvcmNlYGAu CisKKy4uIE5PVEU6OgorCisgICBJZiBhIHRyYWRpdGlvbmFsIE1BQyBzeXN0ZW0gaXMgZW5hYmxl ZCAoU0VMaW51eCwgYXBwYXJtb3IsIHNtYWNrLCBldGNldGVyYSksCisgICBhbGwgd3JpdGVzIHRv IGlwZSdzIHNlY3VyaXR5ZnMgbm9kZXMgcmVxdWlyZSBgYENBUF9NQUNfQURNSU5gYC4KKworQXVk aXQgRXZlbnRzCit+fn5+fn5+fn5+fn4KKworU3VjY2VzcyBBdWRpdGluZworXl5eXl5eXl5eXl5e Xl5eXgorCitJUEUgc3VwcG9ydHMgc3VjY2VzcyBhdWRpdGluZy4gV2hlbiBlbmFibGVkLCBhbGwg ZXZlbnRzIHRoYXQgcGFzcyBJUEUKK3BvbGljeSBhbmQgYXJlIG5vdCBibG9ja2VkIHdpbGwgZW1p dCBhbiBhdWRpdCBldmVudC4gVGhpcyBpcyBkaXNhYmxlZCBieQorZGVmYXVsdCwgYW5kIGNhbiBi ZSBlbmFibGVkIHZpYSB0aGUga2VybmVsIGNvbW1hbmQgbGluZQorYGBpcGUuc3VjY2Vzc19hdWRp dD0oMHwxKWBgIG9yIHRoZSBzZWN1cml0eWZzIG5vZGUsCitgYC9zeXMva2VybmVsL3NlY3VyaXR5 L2lwZS9zdWNjZXNzX2F1ZGl0YGAuCisKK1RoaXMgaXMgdmVyeSBub2lzeSwgYXMgSVBFIHdpbGwg Y2hlY2sgZXZlcnkgdXNlci1tb2RlIGJpbmFyeSBvbiB0aGUKK3N5c3RlbSwgYnV0IGlzIHVzZWZ1 bCBmb3IgZGVidWdnaW5nIHBvbGljaWVzLgorCisuLiBOT1RFOjoKKworICAgSWYgYSB0cmFkaXRp b25hbCBNQUMgc3lzdGVtIGlzIGVuYWJsZWQgKFNFTGludXgsIGFwcGFybW9yLCBzbWFjaywgZXRj ZXRlcmEpLAorICAgYWxsIHdyaXRlcyB0byBpcGUncyBzZWN1cml0eWZzIG5vZGVzIHJlcXVpcmUg YGBDQVBfTUFDX0FETUlOYGAuCisKK1Byb3BlcnRpZXMKKy0tLS0tLS0tLS0tLS0tCisKK0FzIGV4 cGxhaW5lZCBhYm92ZSwgSVBFIHByb3BlcnRpZXMgYXJlIGBga2V5PXZhbHVlYGAgcGFpcnMgZXhw cmVzc2VkIGluCitJUEUgcG9saWN5LiBUd28gcHJvcGVydGllcyBhcmUgYnVpbHQtaW50byB0aGUg cG9saWN5IHBhcnNlcjogJ29wJyBhbmQKKydhY3Rpb24nLiBUaGUgb3RoZXIgcHJvcGVydGllcyBh cmUgZGV0ZXJtaW5zdGljIGF0dHJpYnV0ZXMgdG8gZXhwcmVzcworYWNyb3NzIGZpbGVzLiBDdXJy ZW50bHkgdGhvc2UgcHJvcGVydGllcyBhcmU6ICdib290X3ZlcmlmaWVkJywKKydkbXZlcml0eV9z aWduYXR1cmUnLCAnZG12ZXJpdHlfcm9vdGhhc2gnLCAnZnN2ZXJpdHlfc2lnbmF0dXJlJywKKydm c3Zlcml0eV9kaWdlc3QnLiBBIGRlc2NyaXB0aW9uIG9mIGFsbCBwcm9wZXJ0aWVzIHN1cHBvcnRl ZCBieSBJUEUKK2FyZSBsaXN0ZWQgYmVsb3c6CisKK29wCit+fgorCitJbmRpY2F0ZXMgdGhlIG9w ZXJhdGlvbiBmb3IgYSBydWxlIHRvIGFwcGx5IHRvLiBNdXN0IGJlIGluIGV2ZXJ5IHJ1bGUsCith cyB0aGUgZmlyc3QgdG9rZW4uIElQRSBzdXBwb3J0cyB0aGUgZm9sbG93aW5nIG9wZXJhdGlvbnM6 CisKK1ZlcnNpb24gMQorXl5eXl5eXl5eCisKK2BgRVhFQ1VURWBgCisKKyAgIFBlcnRhaW5zIHRv IGFueSBmaWxlIGF0dGVtcHRpbmcgdG8gYmUgZXhlY3V0ZWQsIG9yIGxvYWRlZCBhcyBhbgorICAg ZXhlY3V0YWJsZS4KKworYGBGSVJNV0FSRWBgOgorCisgICBQZXJ0YWlucyB0byBmaXJtd2FyZSBi ZWluZyBsb2FkZWQgdmlhIHRoZSBmaXJtd2FyZV9jbGFzcyBpbnRlcmZhY2UuCisgICBUaGlzIGNv dmVycyBib3RoIHRoZSBwcmVhbGxvY2F0ZWQgYnVmZmVyIGFuZCB0aGUgZmlybXdhcmUgZmlsZQor ICAgaXRzZWxmLgorCitgYEtNT0RVTEVgYDoKKworICAgUGVydGFpbnMgdG8gbG9hZGluZyBrZXJu ZWwgbW9kdWxlcyB2aWEgYGBtb2Rwcm9iZWBgIG9yIGBgaW5zbW9kYGAuCisKK2BgS0VYRUNfSU1B R0VgYDoKKworICAgUGVydGFpbnMgdG8ga2VybmVsIGltYWdlcyBsb2FkaW5nIHZpYSBgYGtleGVj YGAuCisKK2BgS0VYRUNfSU5JVFJBTUZTYGAKKworICAgUGVydGFpbnMgdG8gaW5pdHJkIGltYWdl cyBsb2FkaW5nIHZpYSBgYGtleGVjIC0taW5pdHJkYGAuCisKK2BgUE9MSUNZYGA6CisKKyAgIENv bnRyb2xzIGxvYWRpbmcgSU1BIHBvbGljaWVzIHRocm91Z2ggdGhlCisgICBgYC9zeXMva2VybmVs L3NlY3VyaXR5L2ltYS9wb2xpY3lgYCBzZWN1cml0eWZzIGVudHJ5LgorCitgYFg1MDlfQ0VSVGBg OgorCisgICBDb250cm9scyBsb2FkaW5nIElNQSBjZXJ0aWZpY2F0ZXMgdGhyb3VnaCB0aGUgS2Nv bmZpZ3MsCisgICBgYENPTkZJR19JTUFfWDUwOV9QQVRIYGAgYW5kIGBgQ09ORklHX0VWTV9YNTA5 X1BBVEhgYC4KKworYGBLRVJORUxfUkVBRGBgOgorCisgICBTaG9ydCBoYW5kIGZvciBhbGwgb2Yg dGhlIGZvbGxvd2luZzogYGBGSVJNV0FSRWBgLCBgYEtNT0RVTEVgYCwKKyAgIGBgS0VYRUNfSU1B R0VgYCwgYGBLRVhFQ19JTklUUkFNRlNgYCwgYGBQT0xJQ1lgYCwgYW5kIGBgWDUwOV9DRVJUYGAu CisKK2FjdGlvbgorfn5+fn5+CisKK1ZlcnNpb24gMQorXl5eXl5eXl5eCisKK0RldGVybWluZXMg d2hhdCBJUEUgc2hvdWxkIGRvIHdoZW4gYSBydWxlIG1hdGNoZXMuIE11c3QgYmUgaW4gZXZlcnkK K3J1bGUsIGFzIHRoZSBmaW5hbCBjbGF1c2UuIENhbiBiZSBvbmUgb2Y6CisKK2BgQUxMT1dgYDoK KworICAgSWYgdGhlIHJ1bGUgbWF0Y2hlcywgZXhwbGljaXRseSBhbGxvdyBhY2Nlc3MgdG8gdGhl IHJlc291cmNlIHRvIHByb2NlZWQKKyAgIHdpdGhvdXQgZXhlY3V0aW5nIGFueSBtb3JlIHJ1bGVz LgorCitgYERFTllgYDoKKworICAgSWYgdGhlIHJ1bGUgbWF0Y2hlcywgZXhwbGljaXRseSBwcm9o aWJpdCBhY2Nlc3MgdG8gdGhlIHJlc291cmNlIHRvCisgICBwcm9jZWVkIHdpdGhvdXQgZXhlY3V0 aW5nIGFueSBtb3JlIHJ1bGVzLgorCitib290X3ZlcmlmaWVkCit+fn5+fn5+fn5+fn5+CisKK1Zl cnNpb24gMQorXl5eXl5eXl5eCisKK1RoaXMgcHJvcGVydHkgY2FuIGJlIHV0aWxpemVkIGZvciBh dXRob3JpemF0aW9uIG9mIHRoZSBmaXJzdCBzdXBlci1ibG9jawordGhhdCBleGVjdXRlcyBhIGZp bGUuIFRoaXMgaXMgYWxtb3N0IGFsd2F5cyBpbml0LiBUeXBpY2FsbHkgdGhpcyBpcyB1c2VkCitm b3Igc3lzdGVtcyB3aXRoIGFuIGluaXRyYW1mcyBvciBvdGhlciBpbml0aWFsIGRpc2ssIHdoZXJl IHRoaXMgaXMgdW5tb3VudGVkCitiZWZvcmUgdGhlIHN5c3RlbSBiZWNvbWVzIGF2YWlsYWJsZSwg YW5kIGlzIG5vdCBjb3ZlcmVkIGJ5IGFueSBvdGhlciBwcm9wZXJ0eS4KK1RoaXMgcHJvcGVydHkg aXMgY29udHJvbGxlZCBieSB0aGUgS2NvbmZpZywgYGBDT05GSUdfSVBFX1BST1BfQk9PVF9WRVJJ RklFRGBgLgorVGhlIGZvcm1hdCBvZiB0aGlzIHByb3BlcnR5IGlzOjoKKworICAgICAgIGJvb3Rf dmVyaWZpZWQ9KFRSVUV8RkFMU0UpCisKKworLi4gV0FSTklORzo6CisKKyAgVGhpcyBwcm9wZXJ0 eSB3aWxsIHRydXN0IGFueSBkaXNrIHdoZXJlIHRoZSBmaXJzdCBleGVjdXRpb24gZXZhbHVhdGlv bgorICBvY2N1cnMuIElmIHlvdSBkbyAqTk9UKiBoYXZlIGEgc3RhcnR1cCBkaXNrIHRoYXQgaXMg dW5wYWNrZWQgYW5kIHVubW91bnRlZAorICAobGlrZSBpbml0cmFtZnMpLCB0aGVuIGl0IHdpbGwg YXV0b21hdGljYWxseSB0cnVzdCB0aGUgcm9vdCBmaWxlc3lzdGVtIGFuZAorICBwb3RlbnRpYWxs eSBvdmVyYXV0aG9yaXplIHRoZSBlbnRpcmUgZGlzay4KKworZG12ZXJpdHlfcm9vdGhhc2gKK35+ fn5+fn5+fn5+fn5+fn5+CisKK1ZlcnNpb24gMQorXl5eXl5eXl5eCisKK1RoaXMgcHJvcGVydHkg Y2FuIGJlIHV0aWxpemVkIGZvciBhdXRob3JpemF0aW9uIG9yIHJldm9jYXRpb24gb2YKK3NwZWNp ZmljIGRtLXZlcml0eSB2b2x1bWVzLCBpZGVudGlmaWVkIHZpYSByb290IGhhc2guIEl0IGhhcyBh CitkZXBlbmRlbmN5IG9uIHRoZSBETV9WRVJJVFkgbW9kdWxlLiBUaGlzIHByb3BlcnR5IGlzIGNv bnRyb2xsZWQgYnkgdGhlCitLY29uZmlnIGBgQ09ORklHX0lQRV9QUk9QX0RNX1ZFUklUWV9ST09U SEFTSGBgLiBUaGUgZm9ybWF0IG9mIHRoaXMgcHJvcGVydHkKK2lzOjoKKworICAgZG12ZXJpdHlf cm9vdGhhc2g9SGFzaEhleERpZ2VzdAorCitkbXZlcml0eV9zaWduYXR1cmUKK35+fn5+fn5+fn5+ fn5+fn5+fgorCitWZXJzaW9uIDEKK15eXl5eXl5eXgorCitUaGlzIHByb3BlcnR5IGNhbiBiZSB1 dGlsaXplZCBmb3IgYXV0aG9yaXphdGlvbiBvZiBhbGwgZG0tdmVyaXR5IHZvbHVtZXMKK3RoYXQg aGF2ZSBhIHNpZ25lZCByb290aGFzaCB0aGF0IGNoYWlucyB0byBhIGtleXJpbmcgc3BlY2lmaWVk IGJ5IGRtLXZlcml0eSdzCitjb25maWd1cmF0aW9uLCBlaXRoZXIgdGhlIHN5c3RlbSB0cnVzdGVk IGtleXJpbmcsIG9yIHRoZSBzZWNvbmRhcnkga2V5cmluZy4KK0l0IGhhcyBhbiBhZGRpdGlvbmFs IGRlcGVuZGVuY3kgb24gdGhlIGBgRE1fVkVSSVRZX1ZFUklGWV9ST09USEFTSF9TSUdgYAorS2Nv bmZpZy4gVGhpcyBwcm9wZXJ0eSBpcyBjb250cm9sbGVkIGJ5IHRoZSBLY29uZmlnCitgYENPTkZJ R19JUEVfUFJPUF9ETV9WRVJJVFlfU0lHTkFUVVJFYGAuIFRoZSBmb3JtYXQgb2YgdGhpcyBwcm9w ZXJ0eSBpczo6CisKKyAgIGRtdmVyaXR5X3NpZ25hdHVyZT0oVFJVRXxGQUxTRSkKKworZnN2ZXJp dHlfZGlnZXN0Cit+fn5+fn5+fn5+fn5+fn4KKworVmVyc2lvbiAxCiteXl5eXl5eXl4KK1RoaXMg cHJvcGVydHkgY2FuIGJlIHV0aWxpemVkIGZvciBhdXRob3JpemF0aW9uIG9yIHJldm9jYXRpb24g b2YKK3NwZWNpZmljIGZzdmVyaXR5IGVuYWJsZWQgZmlsZSwgaWRlbnRpZmllZCB2aWEgaXRzIGZz dmVyaXR5IGRpZ2VzdCwKK3doaWNoIGlzIHRoZSBoYXNoIG9mIGEgc3RydWN0IGNvbnRhaW5zIHRo ZSBmaWxlJ3Mgcm9vdGhhc2ggYW5kIGhhc2hpbmcKK3BhcmFtZXRlcnMuIEl0IGhhcyBhIGRlcGVu ZGVuY3kgb24gdGhlIEZTX1ZFUklUWSBtb2R1bGUuCitUaGlzIHByb3BlcnR5IGlzIGNvbnRyb2xs ZWQgYnkgdGhlIEtjb25maWcKK2BgQ09ORklHX0lQRV9QUk9QX0ZTX1ZFUklUWV9ESUdFU1RgYC4g VGhlIGZvcm1hdCBvZiB0aGlzIHByb3BlcnR5IGlzOjoKKworICAgZnN2ZXJpdHlfZGlnZXN0PUhh c2hIZXhEaWdlc3QKKworZnN2ZXJpdHlfc2lnbmF0dXJlCit+fn5+fn5+fn5+fn5+fn5+fn4KKwor VmVyc2lvbiAxCiteXl5eXl5eXl4KKworVGhpcyBwcm9wZXJ0eSBjYW4gYmUgdXRpbGl6ZWQgZm9y IGF1dGhvcml6YXRpb24gb2YgYWxsIGZzdmVyaXR5IGVuYWJsZWQKK2ZpbGVzIHRoYXQgaXMgdmVy aWZpZWQgYnkgZnN2ZXJpdHkuIFRoZSBrZXlyaW5nIHRoYXQgaXMgdmVyaWZpZXMgYWdhaW5zdAor aXMgc3ViamVjdCB0byBmc3Zlcml0eSdzIGNvbmZpZ3VyYXRpb24sIHdoaWNoIGlzIHR5cGljYWxs eSB0aGUgZnN2ZXJpdHkKK2tleXJpbmcuIEl0IGhhcyBhIGRlcGVuZGVuY3kgb24gdGhlIGBgQ09O RklHX0ZTX1ZFUklUWV9CVUlMVElOX1NJR05BVFVSRVNgYAorS2NvbmZpZy4gVGhpcyBwcm9wZXJ0 eSBpcyBjb250cm9sbGVkIGJ5IHRoZSBLY29uZmlnCitgYENPTkZJR19JUEVfUFJPUF9GU19WRVJJ VFlfU0lHTkFUVVJFYGAuIFRoZSBmb3JtYXQgb2YgdGhpcyBwcm9wZXJ0eSBpczo6CisKKyAgIGZz dmVyaXR5X3NpZ25hdHVyZT0oVFJVRXxGQUxTRSkKKworUG9saWN5IEV4YW1wbGVzCistLS0tLS0t LS0tLS0tLS0KKworQWxsb3cgYWxsCit+fn5+fn5+fn4KKworOjoKKworICAgcG9saWN5X25hbWU9 IkFsbG93IEFsbCIgcG9saWN5X3ZlcnNpb249MC4wLjAKKyAgIERFRkFVTFQgYWN0aW9uPUFMTE9X CisKK0FsbG93IG9ubHkgaW5pdGlhbCBzdXBlcmJsb2NrCit+fn5+fn5+fn5+fn5+fn5+fn5+fn5+ fn5+fn5+fgorCis6OgorCisgICBwb2xpY3lfbmFtZT0iQWxsb3cgQWxsIEluaXRpYWwgU0IiIHBv bGljeV92ZXJzaW9uPTAuMC4wCisgICBERUZBVUxUIGFjdGlvbj1ERU5ZCisKKyAgIG9wPUVYRUNV VEUgYm9vdF92ZXJpZmllZD1UUlVFIGFjdGlvbj1BTExPVworCitBbGxvdyBhbnkgc2lnbmVkIGRt LXZlcml0eSB2b2x1bWUgYW5kIHRoZSBpbml0aWFsIHN1cGVyYmxvY2sKK35+fn5+fn5+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fgorCis6OgorCisg ICBwb2xpY3lfbmFtZT0iQWxsb3dTaWduZWRBbmRJbml0aWFsIiBwb2xpY3lfdmVyc2lvbj0wLjAu MAorICAgREVGQVVMVCBhY3Rpb249REVOWQorCisgICBvcD1FWEVDVVRFIGJvb3RfdmVyaWZpZWQ9 VFJVRSBhY3Rpb249QUxMT1cKKyAgIG9wPUVYRUNVVEUgZG12ZXJpdHlfc2lnbmF0dXJlPVRSVUUg YWN0aW9uPUFMTE9XCisKK1Byb2hpYml0IGV4ZWN1dGlvbiBmcm9tIGEgc3BlY2lmaWMgZG0tdmVy aXR5IHZvbHVtZQorfn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+ fn5+fn5+CisKKzo6CisKKyAgIHBvbGljeV9uYW1lPSJBbGxvd1NpZ25lZEFuZEluaXRpYWwiIHBv bGljeV92ZXJzaW9uPTAuMC4wCisgICBERUZBVUxUIGFjdGlvbj1ERU5ZCisKKyAgIG9wPUVYRUNV VEUgZG12ZXJpdHlfcm9vdGhhc2g9NDAxZmNlYzU5NDQ4MjNhZTEyZjYyNzI2ZTgxODQ0MDdhNWZh OTU5OTc4M2YwMzBkZWMxNDY5MzggYWN0aW9uPURFTlkKKyAgIG9wPUVYRUNVVEUgYm9vdF92ZXJp ZmllZD1UUlVFIGFjdGlvbj1BTExPVworICAgb3A9RVhFQ1VURSBkbXZlcml0eV9zaWduYXR1cmU9 VFJVRSBhY3Rpb249QUxMT1cKKworQWxsb3cgb25seSBhIHNwZWNpZmljIGRtLXZlcml0eSB2b2x1 bWUKK35+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+CisKKzo6CisKKyAgIHBv bGljeV9uYW1lPSJBbGxvd1NpZ25lZEFuZEluaXRpYWwiIHBvbGljeV92ZXJzaW9uPTAuMC4wCisg ICBERUZBVUxUIGFjdGlvbj1ERU5ZCisKKyAgIG9wPUVYRUNVVEUgZG12ZXJpdHlfcm9vdGhhc2g9 NDAxZmNlYzU5NDQ4MjNhZTEyZjYyNzI2ZTgxODQ0MDdhNWZhOTU5OTc4M2YwMzBkZWMxNDY5Mzgg YWN0aW9uPUFMTE9XCisKK0FsbG93IGFueSBzaWduZWQgZnMtdmVyaXR5IGZpbGUKK35+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fgorCis6 OgorCisgICBwb2xpY3lfbmFtZT0iQWxsb3dTaWduZWRGU1Zlcml0eSIgcG9saWN5X3ZlcnNpb249 MC4wLjAKKyAgIERFRkFVTFQgYWN0aW9uPURFTlkKKworICAgb3A9RVhFQ1VURSBmc3Zlcml0eV9z aWduYXR1cmU9VFJVRSBhY3Rpb249QUxMT1cKKworUHJvaGliaXQgZXhlY3V0aW9uIG9mIGEgc3Bl Y2lmaWMgZnMtdmVyaXR5IGZpbGUKK35+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fgorCis6OgorCisgICBwb2xpY3lfbmFtZT0iUHJvaGliaXRTcGVjaWZp Y0ZTVkYiIHBvbGljeV92ZXJzaW9uPTAuMC4wCisgICBERUZBVUxUIGFjdGlvbj1ERU5ZCisKKyAg IG9wPUVYRUNVVEUgZnN2ZXJpdHlfZGlnZXN0PWZkODhmMmI4ODI0ZTE5N2Y4NTBiZjRjNTEwOWJl YTVjZjBlZTM4MTA0ZjcxMDg0M2JiNzJkYTc5NmJhNWFmOWUgYWN0aW9uPURFTlkKKyAgIG9wPUVY RUNVVEUgYm9vdF92ZXJpZmllZD1UUlVFIGFjdGlvbj1BTExPVworICAgb3A9RVhFQ1VURSBkbXZl cml0eV9zaWduYXR1cmU9VFJVRSBhY3Rpb249QUxMT1cKKworQWRkaXRpb25hbCBJbmZvcm1hdGlv bgorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCistIGBHaXRodWIgUmVwb3NpdG9yeSA8aHR0cHM6 Ly9naXRodWIuY29tL21pY3Jvc29mdC9pcGU+YF8KKy0gYERlc2lnbiBEb2N1bWVudGF0aW9uIDwv c2VjdXJpdHkvaXBlPmBfCisKK0ZBUQorLS0tCisKKzpROiBXaGF0J3MgdGhlIGRpZmZlcmVuY2Ug YmV0d2VlbiBvdGhlciBMU01zIHdoaWNoIHByb3ZpZGUgdHJ1c3QtYmFzZWQKKyAgIGFjY2VzcyBj b250cm9sLCBmb3IgaW5zdGFuY2UsIElNQT8KKworOkE6IElNQSBpcyBhIGZhbnRhc3RpYyBvcHRp b24gd2hlbiBuZWVkaW5nIG1lYXN1cmVtZW50IGluIGFkZGl0aW9uIHRvIHRoZQorICAgdHJ1c3Qt YmFzZWQgYWNjZXNzIG1vZGVsLiBBbGwgb2YgSU1BIGlzIGNlbnRlcmVkIGFyb3VuZCB0aGVpciBt ZWFzdXJlbWVudAorICAgaGFzaGVzLCBzbyB5b3Ugc2F2ZSB0aW1lIHdoZW4gZG9pbmcgYm90aCBh Y3Rpb25zLiBJUEUsIG9uIHRoZSBvdGhlciBoYW5kLAorICAgaXMgYSBoaWdobHkgcGVyZm9ybWFu dCBzeXN0ZW0gdGhhdCBkb2VzIG5vdCByZWx5IChhbmQgZXhwbGljaXRseSBwcm9oaWJpdHMpLAor ICAgZ2VuZXJhdGluZyBpdHMgb3duIGludGVncml0eSBtZWNoYW5pc21zIC0gc2VwYXJhdGluZyBt ZWFzdXJlbWVudCBhbmQgYWNjZXNzCisgICBjb250cm9sLiBTaW1wbHkgcHV0LCBJUEUgcHJvdmlk ZXMgb25seSB0aGUgZW5mb3JjZW1lbnQgb2YgdHJ1c3QsIHdoaWxlIG90aGVyCisgICBzdWJzeXN0 ZW1zIHByb3ZpZGUgdGhlIGludGVncml0eSBndWFyYW50ZWUgdGhhdCBJUEUgbmVlZHMgdG8gZGV0 ZXJtaW5lIHRoZQorICAgdHJ1c3Qgb2YgYSByZXNvdXJjZS4gSU1BIHByb3ZpZGVzIGJvdGggdGhl IGludGVncml0eSBndWFyYW50ZWUsIGFuZCB0aGUKKyAgIGVuZm9yY2VtZW50IG9mIHRydXN0Lgpk aWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9hZG1pbi1ndWlkZS9rZXJuZWwtcGFyYW1ldGVycy50 eHQgYi9Eb2N1bWVudGF0aW9uL2FkbWluLWd1aWRlL2tlcm5lbC1wYXJhbWV0ZXJzLnR4dAppbmRl eCA0M2RjMzVmZTViYzAuLjg1ZGQ2NTRlNjQyZiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9h ZG1pbi1ndWlkZS9rZXJuZWwtcGFyYW1ldGVycy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9hZG1p bi1ndWlkZS9rZXJuZWwtcGFyYW1ldGVycy50eHQKQEAgLTIwOTYsNiArMjA5NiwxOCBAQAogCWlw Y21uaV9leHRlbmQJW0tOTF0gRXh0ZW5kIHRoZSBtYXhpbXVtIG51bWJlciBvZiB1bmlxdWUgU3lz dGVtIFYKIAkJCUlQQyBpZGVudGlmaWVycyBmcm9tIDMyLDc2OCB0byAxNiw3NzcsMjE2LgogCisJ aXBlLmVuZm9yY2U9CVtJUEVdCisJCQlGb3JtYXQ6IDxib29sPgorCQkJRGV0ZXJtaW5lIHdoZXRo ZXIgSVBFIHN0YXJ0cyBpbiBwZXJtaXNzaXZlICgwKSBvcgorCQkJZW5mb3JjZSAoMSkgbW9kZS4g VGhlIGRlZmF1bHQgaXMgZW5mb3JjZS4KKworCWlwZS5zdWNjZXNzX2F1ZGl0PQorCQkJW0lQRV0K KwkJCUZvcm1hdDogPGJvb2w+CisJCQlTdGFydCBJUEUgd2l0aCBzdWNjZXNzIGF1ZGl0aW5nIGVu YWJsZWQsIGVtaXR0aW5nCisJCQlhbiBhdWRpdCBldmVudCB3aGVuIGEgYmluYXJ5IGlzIGFsbG93 ZWQuIFRoZSBkZWZhdWx0CisJCQlpcyAwLgorCiAJaXJxYWZmaW5pdHk9CVtTTVBdIFNldCB0aGUg ZGVmYXVsdCBpcnEgYWZmaW5pdHkgbWFzawogCQkJVGhlIGFyZ3VtZW50IGlzIGEgY3B1IGxpc3Qs IGFzIGRlc2NyaWJlZCBhYm92ZS4KIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9zZWN1cml0 eS9pbmRleC5yc3QgYi9Eb2N1bWVudGF0aW9uL3NlY3VyaXR5L2luZGV4LnJzdAppbmRleCAxNjMz NWRlMDRlOGMuLmMwNjUzMGI1MDUxNCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9zZWN1cml0 eS9pbmRleC5yc3QKKysrIGIvRG9jdW1lbnRhdGlvbi9zZWN1cml0eS9pbmRleC5yc3QKQEAgLTE3 LDMgKzE3LDQgQEAgU2VjdXJpdHkgRG9jdW1lbnRhdGlvbgogICAgdHBtL2luZGV4CiAgICBkaWdz aWcKICAgIGxhbmRsb2NrCisgICBpcGUKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vc2VjdXJp dHkvaXBlLnJzdCBiL0RvY3VtZW50YXRpb24vc2VjdXJpdHkvaXBlLnJzdApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmU2OTFlMDhlMDMwMwotLS0gL2Rldi9udWxsCisr KyBiL0RvY3VtZW50YXRpb24vc2VjdXJpdHkvaXBlLnJzdApAQCAtMCwwICsxLDMzOSBAQAorLi4g U1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKKworSW50ZWdyaXR5IFBvbGljeSBFbmZv cmNlbWVudCAoSVBFKSAtIERlc2lnbiBEb2N1bWVudHMKKz09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CisKKy4uIE5PVEU6OgorCisgICBUaGlzIGlz IHRoZSBkb2N1bWVudGF0aW9uIGZvciBrZXJuZWwgZGV2ZWxvcGVycyBhbmQgb3RoZXIgaW5kaXZp ZHVhbHMKKyAgIHdobyB3YW50IHRvIHVuZGVyc3RhbmQgdGhlIHJlYXNvbiBiZWhpbmQgd2h5IElQ RSBpcyBkZXNpZ25lZCB0aGUgd2F5IGl0CisgICBpcywgYXMgd2VsbCBhcyBhIHRvdXIgb2YgdGhl IGltcGxlbWVudGF0aW9uLiBJZiB5b3UncmUgbG9va2luZyBmb3IKKyAgIGRvY3VtZW50YXRpb24g b24gdGhlIHVzYWdlIG9mIElQRSwgcGxlYXNlIHNlZQorICAgOnJlZjpgRG9jdW1lbnRhdGlvbi9h ZG1pbi1ndWlkZS9MU00vaXBlLnJzdGAKKworUm9sZSBhbmQgU2NvcGUKKy0tLS0tLS0tLS0tLS0t CisKK0lQRSBvcmlnaW5hbGx5IHN0YXJ0ZWQgd2l0aCBhIHNpbXBsZSBnb2FsOiBjcmVhdGUgYSBz eXN0ZW0gdGhhdCBjYW4KK2Vuc3VyZSB0aGF0IG9ubHkgdHJ1c3RlZCB1c2VybW9kZSBiaW5hcmll cyBhcmUgYWxsb3dlZCB0byBiZSBleGVjdXRlZC4KKworRHVyaW5nIHRoZSBkZXNpZ24gcGhhc2Ug aXQgd2FzIGFwcGFyZW50IHRoYXQgdGhlcmUgYXJlIG11bHRpcGxlIHN5c3RlbXMKK3dpdGhpbiB0 aGUgTGludXgga2VybmVsIHRoYXQgY2FuIHByb3ZpZGUgc29tZSBsZXZlbCBvZiBpbnRlZ3JpdHkK K3ZlcmlmaWNhdGlvbiwgYW5kIGJ5IGFzc29jaWF0aW9uLCB0cnVzdCBmb3IgaXRzIGNvbnRlbnQ6 CisKKyAgMS4gRE0tVmVyaXR5CisgIDIuIEZTLVZlcml0eQorICAzLiBJTUEgKyBFVk0KKworSG93 ZXZlciwgb2YgdGhvc2Ugc3lzdGVtcyBvbmx5IHRoZSB0aGlyZCBvcHRpb24gaGFzIHRoZSBhYmls aXR5IHRvIGVuZm9yY2UKK3RydXN0IHJlcXVpcmVtZW50cyBvbiB0aGUgd2hvbGUgc3lzdGVtLiBJ dHMgYXJjaGl0ZWN0dXJlLCBob3dldmVyIGlzIGNlbnRlcmVkCithcm91bmQgaXRzIG93biBmb3Jt IG9mIHZlcmlmaWNhdGlvbnMsIGFuZCBhIG11bHRpdHVkZSBvZiBhY3Rpb25zIHN1cnJvdW5kaW5n Cit0aG9zZSB2ZXJpZmljYXRpb25zIHdpdGggdmFyaW91cyBwdXJwb3NlcywgdGhlIG1vc3QgcHJv bWluZW50IGJlaW5nIG1lYXN1cmVtZW50CithbmQgdmVyaWZpY2F0aW9uIChhcHByYWlzYWwpLiBU aGlzIG1ha2VzIGl0IHVuc3VpdGFibGUgZnJvbSBhIGxheWVyaW5nIGFuZAorYXJjaGl0ZWN0dXJh bCBwdXJwb3NlLCBhcyBJUEUncyBnb2FsIGlzIGxpbWl0ZWQgdG8gZW5zdXJlIGp1c3QgdHJ1c3Rl ZCB1c2VybW9kZQorYmluYXJpZXMgYXJlIGV4ZWN1dGVkLCB3aXRoIHRoZSBpbnRlbnRpb25hbCBn b2FsIG9mIHN1cHBvcnRpbmcgbXVsdGlwbGUgbWV0aG9kcworZnJvbSBhIGhpZ2hlciBzdWJzeXN0 ZW0gbGF5ZXIgKGkuZS4gZnMsIGJsb2NrLCBvciBzdXBlcl9ibG9jaykuCisKK1RoZSB0d28gb3Ro ZXIgb3B0aW9ucywgZG0tdmVyaXR5IGFuZCBmcy12ZXJpdHkgYXJlIG1pc3NpbmcgYSBjcnVjaWFs IGNvbXBvbmVudAordG8gYWNjb21wbGlzaCB0aGUgZ29hbCBvZiBJUEU6IGEgcG9saWN5IHRvIGlu ZGljYXRlIHRoZSByZXF1aXJlbWVudHMgb2YKK2Fuc3dlcmluZyB0aGUgcXVlc3Rpb24gIldoYXQg aXMgVHJ1c3RlZD8iIGFuZCBhIHN5c3RlbS13aWRlIGxldmVsIG9mIGVuZm9yY2luZwordGhvc2Ug cmVxdWlyZW1lbnRzLgorCitUaGVyZWZvcmUsIElQRSB3YXMgZGVzaWduZWQgYXJvdW5kOgorCisg IDEuIEVhc3kgY29uZmlndXJhdGlvbiBvZiB0cnVzdCBtZWNoYW5pc21zCisgIDIuIEVhc2Ugb2Yg aW50ZWdyYXRpb24gd2l0aCBvdGhlciBsYXllcnMKKyAgMy4gRWFzZSBvZiB1c2UgZm9yIHBsYXRm b3JtIGFkbWluaXN0cmF0b3JzLgorCitEZXNpZ24gRGVjaXNpb25zCistLS0tLS0tLS0tLS0tLS0t CisKK1BvbGljeQorfn5+fn5+CisKK1BsYWluIFRleHQKK15eXl5eXl5eXl4KKworVW5saWtlIG90 aGVyIExTTXMsIElQRSdzIHBvbGljeSBpcyBwbGFpbi10ZXh0LiBUaGlzIGludHJvZHVjZXMgc2xp Z2h0bHkgbGFyZ2VyCitwb2xpY3kgZmlsZXMgdGhhbiBvdGhlciBMU01zLCBidXQgc29sdmVzIHR3 byBtYWpvciBwcm9ibGVtcyB0aGF0IG9jY3VycyB3aXRoCitvdGhlciB0cnVzdC1iYXNlZCBhY2Nl c3MgY29udHJvbCBzeXN0ZW1zLgorCitUaGUgZmlyc3QgaXNzdWUgaXMgb25lIG9mIGNvZGUgbWFp bnRlbmFuY2UgYW5kIGR1cGxpY2F0aW9uLiBUbyBhdXRob3IgcG9saWNpZXMsCit0aGUgcG9saWN5 IGhhcyB0byBiZSBzb21lIGZvcm0gb2Ygc3RyaW5nIHJlcHJlc2VudGF0aW9uIChiZSBpdCBzdHJ1 Y3R1cmVkLAordGhyb3VnaCBYTWwsIEpTT04sIFlBTUwsIGV0Y2V0ZXJhKSwgdG8gYWxsb3cgdGhl IHBvbGljeSBhdXRob3IgdG8gdW5kZXJzdGFuZAord2hhdCBpcyBiZWluZyB3cml0dGVuLiBJbiBh IGh5cG90aGV0aWNhbCBiaW5hcnkgcG9saWN5IGRlc2lnbiwgdGhhdCBhIHNlcmlhbGl6ZXIKK211 c3QgYmUgd3JpdHRlbiB0byB3cml0ZSBzYWlkIGJpbmFyeSBmb3JtLCBmb3IgYSAqbWFqb3JpdHkq IG9mIGh1bWFucyB0byBiZQorYWJsZSB0byB1dGlsaXplIGl0IHByb3Blcmx5LgorCitBZGRpdGlv bmFsbHksIGEgZGVzZXJpYWxpemVyIHdpbGwgZXZlbnR1YWxseSBiZSBuZWVkZWQgdG8gdHJhbnNm b3JtIHRoZSBiaW5hcnkKK2JhY2sgaW50byB0ZXh0IHdpdGggYXMgbXVjaCBpbmZvcm1hdGlvbiBw cmVzZXJ2ZWQuIFdpdGhvdXQgYSBkZXNlcmlhbGl6ZXIsIGEKK3VzZXIgb2YgdGhpcyBhY2Nlc3Mg Y29udHJvbCBzeXN0ZW0gd2lsbCBoYXZlIHRvIGtlZXAgYSBsb29rdXAgdGFibGUgb2YgZWl0aGVy CithIGNoZWNrc3VtLCBvciB0aGUgZmlsZSBpdHNlbGYgdG8gdHJ5IHRvIHVuZGVyc3RhbmQgd2hh dCBwb2xpY2llcyBoYXZlIGJlZW4KK2RlcGxveWVkIG9uIHRoaXMgc3lzdGVtIGFuZCB3aGF0IHBv bGljaWVzIGhhdmUgbm90LiBGb3IgYSBzaW5nbGUgdXNlciwgdGhpcworbWF5IGJlIGFscmlnaHQs IGFzIG9sZCBwb2xpY2llcyBjYW4gYmUgZGlzY2FyZGVkIGFsbW9zdCBpbW1lZGlhdGVseSBhZnRl cgordGhlIHVwZGF0ZSB0YWtlcyBob2xkLgorCitGb3IgdXNlcnMgdGhhdCBtYW5hZ2UgZmxlZXRz IGluIHRoZSB0aG91c2FuZHMsIGlmIG5vdCBodW5kcmVkcyBvZiB0aG91c2FuZHMsCit0aGlzIHF1 aWNrbHkgYmVjb21lcyBhbiBpc3N1ZSwgYXMgc3RhbGUgcG9saWNpZXMgZnJvbSB5ZWFycyBhZ28g bWF5IGJlIHByZXNlbnQsCitxdWlja2x5IHJlc3VsdGluZyBpbiB0aGUgbmVlZCB0byByZWNvdmVy IHRoZSBwb2xpY3kgb3IgZnVuZCBleHRlbnNpdmUKK2luZnJhc3RydWN0dXJlIHRvIHRyYWNrIHdo YXQgZWFjaCBwb2xpY3kgY29udGFpbnMuCisKK1NlY29uZGx5LCBhIHNlcmlhbGl6ZXIgaXMgc3Rp bGwgbmVlZGVkIHdpdGggYSBwbGFpbi10ZXh0IHBvbGljeSAoYXMgdGhlIHBsYWluCit0ZXh0IHBv bGljeSBzdGlsbCBoYXMgdG8gYmUgc2VyaWFsaXplZCB0byBhIGRhdGEgc3RydWN0dXJlIGluIHRo ZSBrZXJuZWwpLCBzbworbm90IG11Y2ggaXMgc2F2ZWQuCisKK1RoZSBzZWNvbmQgaXNzdWUgaXMg b25lIG9mIHRyYW5zcGFyZW5jeS4gQXMgSVBFIGNvbnRyb2xzIGFjY2VzcyBiYXNlZCBvbiB0cnVz dCwKK2l0J3MgcG9saWN5IG11c3QgYWxzbyBiZSB0cnVzdGVkIHRvIGJlIGNoYW5nZWQuIFRoaXMg aXMgZG9uZSB0aHJvdWdoIHNpZ25hdHVyZXMsCitjaGFpbmluZyB0byB0aGUgU1lTVEVNX1RSVVNU RURfS0VZUklORy4gVGhlIGNvbmZpZGVuY2Ugb2Ygc2lnbmluZyBhIHBsYWluLXRleHQKK3BvbGlj eSBpbiB3aGljaCB5b3UgY2FuIHNlZSBldmVyeSBhc3BlY3Qgb2Ygd2hhdCBpcyBiZWluZyBzaWdu ZWQgaXMgYSBzdGVwIGhpZ2hlcgordGhhbiBzaWduaW5nIGFuIG9wYXF1ZSBiaW5hcnkgYmxvYi4K KworQm9vdCBQb2xpY3kKK35+fn5+fn5+fn5+CisKK0FkZGl0aW9uYWxseSwgSVBFIHNob3VsZG4n dCBoYXZlIGFueSBvYnZpb3VzIGdhcHMgaW4gaXRzIGVuZm9yY2VtZW50IHN0b3J5LgorVGhhdCBt ZWFucywgYSBwb2xpY3kgdGhhdCBjb25maWd1cmVzIHRydXN0IHJlcXVpcmVtZW50cywgaWYgc3Bl Y2lmaWVkLCBtdXN0CitiZSBlbmZvcmNlZCBhcyBzb29uIGFzIHRoZSBrZXJuZWwgc3RhcnRzIHVw LiBUaGF0IGNhbiBiZSBhY2NvbXBsaXNoZWQgb25lCitvZiB0aHJlZSB3YXlzOgorCisgIDEuIFRo ZSBwb2xpY3kgZmlsZShzKSBsaXZlIG9uIGRpc2sgYW5kIHRoZSBrZXJuZWwgbG9hZHMgdGhlIHBv bGljeSBwcmlvcgorICAgICB0byBhbiBjb2RlIHBhdGggdGhhdCB3b3VsZCByZXN1bHQgaW4gYW4g ZW5mb3JjZW1lbnQgZGVjaXNpb24uCisgIDIuIFRoZSBwb2xpY3kgZmlsZShzKSBhcmUgcGFzc2Vk IGJ5IHRoZSBib290bG9hZGVyIHRvIHRoZSBrZXJuZWwsIHdobworICAgICBwYXJzZXMgdGhlIHBv bGljeS4KKyAgMy4gVGhlcmUgaXMgYSBwb2xpY3kgZmlsZSB0aGF0IGlzIGNvbXBpbGVkIGludG8g dGhlIGtlcm5lbCB0aGF0IGlzCisgICAgIHBhcnNlZCBhbmQgZW5mb3JjZWQgb24gaW5pdGlhbGl6 YXRpb24uCisKK1RoZSBmaXJzdCBvcHRpb24gaGFzIHByb2JsZW1zOiB0aGUga2VybmVsIHJlYWRp bmcgZmlsZXMgZnJvbSB1c2Vyc3BhY2UKK2lzIHR5cGljYWxseSBkaXNjb3VyYWdlZCBhbmQgdmVy eSB1bmNvbW1vbiBpbiB0aGUga2VybmVsLgorCitUaGUgc2Vjb25kIG9wdGlvbiBhbHNvIGhhcyBw cm9ibGVtczogTGludXggc3VwcG9ydHMgYSB2YXJpZXR5IG9mIGJvb3Rsb2FkZXJzCithY3Jvc3Mg aXRzIGVudGlyZSBlY29zeXN0ZW0gLSBldmVyeSBib290bG9hZGVyIHdvdWxkIGhhdmUgdG8gc3Vw cG9ydCB0aGlzCituZXcgbWV0aG9kb2xvZ3kgb3IgdGhlcmUgbXVzdCBiZSBhbiBpbmRlcGVuZGVu dCBzb3VyY2UuIEFkZGl0aW9uYWxseSwgaXQKK3dvdWxkIGxpa2VseSByZXN1bHQgaW4gbW9yZSBk cmFzdGljIGNoYW5nZXMgdG8gdGhlIGtlcm5lbCBzdGFydHVwIHRoYW4KK25lY2Vzc2FyeS4KKwor VGhlIHRoaXJkIG9wdGlvbiBpcyB0aGUgYmVzdCBidXQgaXQncyBpbXBvcnRhbnQgdG8gYmUgYXdh cmUgdGhhdCB0aGUgcG9saWN5Cit3aWxsIHRha2UgZGlzayBzcGFjZSBhZ2FpbnN0IHRoZSBrZXJu ZWwgaXQncyBjb21waWxlZCBpbi4gSXQncyBpbXBvcnRhbnQgdG8KK2tlZXAgdGhpcyBwb2xpY3kg Z2VuZXJhbGl6ZWQgZW5vdWdoIHRoYXQgdXNlcnNwYWNlIGNhbiBsb2FkIGEgbmV3LCBtb3JlCitj b21wbGljYXRlZCBwb2xpY3ksIGJ1dCByZXN0cmljdGl2ZSBlbm91Z2ggdGhhdCBpdCB3aWxsIG5v dCBvdmVyYXV0aG9yaXplCithbmQgY2F1c2Ugc2VjdXJpdHkgaXNzdWVzLgorCitUaGUgaW5pdHJh bWZzLCBwcm92aWRlcyBhIHdheSB0aGF0IHRoaXMgYm9vdHVwIHBhdGggY2FuIGJlIGVzdGFibGlz aGVkLiBUaGUKK2tlcm5lbCBzdGFydHMgd2l0aCBhIG1pbmltYWwgcG9saWN5LCB0aGF0IGp1c3Qg dHJ1c3RzIHRoZSBpbml0cmFtZnMuIEluc2lkZQordGhlIGluaXRyYW1mcywgd2hlbiB0aGUgcmVh bCByb290ZnMgaXMgbW91bnRlZCwgYnV0IG5vdCB5ZXQgdHJhbnNmZXJyZWQgdG8sCitpdCBkZXBs b3lzIGFuZCBhY3RpdmF0ZXMgYSBwb2xpY3kgdGhhdCB0cnVzdHMgdGhlIG5ldyByb290IGZpbGVz eXN0ZW0ocykuCitUaGlzIHByZXZlbnRzIG92ZXJhdXRob3JpemF0aW9uIGF0IGFueSBzdGVwLCBh bmQga2VlcHMgdGhlIGtlcm5lbCBwb2xpY3kKK3RvIGEgbWluaW1hbCBzaXplLgorCitTdGFydHVw CiteXl5eXl5eCisKK05vdCBldmVyeSBzeXN0ZW0sIGhvd2V2ZXIgc3RhcnRzIHdpdGggYW4gaW5p dHJhbWZzLCBzbyB0aGUgc3RhcnR1cCBwb2xpY3kKK2NvbXBpbGVkIGludG8gdGhlIGtlcm5lbCB3 aWxsIG5lZWQgc29tZSBmbGV4aWJpbGl0eSB0byBleHByZXNzIGhvdyB0cnVzdAoraXMgZXN0YWJs aXNoZWQgZm9yIHRoZSBuZXh0IHBoYXNlIG9mIHRoZSBib290dXAuIFRvIHRoaXMgZW5kLCBpZiB3 ZSBqdXN0CittYWtlIHRoZSBjb21waWxlZC1pbiBwb2xpY3kgYSBmdWxsIElQRSBwb2xpY3ksIGl0 IGFsbG93cyBzeXN0ZW0gYnVpbGRlcnMKK3RvIGV4cHJlc3MgdGhlIGZpcnN0IHN0YWdlIGJvb3R1 cCByZXF1aXJlbWVudHMgYXBwcm9wcmlhdGVseS4KKworVXBkYXRhYmxlLCBSZWJvb3RsZXNzIFBv bGljeQorfn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fgorCitBcyB0aW1lIGdvZXMgb24sIHRy dXN0IHJlcXVpcmVtZW50cyBhcmUgY2hhbmdlZCAodnVsbmVyYWJpbGl0aWVzIGFyZSBmb3VuZCBp bgorcHJldmlvdXNseSB0cnVzdGVkIGFwcGxjYXRpb25zLCBrZXlzIHJvbGwsIGV0Y2V0ZXJhKS4g VXBkYXRpbmcgYSBrZXJuZWwgdG8KK2NoYW5nZSB0aGUgdHJ1c3QgcmVxdWlyZW1lbnRzIGlzIG5v dCBhbHdheXMgYSBzdWl0YWJsZSBvcHRpb24sIGFzIHVwZGF0ZXMKK2FyZSBub3QgYWx3YXlzIHJp c2stZnJlZSBhbmQgd2l0aG91dCBjb25zZXF1ZW5jZS4gVGhpcyBtZWFucyBJUEUgcmVxdWlyZXMK K2EgcG9saWN5IHRoYXQgY2FuIGJlIGNvbXBsZXRlbHkgdXBkYXRlZCBmcm9tIGEgc291cmNlIGV4 dGVybmFsIHRvIHRoZSBrZXJuZWwuCisKK0FkZGl0aW9uYWxseSwgc2luY2UgdGhlIGtlcm5lbCBp cyByZWxhdGl2ZWx5IHN0YXRlbGVzcyBiZXR3ZWVuIGludm9jYXRpb25zLAorYW5kIHdlJ3ZlIGVz dGFibGlzaGVkIHRoYXQgcmVhZGluZyBwb2xpY3kgZmlsZXMgb2ZmIHRoZSBkaXNrIGZyb20ga2Vy bmVsCitzcGFjZSBpcyBhICpiYWQgaWRlYSosIHRoZW4gdGhlIHBvbGljeSB1cGRhdGVzIGhhdmUg dG8gYmUgZG9uZSByZWJvb3RsZXNzbHkuCisKK1RvIGFsbG93IGFuIHVwZGF0ZSBmcm9tIGFuIGV4 dGVybmFsIHNvdXJjZSwgaXQgY291bGQgYmUgcG90ZW50aWFsbHkgbWFsaWNpb3VzLAorc28gdGhp cyBwb2xpY3kgbmVlZHMgdG8gaGF2ZSBhIHdheSB0byBiZSBpZGVudGlmaWVkIGFzIHRydXN0ZWQu IFRoaXMgd2lsbCBiZQorZG9uZSB2aWEgYSBzaWduYXR1cmUsIGNoYWluZWQgdG8gYSB0cnVzdCBz b3VyY2UgaW4gdGhlIGtlcm5lbC4gQXJiaXRyYXJpbHksCit0aGlzIHdpbGwgYmUgdGhlIGBgU1lT VEVNX1RSVVNURURfS0VZUklOR2BgLCBhIGtleXJpbmcgdGhhdCBpcyBpbml0aWFsbHkKK3BvcHVs YXRlZCBhdCBrZXJuZWwgY29tcGlsZS10aW1lLCBhcyB0aGlzIG1hdGNoZXMgdGhlIGV4cGVjdGF0 aW9uIHRoYXQgdGhlCithdXRob3Igb2YgdGhlIGNvbXBpbGVkLWluIHBvbGljeSBkZXNjcmliZWQg YWJvdmUgaXMgdGhlIHNhbWUgZW50aXR5IHRoYXQgY2FuCitkZXBsb3kgcG9saWN5IHVwZGF0ZXMu CisKK0FudGktUm9sbGJhY2sgLyBBbnRpLVJlcGxheQorfn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+ fn5+CisKK092ZXIgdGltZSwgdnVsbmVyYWJpbGl0aWVzIGFyZSBmb3VuZCBhbmQgdHJ1c3RlZCBy ZXNvdXJjZXMgbWF5IG5vdCBiZQordHJ1c3RlZCBhbnltb3JlLiBJUEUncyBwb2xpY3kgaGFzIG5v IGV4Y2VwdGlvbiB0byB0aGlzLiBUaGVyZSBjYW4gYmUKK2luc3RhbmNlcyB3aGVyZSBhIG1pc3Rh a2VuIHBvbGljeSBhdXRob3IgZGVwbG95cyBhbiBpbnNlY3VyZSBwb2xpY3ksCitiZWZvcmUgY29y cmVjdGluZyBpdCB3aXRoIGEgc2VjdXJlIHBvbGljeS4KKworQXNzdW1pbmcgdGhhdCBhcyBzb29u IGFzIHRoZSBpbnNlY3VyZSBwb2xpY3kgd2FzIHNpZ25lZCwgYW4gYXR0YWNrZXIKK2NhbiBhY3F1 aXJlIHRoZSBpbnNlY3VyZSBwb2xpY3ksIElQRSBuZWVkcyBhIHdheSB0byBwcmV2ZW50IHJvbGxi YWNrCitmcm9tIHRoZSBzZWN1cmUgcG9saWN5IHVwZGF0ZSwgdG8gdGhlIGluc2VjdXJlIHBvbGlj eSB1cGRhdGUuCisKK0luaXRpYWxseSwgSVBFJ3MgcG9saWN5IGNhbiBoYXZlIGEgcG9saWN5X3Zl cnNpb24gdGhhdCBzdGF0ZXMgdGhlCittaW5pbXVtIHJlcXVpcmVkIHZlcnNpb24gYWNyb3NzIGFs bCBwb2xpY2llcyB0aGF0IGNhbiBiZSBhY3RpdmUgb24KK3RoZSBzeXN0ZW0uIFRoaXMgd2lsbCBw cmV2ZW50IHJvbGxiYWNrIHdoaWxlIHRoZSBzeXN0ZW0gaXMgbGl2ZS4KKworLi4gV0FSTklORzo6 CisKKyAgSG93ZXZlciwgc2luY2UgdGhlIGtlcm5lbCBpcyBzdGF0ZWxlc3MgYWNyb3NzIGJvb3Rz LCB0aGlzIHBvbGljeQorICB2ZXJzaW9uIHdpbGwgYmUgcmVzZXQgdG8gMC4wLjAgb24gdGhlIG5l eHQgYm9vdC4gU3lzdGVtIGJ1aWxkZXJzCisgIG5lZWQgdG8gYmUgYXdhcmUgb2YgdGhpcywgYW5k IGVuc3VyZSB0aGUgbmV3IHNlY3VyZSBwb2xpY2llcyBhcmUKKyAgZGVwbG95ZWQgQVNBUCBhZnRl ciBhIGJvb3QgdG8gZW5zdXJlIHRoYXQgdGhlIHdpbmRvdyBvZgorICBvcHBvcnR1bml0eSBpcyBt aW5pbWFsIGZvciBhbiBhdHRhY2tlciB0byBkZXBsb3kgdGhlIGluc2VjdXJlIHBvbGljeVsjXV8u CisKK0ltcGxlbWVudGF0aW9uCistLS0tLS0tLS0tLS0tLQorCitDb250ZXh0Cit+fn5+fn5+CisK K0FuIGBgaXBlX2NvbnRleHRgYCBzdHJ1Y3R1cmUgcmVwcmVzZW50IGEgY29udGV4dCBpbiB3aGlj aCBJUEUgY2FuIGJlIGVuZm9yY2VkLgorSXQgY29udGFpbnMgYWxsIHRoZSB0eXBpY2FsIHZhbHVl cyB0aGF0IG9uZSB3b3VsZCBleHBlY3QgYXJlIGdsb2JhbDoKKworICAxLiBFbmZvcmNlL1Blcm1p c3NpdmUgU3RhdGUKKyAgMi4gQWN0aXZlIFBvbGljeQorICAzLiBMaXN0IG9mIFBvbGljaWVzCisg IDQuIFN1Y2Nlc3MgQXVkaXRpbmcgU3RhdGUKKworQSBjb250ZXh0IGlzIGNyZWF0ZWQgYXQgYm9v dCB0aW1lIGFuZCBhdHRhY2hlZCB0byB0aGUgYGB0YXNrX3N0cnVjdGBgIGFzIGEKK3NlY3VyaXR5 IGJsb2IuIEFsbCBuZXcgYGB0YXNrX3N0cnVjdGBgIHdpbGwgaW5oZXJpdCB0aGUgb3JpZ2luYWwg YGBpcGVfY29udGV4dGBgCit0aGF0IHRoZSBzeXN0ZW0gYm9vdHMgd2l0aC4gVGhpcyBzdHJ1Y3R1 cmUgaXMgcmVmZXJlbmNlIGNvdW50ZWQuCisKK0luaXRpYWxseSwgYSBzeXN0ZW0gd2lsbCBvbmx5 IGV2ZXIgaGF2ZSBvbmUgY29udGV4dDsgZm9yIGBgaW5pdGBgLCBhbmQgc2luY2UKK2FsbCB1c2Vy c3BhY2UgcHJvY2Vzc2VzIGFyZSBkZXNjZW5kZW50cyBvZiBgYGluaXRgYCwgYWxsIG9mIHVzZXJt b2RlIHdpbGwgaGF2ZQordGhpcyBleGVjdXRpb24gY29udGV4dC4KKworVGhpcyBhcmNoaXRlY3R1 cmUgaGFzIHNvbWUgYWR2YW50YWdlcyAtIG5hbWVseSwgaXQgYWxsb3dzIGZvciBhIG5hdHVyYWwK K2V4dGVuc2lvbiBmb3IgSVBFIHRvIGNyZWF0ZSBuZXcgY29udGV4dHMgLSBzdWNoIGFzIGFwcGx5 aW5nIGEgZGlmZmVyZW50Citwb2xpY3kgZm9yIHRydXN0IGZvciBhIHByaXZsZWRnZWQgY29udGFp bmVyIGZyb20gdGhhdCBvZiBpdHMgaG9zdC4KKworQW5vbnltb3VzIE1lbW9yeQorfn5+fn5+fn5+ fn5+fn5+fgorCitBbm9ueW1vdXMgbWVtb3J5IGlzbid0IHRyZWF0ZWQgYW55IGRpZmZlcmVudGx5 IHRoYW4gYW55IG90aGVyIGFjY2VzcyBpbiBJUEUuCitXaGVuIGFub255bW91cyBtZW1vcnkgaXMg bWFwcGVkIHdpdGggYGArWGBgLCBpdCBzdGlsbCBjb21lcyBpbnRvIHRoZSBgYGZpbGVfbW1hcGBg Citob29rLCBidXQgd2l0aCBhIGBgTlVMTGBgIGZpbGUgb2JqZWN0LiBUaGlzIGlzIHN1Ym1pdHRl ZCB0byB0aGUgZXZhbHVhdGlvbiwgbGlrZQorYW55IG90aGVyIGZpbGUsIGhvd2V2ZXIsIGFsbCB0 cnVzdCBtZWNoYW5pc21zIHdpbGwgcmV0dXJuIGZhbHNlIGFzIHRoZXJlIGlzCitub3RoaW5nIHRv IGV2YWx1YXRlLiBUaGlzIG1lYW5zIGFub255bW91cyBtZW1vcnkgZXhlY3V0aW9uIGlzIHN1Ympl Y3QgdG8KK3doYXRldmVyIHRoZSBgYERFRkFVTFRgYCBpcyBmb3IgYGBFWEVDVVRFYGAuCisKKy4u IFdBUk5JTkc6OgorCisgIFRoaXMgYWxzbyBvY2N1cnMgd2l0aCB0aGUgYGBrZXJuZWxfbG9hZF9k YXRhYGAgaG9vaywgd2hpY2ggaXMgdXNlZCBieSBzaWduZWQKKyAgYW5kIGNvbXByZXNzZWQga2Vy bmVsIG1vZHVsZXMuIFVzaW5nIHRoaXMgd2l0aCBJUEUgd2lsbCByZXN1bHQgaW4gdGhlCisgIGBg REVGQVVMVGBgIGZvciBgYEtNT0RVTEVgYCBiZWluZyB0YWtlbi4KKworUG9saWN5IFBhcnNlcgor fn5+fn5+fn5+fn5+fgorCitUaGUgcG9saWN5IHBhcnNlciBpcyB0aGUgc3RhcGxlIG9mIElQRSdz IGZ1bmN0aW9uYWxpdHksIHByb3ZpZGluZyBhCittb2R1bGFyIHdheSB0byBpbnRyb2R1Y2UgbmV3 IGludGVncmF0aW9ucy4gQXMgc3VjaCwgaXQncyBmdW5jdGlvbmFsaXR5CitpcyBkaXZpZGVkIGlu dG8gNCBwYXNzZXMuIFRoaXMgZ2l2ZXMgdGhlIGJlbmVmaXQgb2YgY2xlYXJseSBkZWZpbmVkIHBy ZQorYW5kIHBvc3QtY29uZGl0aW9uIHN0YXRlcyBhZnRlciBlYWNoIHBhc3MsIGdpdmluZyBkZWJ1 Z2dpbmcgYmVuZWZpdHMKK3doZW4gc29tZXRoaW5nIGdvZXMgd3JvbmcuCisKK0luIHBhc3MxLCB0 aGUgcG9saWN5IGlzIHRyYW5zZm9ybWVkIGludG8gYSAyRCwgamFnZ2VkLCBhcnJheSBvZiB0b2tl bnMsCit3aGVyZSBhIHRva2VuIGlzIGRlZmluZWQgYXMgYSAia2V5PXZhbHVlIiBwYWlyLCBvciBh IHNpbmd1bGFyIHRva2VuLAorZm9yIGV4YW1wbGUsICJERUZBVUxUIi4gUXVvdGVkIHZhbHVlcyBh cmUgcGFyc2VkIGFzIGEgc2luZ2xlIHZhbHVlLXBhaXIsCit3aGljaCBpcyB3aHkgYGA8bGludXgv cGFyc2VyLmg+YGAgcGFyc2VyIGlzIGluc3VmZmljaWVudCAtIGl0IGRvZXMgbm90Cit1bmRlcnN0 YW5kIHF1b3RlZCB2YWx1ZXMuCisKK0luIHBhc3MyLCB0aGUgamFnZ2VkIGFycmF5IHByb2R1Y2Vk IGluIHBhc3MxIGlzIHBhcnRpYWxseSBpbmdlc3RlZCwKK2NyZWF0aW5nIGEgcGFydGlhbGx5IHBv cHVsYXRlZCBwb2xpY3ksIHdoZXJlIG5vIHJ1bGVzIGhhdmUgYmVlbiBwYXJzZWQKK3lldCwgYnV0 IG1ldGFkYXRhIGFuZCByZWZlcmVuY2VzIGFyZSBjcmVhdGVkIHRoYXQgY2FuIGJlIG5vdyB1c2Vk IGluCitwYXNzMy4KKworRXhhbXBsZXMgb2YgcGFyc2luZyB0aGF0IHdvdWxkIGJlIGRvbmUgaW4g cGFzczI6OgorCisgIHBvbGljeV9uYW1lPSJteS1wb2xpY3kiIHBvbGljeV92ZXJzaW9uPTAuMC4w CisgIERFRkFVTFQgYWN0aW9uPURFTlkKKworQXMgdGhlc2UgbGluZXMgYXJlIG5vdCBydWxlcyBp biBvZiB0aGVtc2VsdmVzLCBidXQgZWZmZWN0IHRoZSBwb2xpY3kKK2l0c2VsZi4KKworSW4gcGFz czMsIHRoZSByZW1haW5pbmcgbGluZXMgaW4gdGhlIGphZ2dlZCBhcnJheSBwcm9kdWNlZCBpbiBw YXNzMSBhbmQKK3BhcnRpYWxseS1jb25zdW1lZCBpbiBwYXNzMiBpcyBjb25zdW1lZCBjb21wbGV0 ZWx5LCBwYXJzaW5nIGFsbCB0aGUKK3J1bGVzIGluIElQRSBwb2xpY3kuIFRoaXMgY2FuIGxldmVy YWdlIHRoZSBkYXRhIHVzZWQgaW4gcGFzczIuCitFeGFtcGxlIGxpbmVzIHBhcnNlZCBpbiBwYXNz Mzo6CisKKyAgb3A9RVhFQ1VURSBkbXZlcml0eV9zaWduYXR1cmU9VFJVRSBhY3Rpb249REVOWQor CitBIHJ1bGUgaXMgc3RyaWN0bHkgZGVmaW5lZCBhcyBzdGFydHMgd2l0aCB0aGUgb3AgdG9rZW4g YW5kIGVuZHMgd2l0aAordGhlIGFjdGlvbiB0b2tlbi4KKworQWZ0ZXIgdGhpcyBwYXNzLCBhIHBv bGljeSBpcyBkZWVtZWQgZnVsbHkgY29uc3RydWN0ZWQgYnV0IG5vdCB5ZXQgdmFsaWQsCithcyB0 aGVyZSBjb3VsZCBiZSBtaXNzaW5nIGVsZW1lbnRzIChzdWNoIGFzIGEgcmVxdWlyZWQgREVGQVVM VCBmb3IgYWxsCithY3Rpb25zLCBtaXNzaW5nIGEgcG9saWN5X25hbWUpLCBldGMuCisKK0FkZGl0 aW9uYWxseSwgYXMgSVBFIHBvbGljeSBzdXBwb3J0cyBvcGVyYXRpb24gYWxpYXNlcyAoYW4gb3Bl cmF0aW9uCit0aGF0IG1hcHMgdG8gdHdvIG9yIG1vcmUgb3RoZXIgb3BlcmF0aW9ucyksIHN1cHBv cnQgaXMgYWRkZWQgaGVyZS4KKworVGhlIHB1cnBvc2UgaW4gdGhlIGRpdmlzaW9uIG9mIHBhc3My IGFuZCBwYXNzMyBpcyB0byBhbGxvdyBmb3IKK2RlY2xhcmF0aW9ucyBpbiBJUEUncyBzeW50YXgu IEZvciBleGFtcGxlLCBpbiB0aGUgZnV0dXJlLCBpZiB3ZSB3ZXJlCit0byBpbnRyb2R1Y2UgdGhp cyBzeW50YXg6OgorCisgIENFUlRJRklDQVRFPUZha2VDZXJ0IHRodW1icHJpbnQ9REVBREJFRUYg Q049IkNvbnRvc28iCisKK0FuZCB1c2UgaXQgbGlrZSBzbzo6CisKKyAgb3A9RVhFQ1VURSBkbXZl cml0eV9zaWduYXR1cmU9RmFrZUNlcnQgYWN0aW9uPUFMTE9XCisKK1RoZSBgYENFUlRJRklDQVRF YGAgbGluZXMgY2FuIGJlIGdyb3VwZWQgdG9nZXRoZXIgYXQgYW55IHBsYWNlIGluIHRoZSBwb2xp Y3kuCisKK0FmdGVyIHBhc3MzLCBhbiBJUEUgcG9saWN5IGNhbiBzdGlsbCBiZSB0ZWNobmljYWxs eSBpbnZhbGlkIGZvciB1c2UsIGFzCithIHBvbGljeSBjYW4gYmUgbGFja2luZyByZXF1aXJlZCBl bGVtZW50cyB0byBlbGltaW5hdGVkIHRoZSBwb3NzaWJpbGl0eQorb2YgdW5kZWZpbmVkIG9yIHVu a25vd24gYmVoYXZpb3IuCisKK0EgY29uY3JldGUgZXhhbXBsZSBpcyB3aGVuIGEgcG9saWN5IGRv ZXMgbm90IGRlZmluZSBhIGRlZmF1bHQgYWN0aW9uIGZvcgorYWxsIHBvc3NpYmlsaXRpZXM6Ogor CisgIERFRkFVTFQgb3A9RVhFQ1VURSBhY3Rpb249QUxMT1cKKworQXQgdGhpcyBwb2ludCwgd2hp bGUgYSB0ZWNobmljYWxseSBzeW50YWN0aWNhbGx5IGFuZCBzZW1hbnRpY2FsbHkgdmFsaWQKK3Bv bGljeSwgaXQgZG9lcyBub3QgY29udGFpbiBlbm91Z2ggaW5mb3JtYXRpb24gdG8gZGV0ZXJtaW5l IHdoYXQgc2hvdWxkCitiZSBkb25lIGZvciBhbiBvcGVyYXRpb24gb3RoZXIgdGhhbiAiRVhFQ1VU RSIuIEFzIElQRSdzIGRlc2lnbgorZXhwbGljaXRseSBwcm9oaWJpdHMgdGhlIGltcGxpY2l0IHNl dHRpbmcgb2YgYSBERUZBVUxULCBpdCBpcyBpbXBvcnRhbnQKK2ZvciBjYXNlcyBsaWtlIHRoZXNl IGFyZSBwcmV2ZW50ZWQgZnJvbSBvY2N1cnJpbmcuCisKK1RvIHJlc29sdmUgYWxsIHRoZXNlIGNh c2VzLCBhIGZpbmFsIGNoZWNrIG9uIHRoZSBwb2xpY3kgaXMgZG9uZSB0byBlbnN1cmUKK2l0IHZh bGlkIGZvciB1c2UuCisKK0luIGFsbCBjYXNlcywgdGhlIHBhcnNlciBpcyB0aGUgbnVtYmVyIG9u ZSBib3R0bGVuZWNrIHdoZW4gaXQgY29tZXMgdG8KK0lQRSdzIHBlcmZvcm1hbmNlLCBidXQgaGFz IHRoZSBiZW5lZml0IG9mIGhhcHBlbmluZyByYXJlbHksIGFuZCBhcyBhCitkaXJlY3QgY29uc2Vx dWVuY2Ugb2YgdXNlci1pbnB1dC4KKworTW9kdWxlIHZzIFBhcnNlcgorfn5+fn5+fn5+fn5+fn5+ fgorCitBICJtb2R1bGUiLCAidHJ1c3QgcHJvdmlkZXIiLCBvciAicHJvcGVydHkiIGFzIGRlZmlu ZWQgaW4gSVBFJ3MgY29kZSBhbmQKK2NvbW1pdHMgaXMgYW4gaW50ZWdyYXRpb24gd2l0aCBhbiBl eHRlcm5hbCBzdWJzeXN0ZW0gdGhhdCBwcm92aWRlcyBhIHdheQordG8gaWRlbnRpZnkgYSByZXNv dXJjZSBhcyB0cnVzdGVkLiBJdCdzIHRoZSBjb2RlIHRoYXQgcG93ZXJzIHRoZSBrZXk9dmFsdWUK K3BhaXJzIGluIGJldHdlZW4gdGhlIGBgb3BgYCB0b2tlbiBhbmQgdGhlIGBgYWN0aW9uYGAgdG9r ZW4uIFRoZXNlIGFyZSBjYWxsZWQKK2luIHBhc3MzIHdoZW4gcGFyc2luZyBhIHBvbGljeSAodmlh IHRoZSBgYHBhcnNlYGAgbWV0aG9kKSwgYW5kIGR1cmluZworZXZhbHVhdGlvbiB3aGVuIGV2YWx1 YXRpbmcgYSBhY2Nlc3MgYXR0ZW1wdCAodmlhIHRoZSBgYGV2YWxgYCBtZXRob2QpLiBUaGVzZQor ZGlzY3JldGUgbW9kdWxlcyBhcmUgc2luZ2xlIGZpbGVzIGluIGBgc2VjdXJpdHkvaXBlL21vZHVs ZXNgYCBhbmQgYXJlCit2ZXJzaW9uZWQgaW5kZXBlbmRlbnRseS4gVGhlIGRvY3VtZW50YXRpb24g aW4gdGhlIGFkbWluIGd1aWRlIGFuZCBiZSB1c2VkCit0byBjcm9zcyByZWZlcmVuY2Ugd2hhdCB2 ZXJzaW9uIHN1cHBvcnRzIHdoYXQgc3ludGF4LgorCitBICJwYXJzZXIiLCBvbiB0aGUgb3RoZXIg aGFuZCBpcyBhIGRpc2NyZXRlIHVuaXQgb2YgY29kZSB0aGF0IGlzICpvbmx5KgordXNlZCB3aGVu IHBhcnNpbmcgYSBwb2xpY3kgaW4gcGFzczIuIFRoZSBpbnRlbnRpb24gaXMgdG8gbWFrZSBpdCBl YXN5Cit0byBpbnRyb2R1Y2Ugc3RhdGVtZW50cywgbGlrZSB0aGUgYGBERUZBVUxUYGAgc3RhdGVt ZW50OjoKKworICBERUZBVUxUIG9wPUVYRUNVVEUgYWN0aW9uPUFMTE9XCisgIERFRkFVTFQgYWN0 aW9uPUFMTE9XCisKK29yLCB0aGUgcG9saWN5IGhlYWRlcjo6CisKKyAgcG9saWN5X25hbWU9Ik15 UG9saWN5IiBwb2xpY3lfdmVyc2lvbj0wLjAuMAorCitUaGVzZSBpbmRpdmlkdWFsIGZyYWdtZW50 cyBvZiBjb2RlLCBhcyBzdWNoLCBnYWluIGFjY2VzcyB0byBtYW5pcHVsYXRpbmcKK0lQRSdzIHBv bGljeSBzdHJ1Y3R1cmUgZGlyZWN0bHksIGFzIG9wcG9zZWQgdG8gdGhlIG9wYXF1ZSBgYHZvaWQg KmBgIHRoYXQKK21vZHVsZXMgZ2V0LgorCisuLiBbI10gVGhpcyBpcyBzb21ldGhpbmcgd2UncmUg aW50ZXJlc3RlZCBpbiBzb2x2aW5nLCB1c2luZyBzb21lCisgICAgICAgcGVyc2lzdGVudCBzdG9y YWdlCisKK1Rlc3RzCit+fn5+fgorCitJUEUgaW5pdGlhbGx5IGhhcyBLVW5pdCBUZXN0cywgdGVz dGluZyBwcmltYXJpbHkgdGhlIHBhcnNlciBhbmQgdGhlIGNvbnRleHQKK3N0cnVjdHVyZXMuIEEg bWFqb3JpdHkgb2YgdGhlc2UgYXJlIHRhYmxlLWJhc2VkIHRlc3RpbmcsIHBsZWFzZSBjb250cmli dXRlCit0byB0aGVtLCBlc3BlY2lhbGx5IHdoZW4gYWRkaW5nIG5ldyBwcm9wZXJ0aWVzLgpkaWZm IC0tZ2l0IGEvTUFJTlRBSU5FUlMgYi9NQUlOVEFJTkVSUwppbmRleCBhODRjYTc4MTE5OWIuLjkw OWRiNWJhNmY4NyAxMDA2NDQKLS0tIGEvTUFJTlRBSU5FUlMKKysrIGIvTUFJTlRBSU5FUlMKQEAg LTkyODMsNiArOTI4Myw4IEBAIElOVEVHUklUWSBQT0xJQ1kgRU5GT1JDRU1FTlQgKElQRSkKIE06 CURldmVuIEJvd2VycyA8ZGV2ZW4uZGVzYWlAbGludXgubWljcm9zb2Z0LmNvbT4KIE06CUZhbiBX dSA8d3VmYW5AbGludXgubWljcm9zb2Z0LmNvbT4KIFM6CVN1cHBvcnRlZAorRjoJRG9jdW1lbnRh dGlvbi9hZG1pbi1ndWlkZS9MU00vaXBlLnJzdAorRjoJRG9jdW1lbnRhdGlvbi9zZWN1cml0eS9p cGUucnN0CiBGOglzY3JpcHRzL2lwZS8KIEY6CXNlY3VyaXR5L2lwZS8KIAotLSAKMi4zMy4wCgoK LS0KTGludXgtYXVkaXQgbWFpbGluZyBsaXN0CkxpbnV4LWF1ZGl0QHJlZGhhdC5jb20KaHR0cHM6 Ly9saXN0bWFuLnJlZGhhdC5jb20vbWFpbG1hbi9saXN0aW5mby9saW51eC1hdWRpdA==