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 vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 98886C433EF for ; Wed, 9 Mar 2022 01:11:05 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230091AbiCIBMA (ORCPT ); Tue, 8 Mar 2022 20:12:00 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44692 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229866AbiCIBLo (ORCPT ); Tue, 8 Mar 2022 20:11:44 -0500 Received: from mail-yb1-xb4a.google.com (mail-yb1-xb4a.google.com [IPv6:2607:f8b0:4864:20::b4a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 2F3AA1516B4 for ; Tue, 8 Mar 2022 16:54:09 -0800 (PST) Received: by mail-yb1-xb4a.google.com with SMTP id n66-20020a254045000000b0062883b59ddbso522961yba.12 for ; Tue, 08 Mar 2022 16:54:09 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc:content-transfer-encoding; bh=2eLf1OQ5c5M4ayVX+55KychHLqSf2s8rTUtR5N1e2O4=; b=mYotAHnmck7cPQSLQ5H1Jgup5Q0G9nVPyWtfD7SnKNQ/M1hTgghhfpZ4cCWtoxTj44 csktK1vQp32m/Bge+p2XZSFeDfN3BXrGi2ngYB4B65c8GF5Yvc7CLZrTXZ11atQzrGM5 VjENj2CN3KFi5es5T3m/Q7BW01EhOnrOo2x7oMaydXpG4LIHJd+ec5LbiaMNTwNwIvnl oMFKIdT5QiCz69GuODtpKmAewOxPROVTG3nziYa8tllTKYTT3dkOKF/7mIBANAhva48u DRpSchfdmuLJQq9gWHowdHZaMNiPSaR1K16OSkOVXkcsbYAcKUyt1NRFc+fCE0Se/+po AJAA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc:content-transfer-encoding; bh=2eLf1OQ5c5M4ayVX+55KychHLqSf2s8rTUtR5N1e2O4=; b=y4JO6FrSIc9m8pt08qOiA9EmH+Y+XNchXUuf53pgyeInO10sFfdAaUwx7CB598uz9q ZZBYC09A6SkNhLZCzfaDCL/F7gceREBNb/kSv12+M00G2LPRhm4Ts5h33Y8KDVwDYh23 BmOdhZnjw3w7GavKqqOIjignedG4CFH7BeRCBgt17YdWG3wQSolZlaFVKdIbQyPCh472 Jetw+obcnrxAEWU6nCiMtHLq61yReH8p6vLSnU2UtEomRNJJG2kNLtrNKgv6lmp2vtjY Spw7l/F4AIfJtMEbgYeqnfLnTEgB8r9yuyUAN7A4BnNIMnmydcuF4JT94pjkFUfQXXA6 2gwg== X-Gm-Message-State: AOAM53119doDXcV9QHwQXwkTZ46ACeieRoilhLBSQoVNJKqg9KAh1vnK rApoQPZ/QhiaSmMG2eqOcq2zFfSReBI= X-Google-Smtp-Source: ABdhPJy2qWRKAnebFlR4r0klAb03fdPmcYWhFD9wA2KdO3CK7iDFRKSpNcQybt31JhmXhU2fP2/5pR0E+WE= X-Received: from yuzhao.bld.corp.google.com ([2620:15c:183:200:57a6:54a6:aad1:c0a8]) (user=yuzhao job=sendgmr) by 2002:a81:1d2:0:b0:2dc:5915:661 with SMTP id 201-20020a8101d2000000b002dc59150661mr15391184ywb.154.1646783324137; Tue, 08 Mar 2022 15:48:44 -0800 (PST) Date: Tue, 8 Mar 2022 16:47:24 -0700 In-Reply-To: <20220308234723.3834941-1-yuzhao@google.com> Message-Id: <20220308234723.3834941-15-yuzhao@google.com> Mime-Version: 1.0 References: <20220308234723.3834941-1-yuzhao@google.com> X-Mailer: git-send-email 2.35.1.616.g0bdcbb4464-goog Subject: [PATCH v8 14/14] mm: multi-gen LRU: design doc From: Yu Zhao To: Andrew Morton Cc: Andi Kleen , Aneesh Kumar , Catalin Marinas , Dave Hansen , Hillf Danton , Jens Axboe , Jesse Barnes , Johannes Weiner , Jonathan Corbet , Linus Torvalds , Matthew Wilcox , Mel Gorman , Michael Larabel , Michal Hocko , Mike Rapoport , Rik van Riel , Vlastimil Babka , Will Deacon , Ying Huang , linux-arm-kernel@lists.infradead.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, page-reclaim@google.com, x86@kernel.org, Yu Zhao , Brian Geffon , Jan Alexander Steffens , Oleksandr Natalenko , Steven Barrett , Suleiman Souhlal , Daniel Byrne , Donald Carr , "=?UTF-8?q?Holger=20Hoffst=C3=A4tte?=" , Konstantin Kharlamov , Shuang Zhai , Sofia Trinh , Vaibhav Jain Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Add a design doc. Signed-off-by: Yu Zhao Acked-by: Brian Geffon Acked-by: Jan Alexander Steffens (heftig) Acked-by: Oleksandr Natalenko Acked-by: Steven Barrett Acked-by: Suleiman Souhlal Tested-by: Daniel Byrne Tested-by: Donald Carr Tested-by: Holger Hoffst=C3=A4tte Tested-by: Konstantin Kharlamov Tested-by: Shuang Zhai Tested-by: Sofia Trinh Tested-by: Vaibhav Jain --- Documentation/vm/index.rst | 1 + Documentation/vm/multigen_lru.rst | 156 ++++++++++++++++++++++++++++++ 2 files changed, 157 insertions(+) create mode 100644 Documentation/vm/multigen_lru.rst diff --git a/Documentation/vm/index.rst b/Documentation/vm/index.rst index 44365c4574a3..b48434300226 100644 --- a/Documentation/vm/index.rst +++ b/Documentation/vm/index.rst @@ -25,6 +25,7 @@ algorithms. If you are looking for advice on simply allo= cating memory, see the ksm memory-model mmu_notifier + multigen_lru numa overcommit-accounting page_migration diff --git a/Documentation/vm/multigen_lru.rst b/Documentation/vm/multigen_= lru.rst new file mode 100644 index 000000000000..cde60de16621 --- /dev/null +++ b/Documentation/vm/multigen_lru.rst @@ -0,0 +1,156 @@ +.. SPDX-License-Identifier: GPL-2.0 + +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D +Multi-Gen LRU +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + +Design overview +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D +Objectives +---------- +The design objectives are: + +* Good representation of access recency +* Try to profit from spatial locality +* Fast paths to make obvious choices +* Simple self-correcting heuristics + +The representation of access recency is at the core of all LRU +implementations. In the multi-gen LRU, each generation represents a +group of pages with similar access recency. Generations establish a +common frame of reference and therefore help make better choices, +e.g., between different memcgs on a computer or different computers in +a data center (for job scheduling). + +Exploiting spatial locality improves efficiency when gathering the +accessed bit. A rmap walk targets a single page and does not try to +profit from discovering a young PTE. A page table walk can sweep all +the young PTEs in an address space, but the address space can be too +large to make a profit. The key is to optimize both methods and use +them in combination. + +Fast paths reduce code complexity and runtime overhead. Unmapped pages +do not require TLB flushes; clean pages do not require writeback. +These facts are only helpful when other conditions, e.g., access +recency, are similar. With generations as a common frame of reference, +additional factors stand out. But obvious choices might not be good +choices; thus self-correction is required. + +The benefits of simple self-correcting heuristics are self-evident. +Again, with generations as a common frame of reference, this becomes +attainable. Specifically, pages in the same generation can be +categorized based on additional factors, and a feedback loop can +statistically compare the refault percentages across those categories +and infer which of them are better choices. + +Assumptions +----------- +The protection of hot pages and the selection of cold pages are based +on page access channels and patterns. There are two access channels: + +* Accesses through page tables +* Accesses through file descriptors + +The protection of the former channel is by design stronger because: + +1. The uncertainty in determining the access patterns of the former + channel is higher due to the approximation of the accessed bit. +2. The cost of evicting the former channel is higher due to the TLB + flushes required and the likelihood of encountering the dirty bit. +3. The penalty of underprotecting the former channel is higher because + applications usually do not prepare themselves for major page + faults like they do for blocked I/O. E.g., GUI applications + commonly use dedicated I/O threads to avoid blocking the rendering + threads. + +There are also two access patterns: + +* Accesses exhibiting temporal locality +* Accesses not exhibiting temporal locality + +For the reasons listed above, the former channel is assumed to follow +the former pattern unless ``VM_SEQ_READ`` or ``VM_RAND_READ`` is +present, and the latter channel is assumed to follow the latter +pattern unless outlying refaults have been observed. + +Workflow overview +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D +Evictable pages are divided into multiple generations for each +``lruvec``. The youngest generation number is stored in +``lrugen->max_seq`` for both anon and file types as they are aged on +an equal footing. The oldest generation numbers are stored in +``lrugen->min_seq[]`` separately for anon and file types as clean file +pages can be evicted regardless of swap constraints. These three +variables are monotonically increasing. + +Generation numbers are truncated into ``order_base_2(MAX_NR_GENS+1)`` +bits in order to fit into the gen counter in ``folio->flags``. Each +truncated generation number is an index to ``lrugen->lists[]``. The +sliding window technique is used to track at least ``MIN_NR_GENS`` and +at most ``MAX_NR_GENS`` generations. The gen counter stores a value +within ``[1, MAX_NR_GENS]`` while a page is on one of +``lrugen->lists[]``; otherwise it stores zero. + +Each generation is divided into multiple tiers. Tiers represent +different ranges of numbers of accesses through file descriptors. A +page accessed ``N`` times through file descriptors is in tier +``order_base_2(N)``. In contrast to moving across generations, which +requires the LRU lock, moving across tiers only requires operations on +``folio->flags`` and therefore has a negligible cost. A feedback loop +modeled after the PID controller monitors refaults over all the tiers +from anon and file types and decides which tiers from which types to +evict or protect. + +There are two conceptually independent procedures: the aging and the +eviction. They form a closed-loop system, i.e., the page reclaim. + +Aging +----- +The aging produces young generations. Given an ``lruvec``, it +increments ``max_seq`` when ``max_seq-min_seq+1`` approaches +``MIN_NR_GENS``. The aging promotes hot pages to the youngest +generation when it finds them accessed through page tables; the +demotion of cold pages happens consequently when it increments +``max_seq``. The aging uses page table walks and rmap walks to find +young PTEs. For the former, it iterates ``lruvec_memcg()->mm_list`` +and calls ``walk_page_range()`` with each ``mm_struct`` on this list +to scan PTEs. On finding a young PTE, it clears the accessed bit and +updates the gen counter of the page mapped by this PTE to +``(max_seq%MAX_NR_GENS)+1``. After each iteration of this list, it +increments ``max_seq``. For the latter, when the eviction walks the +rmap and finds a young PTE, the aging scans the adjacent PTEs and +follows the same steps just described. + +Eviction +-------- +The eviction consumes old generations. Given an ``lruvec``, it +increments ``min_seq`` when ``lrugen->lists[]`` indexed by +``min_seq%MAX_NR_GENS`` becomes empty. To select a type and a tier to +evict from, it first compares ``min_seq[]`` to select the older type. +If both types are equally old, it selects the one whose first tier has +a lower refault percentage. The first tier contains single-use +unmapped clean pages, which are the best bet. The eviction sorts a +page according to the gen counter if the aging has found this page +accessed through page tables and updated the gen counter. It also +moves a page to the next generation, i.e., ``min_seq+1``, if this page +was accessed multiple times through file descriptors and the feedback +loop has detected outlying refaults from the tier this page is in. To +do this, the feedback loop uses the first tier as the baseline, for +the reason stated earlier. + +Summary +------- +The multi-gen LRU can be disassembled into the following parts: + +* Generations +* Page table walks +* Rmap walks +* Bloom filters +* The PID controller + +The aging and the eviction is a producer-consumer model; specifically, +the latter drives the former by the sliding window over generations. +Within the aging, rmap walks drive page table walks by inserting hot +densely populated page tables to the Bloom filters. Within the +eviction, the PID controller uses refaults as the feedback to select +types to evict and tiers to protect. --=20 2.35.1.616.g0bdcbb4464-goog 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 bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 4D22EC433EF for ; Tue, 8 Mar 2022 23:57:34 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:Cc:To:From:Subject:References: Mime-Version:Message-Id:In-Reply-To:Date:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=1gPc3mt0I+0qBodMtVoc1e7V/+rKmYck3LaeQRbJcS4=; b=jBMn4c/lYiVYsr7ismhXTZfLkb iHS57Upd6PhGH+aaTLTjOC6pxW5LjPBZgKqAe2ubSsjFvyCAre/5Yflrw5xdTx0NZbDQKR4OmT/w+ Bj3ecDFF5jivJhDicmyw0l34kN0JmsDYPjiNOQQagbP/ecgdpUZXquZbyPEalWl6do5kHWHCpxf/l 0oDzrOCUdtFe6klZAnUfd0iDsIHuy3GASfMGIEzeQXUiIaA6VMrK3JLHRa+WWB4+7ArHiSVxATBv2 EBvESJcgr/h549BsCImpzEwejkWbsnhO/KZTgcyGDEMvNzNLqptzBfGWKFTLYGAf32RFi+S7ByGRn RAa4hp1g==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nRjgL-006dDx-J4; Tue, 08 Mar 2022 23:55:58 +0000 Received: from mail-yw1-x1149.google.com ([2607:f8b0:4864:20::1149]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1nRjZN-006aSx-Sq for linux-arm-kernel@lists.infradead.org; Tue, 08 Mar 2022 23:48:59 +0000 Received: by mail-yw1-x1149.google.com with SMTP id 00721157ae682-2d61f6c1877so3614257b3.15 for ; Tue, 08 Mar 2022 15:48:44 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc:content-transfer-encoding; bh=2eLf1OQ5c5M4ayVX+55KychHLqSf2s8rTUtR5N1e2O4=; b=mYotAHnmck7cPQSLQ5H1Jgup5Q0G9nVPyWtfD7SnKNQ/M1hTgghhfpZ4cCWtoxTj44 csktK1vQp32m/Bge+p2XZSFeDfN3BXrGi2ngYB4B65c8GF5Yvc7CLZrTXZ11atQzrGM5 VjENj2CN3KFi5es5T3m/Q7BW01EhOnrOo2x7oMaydXpG4LIHJd+ec5LbiaMNTwNwIvnl oMFKIdT5QiCz69GuODtpKmAewOxPROVTG3nziYa8tllTKYTT3dkOKF/7mIBANAhva48u DRpSchfdmuLJQq9gWHowdHZaMNiPSaR1K16OSkOVXkcsbYAcKUyt1NRFc+fCE0Se/+po AJAA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc:content-transfer-encoding; bh=2eLf1OQ5c5M4ayVX+55KychHLqSf2s8rTUtR5N1e2O4=; b=ADQKu2933eSZugXxecDxcj9JDKdk3zk1P/YkMeBa4HpxMsibAK3Qi7EnPUi80cXWrz k5vk7Yq/Dd9O2KR4AgLOTvi4Mx526wYD/w0x4aT61U6+wtzRHELimD+9BPHgQE8rbSoI SjbRZ+hmdSHrK3U91abdKyuHxdAHl78178LYx7TVTZSNQ9tKX+TYHeAi2TAKUK3hDHgr p19kooZv+I102C8y8N3UWyEFHVUCfPvhKLwRGaOuI04Pbzt6DGm/APd9soUppNabA+oV tL/LGMHoJY3886+VAQSVIzIJaYZLVUJpOAtmEq96fs3jDn4+LW3fzZpLUuqVAv2qle4V AZ6Q== X-Gm-Message-State: AOAM530p9L0gBHyFYRrcs5M8jVKuLxuzHoW7bJledkT3lLxRsFArk5Ve iCugdgCgYslhFllWz2qqFJD1CO/jB+8= X-Google-Smtp-Source: ABdhPJy2qWRKAnebFlR4r0klAb03fdPmcYWhFD9wA2KdO3CK7iDFRKSpNcQybt31JhmXhU2fP2/5pR0E+WE= X-Received: from yuzhao.bld.corp.google.com ([2620:15c:183:200:57a6:54a6:aad1:c0a8]) (user=yuzhao job=sendgmr) by 2002:a81:1d2:0:b0:2dc:5915:661 with SMTP id 201-20020a8101d2000000b002dc59150661mr15391184ywb.154.1646783324137; Tue, 08 Mar 2022 15:48:44 -0800 (PST) Date: Tue, 8 Mar 2022 16:47:24 -0700 In-Reply-To: <20220308234723.3834941-1-yuzhao@google.com> Message-Id: <20220308234723.3834941-15-yuzhao@google.com> Mime-Version: 1.0 References: <20220308234723.3834941-1-yuzhao@google.com> X-Mailer: git-send-email 2.35.1.616.g0bdcbb4464-goog Subject: [PATCH v8 14/14] mm: multi-gen LRU: design doc From: Yu Zhao To: Andrew Morton Cc: Andi Kleen , Aneesh Kumar , Catalin Marinas , Dave Hansen , Hillf Danton , Jens Axboe , Jesse Barnes , Johannes Weiner , Jonathan Corbet , Linus Torvalds , Matthew Wilcox , Mel Gorman , Michael Larabel , Michal Hocko , Mike Rapoport , Rik van Riel , Vlastimil Babka , Will Deacon , Ying Huang , linux-arm-kernel@lists.infradead.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, page-reclaim@google.com, x86@kernel.org, Yu Zhao , Brian Geffon , Jan Alexander Steffens , Oleksandr Natalenko , Steven Barrett , Suleiman Souhlal , Daniel Byrne , Donald Carr , "=?UTF-8?q?Holger=20Hoffst=C3=A4tte?=" , Konstantin Kharlamov , Shuang Zhai , Sofia Trinh , Vaibhav Jain X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220308_154845_983149_DAFE1C3F X-CRM114-Status: GOOD ( 23.68 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org QWRkIGEgZGVzaWduIGRvYy4KClNpZ25lZC1vZmYtYnk6IFl1IFpoYW8gPHl1emhhb0Bnb29nbGUu Y29tPgpBY2tlZC1ieTogQnJpYW4gR2VmZm9uIDxiZ2VmZm9uQGdvb2dsZS5jb20+CkFja2VkLWJ5 OiBKYW4gQWxleGFuZGVyIFN0ZWZmZW5zIChoZWZ0aWcpIDxoZWZ0aWdAYXJjaGxpbnV4Lm9yZz4K QWNrZWQtYnk6IE9sZWtzYW5kciBOYXRhbGVua28gPG9sZWtzYW5kckBuYXRhbGVua28ubmFtZT4K QWNrZWQtYnk6IFN0ZXZlbiBCYXJyZXR0IDxzdGV2ZW5AbGlxdW9yaXgubmV0PgpBY2tlZC1ieTog U3VsZWltYW4gU291aGxhbCA8c3VsZWltYW5AZ29vZ2xlLmNvbT4KVGVzdGVkLWJ5OiBEYW5pZWwg QnlybmUgPGRqYnlybmVAbXR1LmVkdT4KVGVzdGVkLWJ5OiBEb25hbGQgQ2FyciA8ZEBjaGFvcy1y ZWlucy5jb20+ClRlc3RlZC1ieTogSG9sZ2VyIEhvZmZzdMOkdHRlIDxob2xnZXJAYXBwbGllZC1h c3luY2hyb255LmNvbT4KVGVzdGVkLWJ5OiBLb25zdGFudGluIEtoYXJsYW1vdiA8SGktQW5nZWxA eWFuZGV4LnJ1PgpUZXN0ZWQtYnk6IFNodWFuZyBaaGFpIDxzemhhaTJAY3Mucm9jaGVzdGVyLmVk dT4KVGVzdGVkLWJ5OiBTb2ZpYSBUcmluaCA8c29maWEudHJpbmhAZWRpLndvcmtzPgpUZXN0ZWQt Ynk6IFZhaWJoYXYgSmFpbiA8dmFpYmhhdkBsaW51eC5pYm0uY29tPgotLS0KIERvY3VtZW50YXRp b24vdm0vaW5kZXgucnN0ICAgICAgICB8ICAgMSArCiBEb2N1bWVudGF0aW9uL3ZtL211bHRpZ2Vu X2xydS5yc3QgfCAxNTYgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiAyIGZpbGVzIGNo YW5nZWQsIDE1NyBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgRG9jdW1lbnRhdGlv bi92bS9tdWx0aWdlbl9scnUucnN0CgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi92bS9pbmRl eC5yc3QgYi9Eb2N1bWVudGF0aW9uL3ZtL2luZGV4LnJzdAppbmRleCA0NDM2NWM0NTc0YTMuLmI0 ODQzNDMwMDIyNiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi92bS9pbmRleC5yc3QKKysrIGIv RG9jdW1lbnRhdGlvbi92bS9pbmRleC5yc3QKQEAgLTI1LDYgKzI1LDcgQEAgYWxnb3JpdGhtcy4g IElmIHlvdSBhcmUgbG9va2luZyBmb3IgYWR2aWNlIG9uIHNpbXBseSBhbGxvY2F0aW5nIG1lbW9y eSwgc2VlIHRoZQogICAga3NtCiAgICBtZW1vcnktbW9kZWwKICAgIG1tdV9ub3RpZmllcgorICAg bXVsdGlnZW5fbHJ1CiAgICBudW1hCiAgICBvdmVyY29tbWl0LWFjY291bnRpbmcKICAgIHBhZ2Vf bWlncmF0aW9uCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3ZtL211bHRpZ2VuX2xydS5yc3Qg Yi9Eb2N1bWVudGF0aW9uL3ZtL211bHRpZ2VuX2xydS5yc3QKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwLi5jZGU2MGRlMTY2MjEKLS0tIC9kZXYvbnVsbAorKysgYi9Eb2N1 bWVudGF0aW9uL3ZtL211bHRpZ2VuX2xydS5yc3QKQEAgLTAsMCArMSwxNTYgQEAKKy4uIFNQRFgt TGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCisKKz09PT09PT09PT09PT0KK011bHRpLUdlbiBM UlUKKz09PT09PT09PT09PT0KKworRGVzaWduIG92ZXJ2aWV3Cis9PT09PT09PT09PT09PT0KK09i amVjdGl2ZXMKKy0tLS0tLS0tLS0KK1RoZSBkZXNpZ24gb2JqZWN0aXZlcyBhcmU6CisKKyogR29v ZCByZXByZXNlbnRhdGlvbiBvZiBhY2Nlc3MgcmVjZW5jeQorKiBUcnkgdG8gcHJvZml0IGZyb20g c3BhdGlhbCBsb2NhbGl0eQorKiBGYXN0IHBhdGhzIHRvIG1ha2Ugb2J2aW91cyBjaG9pY2VzCisq IFNpbXBsZSBzZWxmLWNvcnJlY3RpbmcgaGV1cmlzdGljcworCitUaGUgcmVwcmVzZW50YXRpb24g b2YgYWNjZXNzIHJlY2VuY3kgaXMgYXQgdGhlIGNvcmUgb2YgYWxsIExSVQoraW1wbGVtZW50YXRp b25zLiBJbiB0aGUgbXVsdGktZ2VuIExSVSwgZWFjaCBnZW5lcmF0aW9uIHJlcHJlc2VudHMgYQor Z3JvdXAgb2YgcGFnZXMgd2l0aCBzaW1pbGFyIGFjY2VzcyByZWNlbmN5LiBHZW5lcmF0aW9ucyBl c3RhYmxpc2ggYQorY29tbW9uIGZyYW1lIG9mIHJlZmVyZW5jZSBhbmQgdGhlcmVmb3JlIGhlbHAg bWFrZSBiZXR0ZXIgY2hvaWNlcywKK2UuZy4sIGJldHdlZW4gZGlmZmVyZW50IG1lbWNncyBvbiBh IGNvbXB1dGVyIG9yIGRpZmZlcmVudCBjb21wdXRlcnMgaW4KK2EgZGF0YSBjZW50ZXIgKGZvciBq b2Igc2NoZWR1bGluZykuCisKK0V4cGxvaXRpbmcgc3BhdGlhbCBsb2NhbGl0eSBpbXByb3ZlcyBl ZmZpY2llbmN5IHdoZW4gZ2F0aGVyaW5nIHRoZQorYWNjZXNzZWQgYml0LiBBIHJtYXAgd2FsayB0 YXJnZXRzIGEgc2luZ2xlIHBhZ2UgYW5kIGRvZXMgbm90IHRyeSB0bworcHJvZml0IGZyb20gZGlz Y292ZXJpbmcgYSB5b3VuZyBQVEUuIEEgcGFnZSB0YWJsZSB3YWxrIGNhbiBzd2VlcCBhbGwKK3Ro ZSB5b3VuZyBQVEVzIGluIGFuIGFkZHJlc3Mgc3BhY2UsIGJ1dCB0aGUgYWRkcmVzcyBzcGFjZSBj YW4gYmUgdG9vCitsYXJnZSB0byBtYWtlIGEgcHJvZml0LiBUaGUga2V5IGlzIHRvIG9wdGltaXpl IGJvdGggbWV0aG9kcyBhbmQgdXNlCit0aGVtIGluIGNvbWJpbmF0aW9uLgorCitGYXN0IHBhdGhz IHJlZHVjZSBjb2RlIGNvbXBsZXhpdHkgYW5kIHJ1bnRpbWUgb3ZlcmhlYWQuIFVubWFwcGVkIHBh Z2VzCitkbyBub3QgcmVxdWlyZSBUTEIgZmx1c2hlczsgY2xlYW4gcGFnZXMgZG8gbm90IHJlcXVp cmUgd3JpdGViYWNrLgorVGhlc2UgZmFjdHMgYXJlIG9ubHkgaGVscGZ1bCB3aGVuIG90aGVyIGNv bmRpdGlvbnMsIGUuZy4sIGFjY2VzcworcmVjZW5jeSwgYXJlIHNpbWlsYXIuIFdpdGggZ2VuZXJh dGlvbnMgYXMgYSBjb21tb24gZnJhbWUgb2YgcmVmZXJlbmNlLAorYWRkaXRpb25hbCBmYWN0b3Jz IHN0YW5kIG91dC4gQnV0IG9idmlvdXMgY2hvaWNlcyBtaWdodCBub3QgYmUgZ29vZAorY2hvaWNl czsgdGh1cyBzZWxmLWNvcnJlY3Rpb24gaXMgcmVxdWlyZWQuCisKK1RoZSBiZW5lZml0cyBvZiBz aW1wbGUgc2VsZi1jb3JyZWN0aW5nIGhldXJpc3RpY3MgYXJlIHNlbGYtZXZpZGVudC4KK0FnYWlu LCB3aXRoIGdlbmVyYXRpb25zIGFzIGEgY29tbW9uIGZyYW1lIG9mIHJlZmVyZW5jZSwgdGhpcyBi ZWNvbWVzCithdHRhaW5hYmxlLiBTcGVjaWZpY2FsbHksIHBhZ2VzIGluIHRoZSBzYW1lIGdlbmVy YXRpb24gY2FuIGJlCitjYXRlZ29yaXplZCBiYXNlZCBvbiBhZGRpdGlvbmFsIGZhY3RvcnMsIGFu ZCBhIGZlZWRiYWNrIGxvb3AgY2FuCitzdGF0aXN0aWNhbGx5IGNvbXBhcmUgdGhlIHJlZmF1bHQg cGVyY2VudGFnZXMgYWNyb3NzIHRob3NlIGNhdGVnb3JpZXMKK2FuZCBpbmZlciB3aGljaCBvZiB0 aGVtIGFyZSBiZXR0ZXIgY2hvaWNlcy4KKworQXNzdW1wdGlvbnMKKy0tLS0tLS0tLS0tCitUaGUg cHJvdGVjdGlvbiBvZiBob3QgcGFnZXMgYW5kIHRoZSBzZWxlY3Rpb24gb2YgY29sZCBwYWdlcyBh cmUgYmFzZWQKK29uIHBhZ2UgYWNjZXNzIGNoYW5uZWxzIGFuZCBwYXR0ZXJucy4gVGhlcmUgYXJl IHR3byBhY2Nlc3MgY2hhbm5lbHM6CisKKyogQWNjZXNzZXMgdGhyb3VnaCBwYWdlIHRhYmxlcwor KiBBY2Nlc3NlcyB0aHJvdWdoIGZpbGUgZGVzY3JpcHRvcnMKKworVGhlIHByb3RlY3Rpb24gb2Yg dGhlIGZvcm1lciBjaGFubmVsIGlzIGJ5IGRlc2lnbiBzdHJvbmdlciBiZWNhdXNlOgorCisxLiBU aGUgdW5jZXJ0YWludHkgaW4gZGV0ZXJtaW5pbmcgdGhlIGFjY2VzcyBwYXR0ZXJucyBvZiB0aGUg Zm9ybWVyCisgICBjaGFubmVsIGlzIGhpZ2hlciBkdWUgdG8gdGhlIGFwcHJveGltYXRpb24gb2Yg dGhlIGFjY2Vzc2VkIGJpdC4KKzIuIFRoZSBjb3N0IG9mIGV2aWN0aW5nIHRoZSBmb3JtZXIgY2hh bm5lbCBpcyBoaWdoZXIgZHVlIHRvIHRoZSBUTEIKKyAgIGZsdXNoZXMgcmVxdWlyZWQgYW5kIHRo ZSBsaWtlbGlob29kIG9mIGVuY291bnRlcmluZyB0aGUgZGlydHkgYml0LgorMy4gVGhlIHBlbmFs dHkgb2YgdW5kZXJwcm90ZWN0aW5nIHRoZSBmb3JtZXIgY2hhbm5lbCBpcyBoaWdoZXIgYmVjYXVz ZQorICAgYXBwbGljYXRpb25zIHVzdWFsbHkgZG8gbm90IHByZXBhcmUgdGhlbXNlbHZlcyBmb3Ig bWFqb3IgcGFnZQorICAgZmF1bHRzIGxpa2UgdGhleSBkbyBmb3IgYmxvY2tlZCBJL08uIEUuZy4s IEdVSSBhcHBsaWNhdGlvbnMKKyAgIGNvbW1vbmx5IHVzZSBkZWRpY2F0ZWQgSS9PIHRocmVhZHMg dG8gYXZvaWQgYmxvY2tpbmcgdGhlIHJlbmRlcmluZworICAgdGhyZWFkcy4KKworVGhlcmUgYXJl IGFsc28gdHdvIGFjY2VzcyBwYXR0ZXJuczoKKworKiBBY2Nlc3NlcyBleGhpYml0aW5nIHRlbXBv cmFsIGxvY2FsaXR5CisqIEFjY2Vzc2VzIG5vdCBleGhpYml0aW5nIHRlbXBvcmFsIGxvY2FsaXR5 CisKK0ZvciB0aGUgcmVhc29ucyBsaXN0ZWQgYWJvdmUsIHRoZSBmb3JtZXIgY2hhbm5lbCBpcyBh c3N1bWVkIHRvIGZvbGxvdwordGhlIGZvcm1lciBwYXR0ZXJuIHVubGVzcyBgYFZNX1NFUV9SRUFE YGAgb3IgYGBWTV9SQU5EX1JFQURgYCBpcworcHJlc2VudCwgYW5kIHRoZSBsYXR0ZXIgY2hhbm5l bCBpcyBhc3N1bWVkIHRvIGZvbGxvdyB0aGUgbGF0dGVyCitwYXR0ZXJuIHVubGVzcyBvdXRseWlu ZyByZWZhdWx0cyBoYXZlIGJlZW4gb2JzZXJ2ZWQuCisKK1dvcmtmbG93IG92ZXJ2aWV3Cis9PT09 PT09PT09PT09PT09PQorRXZpY3RhYmxlIHBhZ2VzIGFyZSBkaXZpZGVkIGludG8gbXVsdGlwbGUg Z2VuZXJhdGlvbnMgZm9yIGVhY2gKK2BgbHJ1dmVjYGAuIFRoZSB5b3VuZ2VzdCBnZW5lcmF0aW9u IG51bWJlciBpcyBzdG9yZWQgaW4KK2BgbHJ1Z2VuLT5tYXhfc2VxYGAgZm9yIGJvdGggYW5vbiBh bmQgZmlsZSB0eXBlcyBhcyB0aGV5IGFyZSBhZ2VkIG9uCithbiBlcXVhbCBmb290aW5nLiBUaGUg b2xkZXN0IGdlbmVyYXRpb24gbnVtYmVycyBhcmUgc3RvcmVkIGluCitgYGxydWdlbi0+bWluX3Nl cVtdYGAgc2VwYXJhdGVseSBmb3IgYW5vbiBhbmQgZmlsZSB0eXBlcyBhcyBjbGVhbiBmaWxlCitw YWdlcyBjYW4gYmUgZXZpY3RlZCByZWdhcmRsZXNzIG9mIHN3YXAgY29uc3RyYWludHMuIFRoZXNl IHRocmVlCit2YXJpYWJsZXMgYXJlIG1vbm90b25pY2FsbHkgaW5jcmVhc2luZy4KKworR2VuZXJh dGlvbiBudW1iZXJzIGFyZSB0cnVuY2F0ZWQgaW50byBgYG9yZGVyX2Jhc2VfMihNQVhfTlJfR0VO UysxKWBgCitiaXRzIGluIG9yZGVyIHRvIGZpdCBpbnRvIHRoZSBnZW4gY291bnRlciBpbiBgYGZv bGlvLT5mbGFnc2BgLiBFYWNoCit0cnVuY2F0ZWQgZ2VuZXJhdGlvbiBudW1iZXIgaXMgYW4gaW5k ZXggdG8gYGBscnVnZW4tPmxpc3RzW11gYC4gVGhlCitzbGlkaW5nIHdpbmRvdyB0ZWNobmlxdWUg aXMgdXNlZCB0byB0cmFjayBhdCBsZWFzdCBgYE1JTl9OUl9HRU5TYGAgYW5kCithdCBtb3N0IGBg TUFYX05SX0dFTlNgYCBnZW5lcmF0aW9ucy4gVGhlIGdlbiBjb3VudGVyIHN0b3JlcyBhIHZhbHVl Cit3aXRoaW4gYGBbMSwgTUFYX05SX0dFTlNdYGAgd2hpbGUgYSBwYWdlIGlzIG9uIG9uZSBvZgor YGBscnVnZW4tPmxpc3RzW11gYDsgb3RoZXJ3aXNlIGl0IHN0b3JlcyB6ZXJvLgorCitFYWNoIGdl bmVyYXRpb24gaXMgZGl2aWRlZCBpbnRvIG11bHRpcGxlIHRpZXJzLiBUaWVycyByZXByZXNlbnQK K2RpZmZlcmVudCByYW5nZXMgb2YgbnVtYmVycyBvZiBhY2Nlc3NlcyB0aHJvdWdoIGZpbGUgZGVz Y3JpcHRvcnMuIEEKK3BhZ2UgYWNjZXNzZWQgYGBOYGAgdGltZXMgdGhyb3VnaCBmaWxlIGRlc2Ny aXB0b3JzIGlzIGluIHRpZXIKK2Bgb3JkZXJfYmFzZV8yKE4pYGAuIEluIGNvbnRyYXN0IHRvIG1v dmluZyBhY3Jvc3MgZ2VuZXJhdGlvbnMsIHdoaWNoCityZXF1aXJlcyB0aGUgTFJVIGxvY2ssIG1v dmluZyBhY3Jvc3MgdGllcnMgb25seSByZXF1aXJlcyBvcGVyYXRpb25zIG9uCitgYGZvbGlvLT5m bGFnc2BgIGFuZCB0aGVyZWZvcmUgaGFzIGEgbmVnbGlnaWJsZSBjb3N0LiBBIGZlZWRiYWNrIGxv b3AKK21vZGVsZWQgYWZ0ZXIgdGhlIFBJRCBjb250cm9sbGVyIG1vbml0b3JzIHJlZmF1bHRzIG92 ZXIgYWxsIHRoZSB0aWVycworZnJvbSBhbm9uIGFuZCBmaWxlIHR5cGVzIGFuZCBkZWNpZGVzIHdo aWNoIHRpZXJzIGZyb20gd2hpY2ggdHlwZXMgdG8KK2V2aWN0IG9yIHByb3RlY3QuCisKK1RoZXJl IGFyZSB0d28gY29uY2VwdHVhbGx5IGluZGVwZW5kZW50IHByb2NlZHVyZXM6IHRoZSBhZ2luZyBh bmQgdGhlCitldmljdGlvbi4gVGhleSBmb3JtIGEgY2xvc2VkLWxvb3Agc3lzdGVtLCBpLmUuLCB0 aGUgcGFnZSByZWNsYWltLgorCitBZ2luZworLS0tLS0KK1RoZSBhZ2luZyBwcm9kdWNlcyB5b3Vu ZyBnZW5lcmF0aW9ucy4gR2l2ZW4gYW4gYGBscnV2ZWNgYCwgaXQKK2luY3JlbWVudHMgYGBtYXhf c2VxYGAgd2hlbiBgYG1heF9zZXEtbWluX3NlcSsxYGAgYXBwcm9hY2hlcworYGBNSU5fTlJfR0VO U2BgLiBUaGUgYWdpbmcgcHJvbW90ZXMgaG90IHBhZ2VzIHRvIHRoZSB5b3VuZ2VzdAorZ2VuZXJh dGlvbiB3aGVuIGl0IGZpbmRzIHRoZW0gYWNjZXNzZWQgdGhyb3VnaCBwYWdlIHRhYmxlczsgdGhl CitkZW1vdGlvbiBvZiBjb2xkIHBhZ2VzIGhhcHBlbnMgY29uc2VxdWVudGx5IHdoZW4gaXQgaW5j cmVtZW50cworYGBtYXhfc2VxYGAuIFRoZSBhZ2luZyB1c2VzIHBhZ2UgdGFibGUgd2Fsa3MgYW5k IHJtYXAgd2Fsa3MgdG8gZmluZAoreW91bmcgUFRFcy4gRm9yIHRoZSBmb3JtZXIsIGl0IGl0ZXJh dGVzIGBgbHJ1dmVjX21lbWNnKCktPm1tX2xpc3RgYAorYW5kIGNhbGxzIGBgd2Fsa19wYWdlX3Jh bmdlKClgYCB3aXRoIGVhY2ggYGBtbV9zdHJ1Y3RgYCBvbiB0aGlzIGxpc3QKK3RvIHNjYW4gUFRF cy4gT24gZmluZGluZyBhIHlvdW5nIFBURSwgaXQgY2xlYXJzIHRoZSBhY2Nlc3NlZCBiaXQgYW5k Cit1cGRhdGVzIHRoZSBnZW4gY291bnRlciBvZiB0aGUgcGFnZSBtYXBwZWQgYnkgdGhpcyBQVEUg dG8KK2BgKG1heF9zZXElTUFYX05SX0dFTlMpKzFgYC4gQWZ0ZXIgZWFjaCBpdGVyYXRpb24gb2Yg dGhpcyBsaXN0LCBpdAoraW5jcmVtZW50cyBgYG1heF9zZXFgYC4gRm9yIHRoZSBsYXR0ZXIsIHdo ZW4gdGhlIGV2aWN0aW9uIHdhbGtzIHRoZQorcm1hcCBhbmQgZmluZHMgYSB5b3VuZyBQVEUsIHRo ZSBhZ2luZyBzY2FucyB0aGUgYWRqYWNlbnQgUFRFcyBhbmQKK2ZvbGxvd3MgdGhlIHNhbWUgc3Rl cHMganVzdCBkZXNjcmliZWQuCisKK0V2aWN0aW9uCistLS0tLS0tLQorVGhlIGV2aWN0aW9uIGNv bnN1bWVzIG9sZCBnZW5lcmF0aW9ucy4gR2l2ZW4gYW4gYGBscnV2ZWNgYCwgaXQKK2luY3JlbWVu dHMgYGBtaW5fc2VxYGAgd2hlbiBgYGxydWdlbi0+bGlzdHNbXWBgIGluZGV4ZWQgYnkKK2BgbWlu X3NlcSVNQVhfTlJfR0VOU2BgIGJlY29tZXMgZW1wdHkuIFRvIHNlbGVjdCBhIHR5cGUgYW5kIGEg dGllciB0bworZXZpY3QgZnJvbSwgaXQgZmlyc3QgY29tcGFyZXMgYGBtaW5fc2VxW11gYCB0byBz ZWxlY3QgdGhlIG9sZGVyIHR5cGUuCitJZiBib3RoIHR5cGVzIGFyZSBlcXVhbGx5IG9sZCwgaXQg c2VsZWN0cyB0aGUgb25lIHdob3NlIGZpcnN0IHRpZXIgaGFzCithIGxvd2VyIHJlZmF1bHQgcGVy Y2VudGFnZS4gVGhlIGZpcnN0IHRpZXIgY29udGFpbnMgc2luZ2xlLXVzZQordW5tYXBwZWQgY2xl YW4gcGFnZXMsIHdoaWNoIGFyZSB0aGUgYmVzdCBiZXQuIFRoZSBldmljdGlvbiBzb3J0cyBhCitw YWdlIGFjY29yZGluZyB0byB0aGUgZ2VuIGNvdW50ZXIgaWYgdGhlIGFnaW5nIGhhcyBmb3VuZCB0 aGlzIHBhZ2UKK2FjY2Vzc2VkIHRocm91Z2ggcGFnZSB0YWJsZXMgYW5kIHVwZGF0ZWQgdGhlIGdl biBjb3VudGVyLiBJdCBhbHNvCittb3ZlcyBhIHBhZ2UgdG8gdGhlIG5leHQgZ2VuZXJhdGlvbiwg aS5lLiwgYGBtaW5fc2VxKzFgYCwgaWYgdGhpcyBwYWdlCit3YXMgYWNjZXNzZWQgbXVsdGlwbGUg dGltZXMgdGhyb3VnaCBmaWxlIGRlc2NyaXB0b3JzIGFuZCB0aGUgZmVlZGJhY2sKK2xvb3AgaGFz IGRldGVjdGVkIG91dGx5aW5nIHJlZmF1bHRzIGZyb20gdGhlIHRpZXIgdGhpcyBwYWdlIGlzIGlu LiBUbworZG8gdGhpcywgdGhlIGZlZWRiYWNrIGxvb3AgdXNlcyB0aGUgZmlyc3QgdGllciBhcyB0 aGUgYmFzZWxpbmUsIGZvcgordGhlIHJlYXNvbiBzdGF0ZWQgZWFybGllci4KKworU3VtbWFyeQor LS0tLS0tLQorVGhlIG11bHRpLWdlbiBMUlUgY2FuIGJlIGRpc2Fzc2VtYmxlZCBpbnRvIHRoZSBm b2xsb3dpbmcgcGFydHM6CisKKyogR2VuZXJhdGlvbnMKKyogUGFnZSB0YWJsZSB3YWxrcworKiBS bWFwIHdhbGtzCisqIEJsb29tIGZpbHRlcnMKKyogVGhlIFBJRCBjb250cm9sbGVyCisKK1RoZSBh Z2luZyBhbmQgdGhlIGV2aWN0aW9uIGlzIGEgcHJvZHVjZXItY29uc3VtZXIgbW9kZWw7IHNwZWNp ZmljYWxseSwKK3RoZSBsYXR0ZXIgZHJpdmVzIHRoZSBmb3JtZXIgYnkgdGhlIHNsaWRpbmcgd2lu ZG93IG92ZXIgZ2VuZXJhdGlvbnMuCitXaXRoaW4gdGhlIGFnaW5nLCBybWFwIHdhbGtzIGRyaXZl IHBhZ2UgdGFibGUgd2Fsa3MgYnkgaW5zZXJ0aW5nIGhvdAorZGVuc2VseSBwb3B1bGF0ZWQgcGFn ZSB0YWJsZXMgdG8gdGhlIEJsb29tIGZpbHRlcnMuIFdpdGhpbiB0aGUKK2V2aWN0aW9uLCB0aGUg UElEIGNvbnRyb2xsZXIgdXNlcyByZWZhdWx0cyBhcyB0aGUgZmVlZGJhY2sgdG8gc2VsZWN0Cit0 eXBlcyB0byBldmljdCBhbmQgdGllcnMgdG8gcHJvdGVjdC4KLS0gCjIuMzUuMS42MTYuZzBiZGNi YjQ0NjQtZ29vZwoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMu aW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZv L2xpbnV4LWFybS1rZXJuZWwK