From mboxrd@z Thu Jan 1 00:00:00 1970 From: Borislav Petkov Subject: Re: [PATCH v8 01/28] linkage: new macros for assembler symbols Date: Mon, 12 Aug 2019 19:06:52 +0200 Message-ID: <20190812170652.GJ23772@zn.tnic> References: <20190808103854.6192-1-jslaby@suse.cz> <20190808103854.6192-2-jslaby@suse.cz> Mime-Version: 1.0 Content-Type: text/plain; charset=utf-8 Return-path: Content-Disposition: inline In-Reply-To: <20190808103854.6192-2-jslaby@suse.cz> Sender: linux-kernel-owner@vger.kernel.org To: Jiri Slaby Cc: tglx@linutronix.de, mingo@redhat.com, hpa@zytor.com, x86@kernel.org, linux-arch@vger.kernel.org, linux-kernel@vger.kernel.org, Andrew Morton , Boris Ostrovsky , Ingo Molnar , jpoimboe@redhat.com, Juergen Gross , Len Brown , Linus Torvalds , linux-pm@vger.kernel.org, Pavel Machek , Peter Zijlstra , "Rafael J. Wysocki" , xen-devel@lists.xenproject.org List-Id: linux-arch.vger.kernel.org Hi, this time a more detailed look. :) > Subject: Re: [PATCH v8 01/28] linkage: new macros for assembler symbols Patch subject needs a verb, like, for example: "linkage: Introduce new macros for assembler symbols" On Thu, Aug 08, 2019 at 12:38:27PM +0200, Jiri Slaby wrote: > Introduce new C macros for annotations of functions and data in > assembly. There is a long-standing mess in macros like ENTRY, END, > ENDPROC and similar. They are used in different manners and sometimes > incorrectly. > > So introduce macros with clear use to annotate assembly as follows: > > a) Support macros for the ones below > SYM_T_FUNC -- type used by assembler to mark functions > SYM_T_OBJECT -- type used by assembler to mark data > SYM_T_NONE -- type used by assembler to mark entries of unknown type > > They are defined as STT_FUNC, STT_OBJECT, and STT_NOTYPE > respectively. According to the gas manual, this is the most portable > way. I am not sure about other assemblers, so we can switch this back > to %function and %object if this turns into a problem. Architectures > can also override them by something like ", @function" if they need. > > SYM_A_ALIGN, SYM_A_NONE -- align the symbol? > SYM_L_GLOBAL, SYM_L_WEAK, SYM_L_LOCAL -- linkage of symbols > > b) Mostly internal annotations, used by the ones below > SYM_ENTRY -- use only if you have to (for non-paired symbols) > SYM_START -- use only if you have to (for paired symbols) > SYM_END -- use only if you have to (for paired symbols) > > c) Annotations for code > SYM_INNER_LABEL_ALIGN -- only for labels in the middle of code > SYM_INNER_LABEL -- only for labels in the middle of code > > SYM_FUNC_START_LOCAL_ALIAS -- use where there are two local names for > one function > SYM_FUNC_START_ALIAS -- use where there are two global names for one > function > SYM_FUNC_END_ALIAS -- the end of LOCAL_ALIASed or ALIASed function > > SYM_FUNC_START -- use for global functions > SYM_FUNC_START_NOALIGN -- use for global functions, w/o alignment > SYM_FUNC_START_LOCAL -- use for local functions > SYM_FUNC_START_LOCAL_NOALIGN -- use for local functions, w/o > alignment > SYM_FUNC_START_WEAK -- use for weak functions > SYM_FUNC_START_WEAK_NOALIGN -- use for weak functions, w/o alignment > SYM_FUNC_END -- the end of SYM_FUNC_START_LOCAL, SYM_FUNC_START, > SYM_FUNC_START_WEAK, ... > > For functions with special (non-C) calling conventions: > SYM_CODE_START -- use for non-C (special) functions > SYM_CODE_START_NOALIGN -- use for non-C (special) functions, w/o > alignment > SYM_CODE_START_LOCAL -- use for local non-C (special) functions > SYM_CODE_START_LOCAL_NOALIGN -- use for local non-C (special) > functions, w/o alignment > SYM_CODE_END -- the end of SYM_CODE_START_LOCAL or SYM_CODE_START > > d) For data > SYM_DATA_START -- global data symbol > SYM_DATA_START_LOCAL -- local data symbol > SYM_DATA_END -- the end of the SYM_DATA_START symbol > SYM_DATA_END_LABEL -- the labeled end of SYM_DATA_START symbol > SYM_DATA -- start+end wrapper around simple global data > SYM_DATA_LOCAL -- start+end wrapper around simple local data > > ========== > > The macros allow to pair starts and ends of functions and mark functions > correctly in the output ELF objects. > > All users of the old macros in x86 are converted to use these in further > patches. > > [v2] > * use SYM_ prefix and sane names > * add SYM_START and SYM_END and parametrize all the macros > > [v3] > * add SYM_DATA, SYM_DATA_LOCAL, and SYM_DATA_END_LABEL > > [v4] > * add _NOALIGN versions of some macros > * add _CODE_ derivates of _FUNC_ macros > > [v5] > * drop "SIMPLE" from data annotations > * switch NOALIGN and ALIGN variants of inner labels > * s/visibility/linkage/; s@SYM_V_@SYM_L_@ > * add Documentation > > [v6] > * fixed typos found by Randy Dunlap > * remove doubled INNER_LABEL macros, one pair was unused > > [v8] > * use lkml.kernel.org for links > * link the docs from index.rst (by bpetkov) > * fixed typos on the docs Patch version history which doesn't belong in the commit message goes... > Signed-off-by: Jiri Slaby > Cc: Andrew Morton > Cc: Boris Ostrovsky > Cc: hpa@zytor.com > Cc: Ingo Molnar > Cc: jpoimboe@redhat.com > Cc: Juergen Gross > Cc: Len Brown > Cc: Linus Torvalds > Cc: linux-kernel@vger.kernel.org > Cc: linux-pm@vger.kernel.org > Cc: mingo@redhat.com > Cc: Pavel Machek > Cc: Peter Zijlstra > Cc: "Rafael J. Wysocki" > Cc: Thomas Gleixner > Cc: xen-devel@lists.xenproject.org > Cc: x86@kernel.org > --- ... here, under the "---" so that git can ignore it when applying. > Documentation/asm-annotations.rst | 217 ++++++++++++++++++++++++++ > Documentation/index.rst | 8 + > arch/x86/include/asm/linkage.h | 10 +- > include/linux/linkage.h | 245 +++++++++++++++++++++++++++++- > 4 files changed, 469 insertions(+), 11 deletions(-) > create mode 100644 Documentation/asm-annotations.rst > > diff --git a/Documentation/asm-annotations.rst b/Documentation/asm-annotations.rst > new file mode 100644 > index 000000000000..a967648e4325 > --- /dev/null > +++ b/Documentation/asm-annotations.rst > @@ -0,0 +1,217 @@ > +Assembler Annotations > +===================== > + > +Copyright (c) 2017-2019 Jiri Slaby > + > +This document describes the new macros for annotation of data and code in > +assembly. In particular, it contains information about ``SYM_FUNC_START``, > +``SYM_FUNC_END``, ``SYM_CODE_START``, and similar. > + > +Rationale > +--------- > +Some code like entries, trampolines, or boot code needs to be written in > +assembly. The same as in C, we group such code into functions and accompany "we" is? Make this passive: "... such code is grouped into... " > +them with data. Standard assemblers do not force users into precisely marking > +these pieces as code, data, or even specifying their length. Nevertheless, > +assemblers provide developers with such marks to aid debuggers throughout s/marks/annotations/ > +assembly. On the top of that, developers also want to stamp some functions as On top of that, ... s/stamp/mark/ > +*global* to be visible outside of their translation units. s/to be visible/in order to be visible/ > + > +Over time, the Linux kernel took over macros from various projects (like s/took over/has adopted/ > +``binutils``) to ease these markings. s/ease these markings/facilitate such annotations/ > So for historic reasons, we have been s/we have been/people have been/ > +using ``ENTRY``, ``END``, ``ENDPROC``, and other annotations in assembly. Due > +to the lack of their documentation, the macros are used in rather wrong > +contexts at some locations. Clearly, ``ENTRY`` was intended for starts of > +global symbols (be it data or code). s/for starts of global symbols/to denote the beginning of global symbols/ > ``END`` used to be the end of data or end s/used to be/used to mark/ > +of special functions with *non-standard* calling convention. In contrast, > +``ENDPROC`` should annotate only ends of *standard* functions. > + > +When these macros are used correctly, they help assemblers to generate a nice s/to // > +object with both sizes and types set correctly. For example the result of comma: For example, the result of... > +``arch/x86/lib/putuser.S``:: > + > + Num: Value Size Type Bind Vis Ndx Name > + 25: 0000000000000000 33 FUNC GLOBAL DEFAULT 1 __put_user_1 > + 29: 0000000000000030 37 FUNC GLOBAL DEFAULT 1 __put_user_2 > + 32: 0000000000000060 36 FUNC GLOBAL DEFAULT 1 __put_user_4 > + 35: 0000000000000090 37 FUNC GLOBAL DEFAULT 1 __put_user_8 > + > +This is not only important for debugging purposes. When we have properly > +marked objects like this, we can run tools on them and let the tools generate > +more useful information. In particular, on properly marked objects, we can run > +``objtool`` and let it check and fix the object if needed. Passive formulation pls, i.e., get rid of the "we". Pls check and fix the whole text. > Currently, it can > +report missing frame pointer setup/destruction in functions. It can also > +automatically generate annotations for *ORC unwinder* (cf. > +) for most code. Both of these are > +especially important to support reliable stack traces which are in turn > +necessary for *Kernel live patching* (see > +). > + > +Caveat and Discussion > +--------------------- > +As one might realize, there were only three macros previously. That is indeed > +insufficient to cover all the combinations of cases: > + > +* standard/non-standard function > +* code/data > +* global/local symbol > + > +We had a discussion_ and instead of extending the current ``ENTRY/END*`` > +macros, it was decided that we should introduce brand new macros instead:: > + > + So how about using macro names that actually show the purpose, instead > + of importing all the crappy, historic, essentially randomly chosen > + debug symbol macro names from the binutils and older kernels? > + > +.. _discussion: https://lkml.kernel.org/r/20170217104757.28588-1-jslaby@suse.cz > + > +Macros Description > +------------------ > + > +The new macros are prefixed with the ``SYM_`` prefix and can be divided into > +three main groups: > + > +1. ``SYM_FUNC_*`` -- to annotate C-like functions. This means functions with > + standard C calling conventions, i.e. the stack contains a return address at > + the predefined place and a return from the function can happen in a > + standard way. When frame pointers are enabled, save/restore of frame > + pointer shall happen at the start/end of a function, respectively, too. > + > + Checking tools like ``objtool`` should ensure such marked functions conform > + to these rules. The tools can also easily annotate these functions with > + debugging information (like *ORC data*) automatically. > + > +2. ``SYM_CODE_*`` -- special functions called with special stack. Be it > + interrupt handlers with special stack content, trampolines, or startup > + functions. > + > + Checking tools mostly ignore checking of these functions. But some debug > + information still can be generated automatically. For correct debug data, > + this code needs hints like ``UNWIND_HINT_REGS`` provided by developers. > + > +3. ``SYM_DATA*`` -- obviously data belonging to ``.data`` sections and not to > + ``.text``. Data do not contain instructions, so they have to be treated > + specially by the tools: they should not treat the bytes as instructions, > + nor assign any debug information to them. > + > +Instruction Macros > +~~~~~~~~~~~~~~~~~~ > +This section covers ``SYM_FUNC_*`` and ``SYM_CODE_*`` enumerated above. > + > +* ``SYM_FUNC_START`` and ``SYM_FUNC_START_LOCAL`` are supposed to be **the > + most frequent markings**. They are used for functions with standard calling > + conventions -- global and local. Like in C, they both align the functions to > + architecture specific ``__ALIGN`` bytes. There are also ``_NOALIGN`` variants > + for special cases where developers do not want this implicit alignment. > + > + We offer also ``SYM_FUNC_START_WEAK`` and ``SYM_FUNC_START_WEAK_NOALIGN`` > + marks as an assembler counterpart of the *weak* attribute known from C. s/marks/markings/ ... counterpart to the *weak*... > + > + All of these **shall** be coupled with ``SYM_FUNC_END``. First, it marks > + the sequence of instructions as a function and computes its size to the > + generated object file. Second, it also eases checking and processing such > + object files as the tools can trivially find exact start and end of a > + function. I'd change that to "... find exact function boundaries." > + > + So in most cases, developers should write something like in the following > + example, having more instructions in between the macros, of course:: > + > + SYM_FUNC_START(function_hook) > + retq > + SYM_FUNC_END(function_hook) Just use "...asm insns ..." in there so that you don't have to say "having more instructions in between the macros, of course": SYM_FUNC_START(function_hook) ... asm insns ... SYM_FUNC_END(function_hook) > + In fact, this kind of annotation corresponds to now deprecated ``ENTRY`` and > + ``ENDPROC``. "... corresponds to the now deprecated ``ENTRY`` and ``ENDPROC`` macros." > + > +* ``SYM_FUNC_START_ALIAS`` and ``SYM_FUNC_START_LOCAL_ALIAS`` serve for those > + who decided to have two or more names for one function. The typical use is:: > + > + SYM_FUNC_START_ALIAS(__memset) > + SYM_FUNC_START(memset) > + ... > + SYM_FUNC_END(memset) > + SYM_FUNC_END_ALIAS(__memset) > + > + In this example, one can call ``__memset`` or ``memset`` with the same > + result. Except the debug information for the instructions is generated to > + the object file only once -- for the non-``ALIAS`` case. One sentence: "... with the same result, except for the debugging information which is generated in the object file only once - for the non-aliasing function." > + > +* ``SYM_CODE_START`` and ``SYM_CODE_START_LOCAL`` should be used only in > + special cases -- if you know what you are doing. This is used exclusively > + for interrupt handlers and similar where the calling convention is not the C > + one. ``_NOALIGN`` variants exist too. The use is the same as for the ``FUNC`` > + category above:: > + > + SYM_CODE_START_LOCAL(bad_put_user) > + movl $-EFAULT,%eax > + EXIT ... asm insns ... > + SYM_CODE_END(bad_put_user) > + > + Again, every ``SYM_CODE_START*`` **shall** be coupled by ``SYM_CODE_END``. Btw, this coupling: I haven't gone through the whole patchset but do we have automatic checking which makes sure a starting macro is coupled with the correct ending macro? > + > + To some extent, this category corresponds to deprecated ``ENTRY`` and > + ``END``. Except ``END`` had several other meanings too. > + > +* ``SYM_INNER_LABEL*`` is used to denote a label inside some > + ``SYM_{CODE,FUNC}_START`` and ``SYM_{CODE,FUNC}_END``. They are very similar > + to C labels, except they can be made global. An example of use:: > + > + SYM_CODE_START(ftrace_caller) > + /* save_mcount_regs fills in first two parameters */ > + ... > + > + SYM_INNER_LABEL(ftrace_caller_op_ptr, SYM_L_GLOBAL) > + /* Load the ftrace_ops into the 3rd parameter */ > + ... > + > + SYM_INNER_LABEL(ftrace_call, SYM_L_GLOBAL) > + call ftrace_stub > + ... > + retq > + SYM_CODE_END(ftrace_caller) > + > +Data Macros > +~~~~~~~~~~~ > +Similar to instructions, we have a couple of macros to describe data in the > +assembly. > Again, they help debuggers to understand the layout of the resulting > +object files. No need for that sentence - I think it is clear by now what they're for. :-) > + > +* ``SYM_DATA_START`` and ``SYM_DATA_START_LOCAL`` mark the start of some data > + and shall be used in conjunction with either ``SYM_DATA_END``, or > + ``SYM_DATA_END_LABEL``. The latter adds also a label to the end, so that > + people can use ``lstack`` and (local) ``lstack_end`` in the following > + example:: > + > + SYM_DATA_START_LOCAL(lstack) > + .skip 4096 > + SYM_DATA_END_LABEL(lstack, SYM_L_LOCAL, lstack_end) > + > +* ``SYM_DATA`` and ``SYM_DATA_LOCAL`` are variants for simple, mostly one-line > + data:: > + > + SYM_DATA(HEAP, .long rm_heap) > + SYM_DATA(heap_end, .long rm_stack) > + > + In the end, they expand to ``SYM_DATA_START`` with ``SYM_DATA_END`` > + internally. > + > +Support Macros > +~~~~~~~~~~~~~~ > +All the above reduce themselves to some invocation of ``SYM_START``, > +``SYM_END``, or ``SYM_ENTRY`` at last. Normally, developers should avoid using > +these. > + > +Further, in the above examples, one could see ``SYM_L_LOCAL``. There are also > +``SYM_L_GLOBAL`` and ``SYM_L_WEAK``. All are intended to denote linkage of a > +symbol marked by them. They are used either in ``_LABEL`` variants of the > +earlier macros, or in ``SYM_START``. > + > + > +Overriding Macros > +~~~~~~~~~~~~~~~~~ > +Architecture can also override any of the macros in their own "Other architectures... " > +``asm/linkage.h``, including macros specifying the type of a symbol > +(``SYM_T_FUNC``, ``SYM_T_OBJECT``, and ``SYM_T_NONE``). As every macro > +described in this file is surrounded by ``#ifdef`` + ``#endif``, it is enough > +to define the macros differently in the aforementioned architecture-dependent > +header. Thx. -- Regards/Gruss, Boris. Good mailing practices for 400: avoid top-posting and trim the reply. From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.1 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_SANE_1 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id B3556C32750 for ; Tue, 13 Aug 2019 06:53:44 +0000 (UTC) Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (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 619CD20665 for ; Tue, 13 Aug 2019 06:53:44 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=alien8.de header.i=@alien8.de header.b="iYyDMxZn" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 619CD20665 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=alien8.de Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=xen-devel-bounces@lists.xenproject.org Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1hxQgQ-0001zq-11; Tue, 13 Aug 2019 06:53:26 +0000 Received: from all-amaz-eas1.inumbo.com ([34.197.232.57] helo=us1-amaz-eas2.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1hxQgN-0001ys-Rf for xen-devel@lists.xenproject.org; Tue, 13 Aug 2019 06:53:24 +0000 X-Inumbo-ID: 79f8ae90-bd23-11e9-b55f-db0d735cf43a Received: from mail.skyhub.de (unknown [5.9.137.197]) by us1-amaz-eas2.inumbo.com (Halon) with ESMTPS id 79f8ae90-bd23-11e9-b55f-db0d735cf43a; Mon, 12 Aug 2019 17:06:08 +0000 (UTC) Received: from zn.tnic (p200300EC2F062700282A196283E22A0A.dip0.t-ipconnect.de [IPv6:2003:ec:2f06:2700:282a:1962:83e2:2a0a]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.skyhub.de (SuperMail on ZX Spectrum 128k) with ESMTPSA id 18ECF1EC0554; Mon, 12 Aug 2019 19:06:07 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=alien8.de; s=dkim; t=1565629567; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:in-reply-to:in-reply-to: references:references; bh=cT0NYAqU7+08mxXX66pYKJNKSpkrmqNv5IFdSC1mdDQ=; b=iYyDMxZnmVlaFHG7/6oQyZqtaYiKddiaJmS1fqzci3g/qm1EINn2lXJTBm+yPUnjQjLtML 0E73p5JkenpLxR6ePxhVFYnb9xD7LwvRB2pn1z+lVDXvig5tjBYNgnzACyMpHJIvF9nsCH VMiMi3SoN8NOcfo2BYfE2b7UjXTOrzw= Date: Mon, 12 Aug 2019 19:06:52 +0200 From: Borislav Petkov To: Jiri Slaby Message-ID: <20190812170652.GJ23772@zn.tnic> References: <20190808103854.6192-1-jslaby@suse.cz> <20190808103854.6192-2-jslaby@suse.cz> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20190808103854.6192-2-jslaby@suse.cz> User-Agent: Mutt/1.10.1 (2018-07-13) Subject: Re: [Xen-devel] [PATCH v8 01/28] linkage: new macros for assembler symbols X-BeenThere: xen-devel@lists.xenproject.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Cc: linux-arch@vger.kernel.org, Juergen Gross , Peter Zijlstra , jpoimboe@redhat.com, Len Brown , Boris Ostrovsky , linux-pm@vger.kernel.org, x86@kernel.org, "Rafael J. Wysocki" , linux-kernel@vger.kernel.org, Ingo Molnar , mingo@redhat.com, Pavel Machek , hpa@zytor.com, xen-devel@lists.xenproject.org, tglx@linutronix.de, Linus Torvalds , Andrew Morton Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" SGksCgp0aGlzIHRpbWUgYSBtb3JlIGRldGFpbGVkIGxvb2suIDopCgo+IFN1YmplY3Q6IFJlOiBb UEFUQ0ggdjggMDEvMjhdIGxpbmthZ2U6IG5ldyBtYWNyb3MgZm9yIGFzc2VtYmxlciBzeW1ib2xz CgpQYXRjaCBzdWJqZWN0IG5lZWRzIGEgdmVyYiwgbGlrZSwgZm9yIGV4YW1wbGU6CgoibGlua2Fn ZTogSW50cm9kdWNlIG5ldyBtYWNyb3MgZm9yIGFzc2VtYmxlciBzeW1ib2xzIgoKT24gVGh1LCBB dWcgMDgsIDIwMTkgYXQgMTI6Mzg6MjdQTSArMDIwMCwgSmlyaSBTbGFieSB3cm90ZToKPiBJbnRy b2R1Y2UgbmV3IEMgbWFjcm9zIGZvciBhbm5vdGF0aW9ucyBvZiBmdW5jdGlvbnMgYW5kIGRhdGEg aW4KPiBhc3NlbWJseS4gVGhlcmUgaXMgYSBsb25nLXN0YW5kaW5nIG1lc3MgaW4gbWFjcm9zIGxp a2UgRU5UUlksIEVORCwKPiBFTkRQUk9DIGFuZCBzaW1pbGFyLiBUaGV5IGFyZSB1c2VkIGluIGRp ZmZlcmVudCBtYW5uZXJzIGFuZCBzb21ldGltZXMKPiBpbmNvcnJlY3RseS4KPiAKPiBTbyBpbnRy b2R1Y2UgbWFjcm9zIHdpdGggY2xlYXIgdXNlIHRvIGFubm90YXRlIGFzc2VtYmx5IGFzIGZvbGxv d3M6Cj4gCj4gYSkgU3VwcG9ydCBtYWNyb3MgZm9yIHRoZSBvbmVzIGJlbG93Cj4gICAgU1lNX1Rf RlVOQyAtLSB0eXBlIHVzZWQgYnkgYXNzZW1ibGVyIHRvIG1hcmsgZnVuY3Rpb25zCj4gICAgU1lN X1RfT0JKRUNUIC0tIHR5cGUgdXNlZCBieSBhc3NlbWJsZXIgdG8gbWFyayBkYXRhCj4gICAgU1lN X1RfTk9ORSAtLSB0eXBlIHVzZWQgYnkgYXNzZW1ibGVyIHRvIG1hcmsgZW50cmllcyBvZiB1bmtu b3duIHR5cGUKPiAKPiAgICBUaGV5IGFyZSBkZWZpbmVkIGFzIFNUVF9GVU5DLCBTVFRfT0JKRUNU LCBhbmQgU1RUX05PVFlQRQo+ICAgIHJlc3BlY3RpdmVseS4gQWNjb3JkaW5nIHRvIHRoZSBnYXMg bWFudWFsLCB0aGlzIGlzIHRoZSBtb3N0IHBvcnRhYmxlCj4gICAgd2F5LiBJIGFtIG5vdCBzdXJl IGFib3V0IG90aGVyIGFzc2VtYmxlcnMsIHNvIHdlIGNhbiBzd2l0Y2ggdGhpcyBiYWNrCj4gICAg dG8gJWZ1bmN0aW9uIGFuZCAlb2JqZWN0IGlmIHRoaXMgdHVybnMgaW50byBhIHByb2JsZW0uIEFy Y2hpdGVjdHVyZXMKPiAgICBjYW4gYWxzbyBvdmVycmlkZSB0aGVtIGJ5IHNvbWV0aGluZyBsaWtl ICIsIEBmdW5jdGlvbiIgaWYgdGhleSBuZWVkLgo+IAo+ICAgIFNZTV9BX0FMSUdOLCBTWU1fQV9O T05FIC0tIGFsaWduIHRoZSBzeW1ib2w/Cj4gICAgU1lNX0xfR0xPQkFMLCBTWU1fTF9XRUFLLCBT WU1fTF9MT0NBTCAtLSBsaW5rYWdlIG9mIHN5bWJvbHMKPiAKPiBiKSBNb3N0bHkgaW50ZXJuYWwg YW5ub3RhdGlvbnMsIHVzZWQgYnkgdGhlIG9uZXMgYmVsb3cKPiAgICBTWU1fRU5UUlkgLS0gdXNl IG9ubHkgaWYgeW91IGhhdmUgdG8gKGZvciBub24tcGFpcmVkIHN5bWJvbHMpCj4gICAgU1lNX1NU QVJUIC0tIHVzZSBvbmx5IGlmIHlvdSBoYXZlIHRvIChmb3IgcGFpcmVkIHN5bWJvbHMpCj4gICAg U1lNX0VORCAtLSB1c2Ugb25seSBpZiB5b3UgaGF2ZSB0byAoZm9yIHBhaXJlZCBzeW1ib2xzKQo+ IAo+IGMpIEFubm90YXRpb25zIGZvciBjb2RlCj4gICAgU1lNX0lOTkVSX0xBQkVMX0FMSUdOIC0t IG9ubHkgZm9yIGxhYmVscyBpbiB0aGUgbWlkZGxlIG9mIGNvZGUKPiAgICBTWU1fSU5ORVJfTEFC RUwgLS0gb25seSBmb3IgbGFiZWxzIGluIHRoZSBtaWRkbGUgb2YgY29kZQo+IAo+ICAgIFNZTV9G VU5DX1NUQVJUX0xPQ0FMX0FMSUFTIC0tIHVzZSB3aGVyZSB0aGVyZSBhcmUgdHdvIGxvY2FsIG5h bWVzIGZvcgo+IAlvbmUgZnVuY3Rpb24KPiAgICBTWU1fRlVOQ19TVEFSVF9BTElBUyAtLSB1c2Ug d2hlcmUgdGhlcmUgYXJlIHR3byBnbG9iYWwgbmFtZXMgZm9yIG9uZQo+IAlmdW5jdGlvbgo+ICAg IFNZTV9GVU5DX0VORF9BTElBUyAtLSB0aGUgZW5kIG9mIExPQ0FMX0FMSUFTZWQgb3IgQUxJQVNl ZCBmdW5jdGlvbgo+IAo+ICAgIFNZTV9GVU5DX1NUQVJUIC0tIHVzZSBmb3IgZ2xvYmFsIGZ1bmN0 aW9ucwo+ICAgIFNZTV9GVU5DX1NUQVJUX05PQUxJR04gLS0gdXNlIGZvciBnbG9iYWwgZnVuY3Rp b25zLCB3L28gYWxpZ25tZW50Cj4gICAgU1lNX0ZVTkNfU1RBUlRfTE9DQUwgLS0gdXNlIGZvciBs b2NhbCBmdW5jdGlvbnMKPiAgICBTWU1fRlVOQ19TVEFSVF9MT0NBTF9OT0FMSUdOIC0tIHVzZSBm b3IgbG9jYWwgZnVuY3Rpb25zLCB3L28KPiAJYWxpZ25tZW50Cj4gICAgU1lNX0ZVTkNfU1RBUlRf V0VBSyAtLSB1c2UgZm9yIHdlYWsgZnVuY3Rpb25zCj4gICAgU1lNX0ZVTkNfU1RBUlRfV0VBS19O T0FMSUdOIC0tIHVzZSBmb3Igd2VhayBmdW5jdGlvbnMsIHcvbyBhbGlnbm1lbnQKPiAgICBTWU1f RlVOQ19FTkQgLS0gdGhlIGVuZCBvZiBTWU1fRlVOQ19TVEFSVF9MT0NBTCwgU1lNX0ZVTkNfU1RB UlQsCj4gCVNZTV9GVU5DX1NUQVJUX1dFQUssIC4uLgo+IAo+ICAgIEZvciBmdW5jdGlvbnMgd2l0 aCBzcGVjaWFsIChub24tQykgY2FsbGluZyBjb252ZW50aW9uczoKPiAgICBTWU1fQ09ERV9TVEFS VCAtLSB1c2UgZm9yIG5vbi1DIChzcGVjaWFsKSBmdW5jdGlvbnMKPiAgICBTWU1fQ09ERV9TVEFS VF9OT0FMSUdOIC0tIHVzZSBmb3Igbm9uLUMgKHNwZWNpYWwpIGZ1bmN0aW9ucywgdy9vCj4gCWFs aWdubWVudAo+ICAgIFNZTV9DT0RFX1NUQVJUX0xPQ0FMIC0tIHVzZSBmb3IgbG9jYWwgbm9uLUMg KHNwZWNpYWwpIGZ1bmN0aW9ucwo+ICAgIFNZTV9DT0RFX1NUQVJUX0xPQ0FMX05PQUxJR04gLS0g dXNlIGZvciBsb2NhbCBub24tQyAoc3BlY2lhbCkKPiAJZnVuY3Rpb25zLCB3L28gYWxpZ25tZW50 Cj4gICAgU1lNX0NPREVfRU5EIC0tIHRoZSBlbmQgb2YgU1lNX0NPREVfU1RBUlRfTE9DQUwgb3Ig U1lNX0NPREVfU1RBUlQKPiAKPiBkKSBGb3IgZGF0YQo+ICAgIFNZTV9EQVRBX1NUQVJUIC0tIGds b2JhbCBkYXRhIHN5bWJvbAo+ICAgIFNZTV9EQVRBX1NUQVJUX0xPQ0FMIC0tIGxvY2FsIGRhdGEg c3ltYm9sCj4gICAgU1lNX0RBVEFfRU5EIC0tIHRoZSBlbmQgb2YgdGhlIFNZTV9EQVRBX1NUQVJU IHN5bWJvbAo+ICAgIFNZTV9EQVRBX0VORF9MQUJFTCAtLSB0aGUgbGFiZWxlZCBlbmQgb2YgU1lN X0RBVEFfU1RBUlQgc3ltYm9sCj4gICAgU1lNX0RBVEEgLS0gc3RhcnQrZW5kIHdyYXBwZXIgYXJv dW5kIHNpbXBsZSBnbG9iYWwgZGF0YQo+ICAgIFNZTV9EQVRBX0xPQ0FMIC0tIHN0YXJ0K2VuZCB3 cmFwcGVyIGFyb3VuZCBzaW1wbGUgbG9jYWwgZGF0YQo+IAo+ID09PT09PT09PT0KPiAKPiBUaGUg bWFjcm9zIGFsbG93IHRvIHBhaXIgc3RhcnRzIGFuZCBlbmRzIG9mIGZ1bmN0aW9ucyBhbmQgbWFy ayBmdW5jdGlvbnMKPiBjb3JyZWN0bHkgaW4gdGhlIG91dHB1dCBFTEYgb2JqZWN0cy4KPiAKPiBB bGwgdXNlcnMgb2YgdGhlIG9sZCBtYWNyb3MgaW4geDg2IGFyZSBjb252ZXJ0ZWQgdG8gdXNlIHRo ZXNlIGluIGZ1cnRoZXIKPiBwYXRjaGVzLgo+IAo+IFt2Ml0KPiAqIHVzZSBTWU1fIHByZWZpeCBh bmQgc2FuZSBuYW1lcwo+ICogYWRkIFNZTV9TVEFSVCBhbmQgU1lNX0VORCBhbmQgcGFyYW1ldHJp emUgYWxsIHRoZSBtYWNyb3MKPiAKPiBbdjNdCj4gKiBhZGQgU1lNX0RBVEEsIFNZTV9EQVRBX0xP Q0FMLCBhbmQgU1lNX0RBVEFfRU5EX0xBQkVMCj4gCj4gW3Y0XQo+ICogYWRkIF9OT0FMSUdOIHZl cnNpb25zIG9mIHNvbWUgbWFjcm9zCj4gKiBhZGQgX0NPREVfIGRlcml2YXRlcyBvZiBfRlVOQ18g bWFjcm9zCj4gCj4gW3Y1XQo+ICogZHJvcCAiU0lNUExFIiBmcm9tIGRhdGEgYW5ub3RhdGlvbnMK PiAqIHN3aXRjaCBOT0FMSUdOIGFuZCBBTElHTiB2YXJpYW50cyBvZiBpbm5lciBsYWJlbHMKPiAq IHMvdmlzaWJpbGl0eS9saW5rYWdlLzsgc0BTWU1fVl9AU1lNX0xfQAo+ICogYWRkIERvY3VtZW50 YXRpb24KPiAKPiBbdjZdCj4gKiBmaXhlZCB0eXBvcyBmb3VuZCBieSBSYW5keSBEdW5sYXAKPiAq IHJlbW92ZSBkb3VibGVkIElOTkVSX0xBQkVMIG1hY3Jvcywgb25lIHBhaXIgd2FzIHVudXNlZAo+ IAo+IFt2OF0KPiAqIHVzZSBsa21sLmtlcm5lbC5vcmcgZm9yIGxpbmtzCj4gKiBsaW5rIHRoZSBk b2NzIGZyb20gaW5kZXgucnN0IChieSBicGV0a292KQo+ICogZml4ZWQgdHlwb3Mgb24gdGhlIGRv Y3MKClBhdGNoIHZlcnNpb24gaGlzdG9yeSB3aGljaCBkb2Vzbid0IGJlbG9uZyBpbiB0aGUgY29t bWl0IG1lc3NhZ2UgZ29lcy4uLgoKPiBTaWduZWQtb2ZmLWJ5OiBKaXJpIFNsYWJ5IDxqc2xhYnlA c3VzZS5jej4KPiBDYzogQW5kcmV3IE1vcnRvbiA8YWtwbUBsaW51eC1mb3VuZGF0aW9uLm9yZz4K PiBDYzogQm9yaXMgT3N0cm92c2t5IDxib3Jpcy5vc3Ryb3Zza3lAb3JhY2xlLmNvbT4KPiBDYzog aHBhQHp5dG9yLmNvbQo+IENjOiBJbmdvIE1vbG5hciA8bWluZ29Aa2VybmVsLm9yZz4KPiBDYzog anBvaW1ib2VAcmVkaGF0LmNvbQo+IENjOiBKdWVyZ2VuIEdyb3NzIDxqZ3Jvc3NAc3VzZS5jb20+ Cj4gQ2M6IExlbiBCcm93biA8bGVuLmJyb3duQGludGVsLmNvbT4KPiBDYzogTGludXMgVG9ydmFs ZHMgPHRvcnZhbGRzQGxpbnV4LWZvdW5kYXRpb24ub3JnPgo+IENjOiBsaW51eC1rZXJuZWxAdmdl ci5rZXJuZWwub3JnCj4gQ2M6IGxpbnV4LXBtQHZnZXIua2VybmVsLm9yZwo+IENjOiBtaW5nb0By ZWRoYXQuY29tCj4gQ2M6IFBhdmVsIE1hY2hlayA8cGF2ZWxAdWN3LmN6Pgo+IENjOiBQZXRlciBa aWpsc3RyYSA8YS5wLnppamxzdHJhQGNoZWxsby5ubD4KPiBDYzogIlJhZmFlbCBKLiBXeXNvY2tp IiA8cmp3QHJqd3lzb2NraS5uZXQ+Cj4gQ2M6IFRob21hcyBHbGVpeG5lciA8dGdseEBsaW51dHJv bml4LmRlPgo+IENjOiB4ZW4tZGV2ZWxAbGlzdHMueGVucHJvamVjdC5vcmcKPiBDYzogeDg2QGtl cm5lbC5vcmcKPiAtLS0KCi4uLiBoZXJlLCB1bmRlciB0aGUgIi0tLSIgc28gdGhhdCBnaXQgY2Fu IGlnbm9yZSBpdCB3aGVuIGFwcGx5aW5nLgoKPiAgRG9jdW1lbnRhdGlvbi9hc20tYW5ub3RhdGlv bnMucnN0IHwgMjE3ICsrKysrKysrKysrKysrKysrKysrKysrKysrCj4gIERvY3VtZW50YXRpb24v aW5kZXgucnN0ICAgICAgICAgICB8ICAgOCArCj4gIGFyY2gveDg2L2luY2x1ZGUvYXNtL2xpbmth Z2UuaCAgICB8ICAxMCArLQo+ICBpbmNsdWRlL2xpbnV4L2xpbmthZ2UuaCAgICAgICAgICAgfCAy NDUgKysrKysrKysrKysrKysrKysrKysrKysrKysrKystCj4gIDQgZmlsZXMgY2hhbmdlZCwgNDY5 IGluc2VydGlvbnMoKyksIDExIGRlbGV0aW9ucygtKQo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgRG9j dW1lbnRhdGlvbi9hc20tYW5ub3RhdGlvbnMucnN0Cj4gCj4gZGlmZiAtLWdpdCBhL0RvY3VtZW50 YXRpb24vYXNtLWFubm90YXRpb25zLnJzdCBiL0RvY3VtZW50YXRpb24vYXNtLWFubm90YXRpb25z LnJzdAo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAwMDAwLi5hOTY3NjQ4 ZTQzMjUKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvRG9jdW1lbnRhdGlvbi9hc20tYW5ub3RhdGlv bnMucnN0Cj4gQEAgLTAsMCArMSwyMTcgQEAKPiArQXNzZW1ibGVyIEFubm90YXRpb25zCj4gKz09 PT09PT09PT09PT09PT09PT09PQo+ICsKPiArQ29weXJpZ2h0IChjKSAyMDE3LTIwMTkgSmlyaSBT bGFieQo+ICsKPiArVGhpcyBkb2N1bWVudCBkZXNjcmliZXMgdGhlIG5ldyBtYWNyb3MgZm9yIGFu bm90YXRpb24gb2YgZGF0YSBhbmQgY29kZSBpbgo+ICthc3NlbWJseS4gSW4gcGFydGljdWxhciwg aXQgY29udGFpbnMgaW5mb3JtYXRpb24gYWJvdXQgYGBTWU1fRlVOQ19TVEFSVGBgLAo+ICtgYFNZ TV9GVU5DX0VORGBgLCBgYFNZTV9DT0RFX1NUQVJUYGAsIGFuZCBzaW1pbGFyLgo+ICsKPiArUmF0 aW9uYWxlCj4gKy0tLS0tLS0tLQo+ICtTb21lIGNvZGUgbGlrZSBlbnRyaWVzLCB0cmFtcG9saW5l cywgb3IgYm9vdCBjb2RlIG5lZWRzIHRvIGJlIHdyaXR0ZW4gaW4KPiArYXNzZW1ibHkuIFRoZSBz YW1lIGFzIGluIEMsIHdlIGdyb3VwIHN1Y2ggY29kZSBpbnRvIGZ1bmN0aW9ucyBhbmQgYWNjb21w YW55Cgoid2UiIGlzPyBNYWtlIHRoaXMgcGFzc2l2ZTogIi4uLiBzdWNoIGNvZGUgaXMgZ3JvdXBl ZCBpbnRvLi4uICIKCj4gK3RoZW0gd2l0aCBkYXRhLiBTdGFuZGFyZCBhc3NlbWJsZXJzIGRvIG5v dCBmb3JjZSB1c2VycyBpbnRvIHByZWNpc2VseSBtYXJraW5nCj4gK3RoZXNlIHBpZWNlcyBhcyBj b2RlLCBkYXRhLCBvciBldmVuIHNwZWNpZnlpbmcgdGhlaXIgbGVuZ3RoLiBOZXZlcnRoZWxlc3Ms Cj4gK2Fzc2VtYmxlcnMgcHJvdmlkZSBkZXZlbG9wZXJzIHdpdGggc3VjaCBtYXJrcyB0byBhaWQg ZGVidWdnZXJzIHRocm91Z2hvdXQKCnMvbWFya3MvYW5ub3RhdGlvbnMvCgo+ICthc3NlbWJseS4g T24gdGhlIHRvcCBvZiB0aGF0LCBkZXZlbG9wZXJzIGFsc28gd2FudCB0byBzdGFtcCBzb21lIGZ1 bmN0aW9ucyBhcwoKT24gdG9wIG9mIHRoYXQsIC4uLgoKcy9zdGFtcC9tYXJrLwoKPiArKmdsb2Jh bCogdG8gYmUgdmlzaWJsZSBvdXRzaWRlIG9mIHRoZWlyIHRyYW5zbGF0aW9uIHVuaXRzLgoKcy90 byBiZSB2aXNpYmxlL2luIG9yZGVyIHRvIGJlIHZpc2libGUvCgo+ICsKPiArT3ZlciB0aW1lLCB0 aGUgTGludXgga2VybmVsIHRvb2sgb3ZlciBtYWNyb3MgZnJvbSB2YXJpb3VzIHByb2plY3RzIChs aWtlCgpzL3Rvb2sgb3Zlci9oYXMgYWRvcHRlZC8KCj4gK2BgYmludXRpbHNgYCkgdG8gZWFzZSB0 aGVzZSBtYXJraW5ncy4KCnMvZWFzZSB0aGVzZSBtYXJraW5ncy9mYWNpbGl0YXRlIHN1Y2ggYW5u b3RhdGlvbnMvCgo+IFNvIGZvciBoaXN0b3JpYyByZWFzb25zLCB3ZSBoYXZlIGJlZW4KCnMvd2Ug aGF2ZSBiZWVuL3Blb3BsZSBoYXZlIGJlZW4vCgo+ICt1c2luZyBgYEVOVFJZYGAsIGBgRU5EYGAs IGBgRU5EUFJPQ2BgLCBhbmQgb3RoZXIgYW5ub3RhdGlvbnMgaW4gYXNzZW1ibHkuIER1ZQo+ICt0 byB0aGUgbGFjayBvZiB0aGVpciBkb2N1bWVudGF0aW9uLCB0aGUgbWFjcm9zIGFyZSB1c2VkIGlu IHJhdGhlciB3cm9uZwo+ICtjb250ZXh0cyBhdCBzb21lIGxvY2F0aW9ucy4gQ2xlYXJseSwgYGBF TlRSWWBgIHdhcyBpbnRlbmRlZCBmb3Igc3RhcnRzIG9mCj4gK2dsb2JhbCBzeW1ib2xzIChiZSBp dCBkYXRhIG9yIGNvZGUpLgoKcy9mb3Igc3RhcnRzIG9mIGdsb2JhbCBzeW1ib2xzL3RvIGRlbm90 ZSB0aGUgYmVnaW5uaW5nIG9mIGdsb2JhbCBzeW1ib2xzLwoKPiBgYEVORGBgIHVzZWQgdG8gYmUg dGhlIGVuZCBvZiBkYXRhIG9yIGVuZAoKcy91c2VkIHRvIGJlL3VzZWQgdG8gbWFyay8KCj4gK29m IHNwZWNpYWwgZnVuY3Rpb25zIHdpdGggKm5vbi1zdGFuZGFyZCogY2FsbGluZyBjb252ZW50aW9u LiBJbiBjb250cmFzdCwKPiArYGBFTkRQUk9DYGAgc2hvdWxkIGFubm90YXRlIG9ubHkgZW5kcyBv ZiAqc3RhbmRhcmQqIGZ1bmN0aW9ucy4KPiArCj4gK1doZW4gdGhlc2UgbWFjcm9zIGFyZSB1c2Vk IGNvcnJlY3RseSwgdGhleSBoZWxwIGFzc2VtYmxlcnMgdG8gZ2VuZXJhdGUgYSBuaWNlCgpzL3Rv IC8vCgo+ICtvYmplY3Qgd2l0aCBib3RoIHNpemVzIGFuZCB0eXBlcyBzZXQgY29ycmVjdGx5LiBG b3IgZXhhbXBsZSB0aGUgcmVzdWx0IG9mCgpjb21tYTogRm9yIGV4YW1wbGUsIHRoZSByZXN1bHQg b2YuLi4KCj4gK2BgYXJjaC94ODYvbGliL3B1dHVzZXIuU2BgOjoKPiArCj4gKyAgIE51bTogICAg VmFsdWUgICAgICAgICAgU2l6ZSBUeXBlICAgIEJpbmQgICBWaXMgICAgICBOZHggTmFtZQo+ICsg ICAgMjU6IDAwMDAwMDAwMDAwMDAwMDAgICAgMzMgRlVOQyAgICBHTE9CQUwgREVGQVVMVCAgICAx IF9fcHV0X3VzZXJfMQo+ICsgICAgMjk6IDAwMDAwMDAwMDAwMDAwMzAgICAgMzcgRlVOQyAgICBH TE9CQUwgREVGQVVMVCAgICAxIF9fcHV0X3VzZXJfMgo+ICsgICAgMzI6IDAwMDAwMDAwMDAwMDAw NjAgICAgMzYgRlVOQyAgICBHTE9CQUwgREVGQVVMVCAgICAxIF9fcHV0X3VzZXJfNAo+ICsgICAg MzU6IDAwMDAwMDAwMDAwMDAwOTAgICAgMzcgRlVOQyAgICBHTE9CQUwgREVGQVVMVCAgICAxIF9f cHV0X3VzZXJfOAo+ICsKPiArVGhpcyBpcyBub3Qgb25seSBpbXBvcnRhbnQgZm9yIGRlYnVnZ2lu ZyBwdXJwb3Nlcy4gV2hlbiB3ZSBoYXZlIHByb3Blcmx5Cj4gK21hcmtlZCBvYmplY3RzIGxpa2Ug dGhpcywgd2UgY2FuIHJ1biB0b29scyBvbiB0aGVtIGFuZCBsZXQgdGhlIHRvb2xzIGdlbmVyYXRl Cj4gK21vcmUgdXNlZnVsIGluZm9ybWF0aW9uLiBJbiBwYXJ0aWN1bGFyLCBvbiBwcm9wZXJseSBt YXJrZWQgb2JqZWN0cywgd2UgY2FuIHJ1bgo+ICtgYG9ianRvb2xgYCBhbmQgbGV0IGl0IGNoZWNr IGFuZCBmaXggdGhlIG9iamVjdCBpZiBuZWVkZWQuCgpQYXNzaXZlIGZvcm11bGF0aW9uIHBscywg aS5lLiwgZ2V0IHJpZCBvZiB0aGUgIndlIi4gUGxzIGNoZWNrIGFuZCBmaXgKdGhlIHdob2xlIHRl eHQuCgo+IEN1cnJlbnRseSwgaXQgY2FuCj4gK3JlcG9ydCBtaXNzaW5nIGZyYW1lIHBvaW50ZXIg c2V0dXAvZGVzdHJ1Y3Rpb24gaW4gZnVuY3Rpb25zLiBJdCBjYW4gYWxzbwo+ICthdXRvbWF0aWNh bGx5IGdlbmVyYXRlIGFubm90YXRpb25zIGZvciAqT1JDIHVud2luZGVyKiAoY2YuCj4gKzxEb2N1 bWVudGF0aW9uL3g4Ni9vcmMtdW53aW5kZXIudHh0PikgZm9yIG1vc3QgY29kZS4gQm90aCBvZiB0 aGVzZSBhcmUKPiArZXNwZWNpYWxseSBpbXBvcnRhbnQgdG8gc3VwcG9ydCByZWxpYWJsZSBzdGFj ayB0cmFjZXMgd2hpY2ggYXJlIGluIHR1cm4KPiArbmVjZXNzYXJ5IGZvciAqS2VybmVsIGxpdmUg cGF0Y2hpbmcqIChzZWUKPiArPERvY3VtZW50YXRpb24vbGl2ZXBhdGNoL2xpdmVwYXRjaC50eHQ+ KS4KPiArCj4gK0NhdmVhdCBhbmQgRGlzY3Vzc2lvbgo+ICstLS0tLS0tLS0tLS0tLS0tLS0tLS0K PiArQXMgb25lIG1pZ2h0IHJlYWxpemUsIHRoZXJlIHdlcmUgb25seSB0aHJlZSBtYWNyb3MgcHJl dmlvdXNseS4gVGhhdCBpcyBpbmRlZWQKPiAraW5zdWZmaWNpZW50IHRvIGNvdmVyIGFsbCB0aGUg Y29tYmluYXRpb25zIG9mIGNhc2VzOgo+ICsKPiArKiBzdGFuZGFyZC9ub24tc3RhbmRhcmQgZnVu Y3Rpb24KPiArKiBjb2RlL2RhdGEKPiArKiBnbG9iYWwvbG9jYWwgc3ltYm9sCj4gKwo+ICtXZSBo YWQgYSBkaXNjdXNzaW9uXyBhbmQgaW5zdGVhZCBvZiBleHRlbmRpbmcgdGhlIGN1cnJlbnQgYGBF TlRSWS9FTkQqYGAKPiArbWFjcm9zLCBpdCB3YXMgZGVjaWRlZCB0aGF0IHdlIHNob3VsZCBpbnRy b2R1Y2UgYnJhbmQgbmV3IG1hY3JvcyBpbnN0ZWFkOjoKPiArCj4gKyAgICBTbyBob3cgYWJvdXQg dXNpbmcgbWFjcm8gbmFtZXMgdGhhdCBhY3R1YWxseSBzaG93IHRoZSBwdXJwb3NlLCBpbnN0ZWFk Cj4gKyAgICBvZiBpbXBvcnRpbmcgYWxsIHRoZSBjcmFwcHksIGhpc3RvcmljLCBlc3NlbnRpYWxs eSByYW5kb21seSBjaG9zZW4KPiArICAgIGRlYnVnIHN5bWJvbCBtYWNybyBuYW1lcyBmcm9tIHRo ZSBiaW51dGlscyBhbmQgb2xkZXIga2VybmVscz8KPiArCj4gKy4uIF9kaXNjdXNzaW9uOiBodHRw czovL2xrbWwua2VybmVsLm9yZy9yLzIwMTcwMjE3MTA0NzU3LjI4NTg4LTEtanNsYWJ5QHN1c2Uu Y3oKPiArCj4gK01hY3JvcyBEZXNjcmlwdGlvbgo+ICstLS0tLS0tLS0tLS0tLS0tLS0KPiArCj4g K1RoZSBuZXcgbWFjcm9zIGFyZSBwcmVmaXhlZCB3aXRoIHRoZSBgYFNZTV9gYCBwcmVmaXggYW5k IGNhbiBiZSBkaXZpZGVkIGludG8KPiArdGhyZWUgbWFpbiBncm91cHM6Cj4gKwo+ICsxLiBgYFNZ TV9GVU5DXypgYCAtLSB0byBhbm5vdGF0ZSBDLWxpa2UgZnVuY3Rpb25zLiBUaGlzIG1lYW5zIGZ1 bmN0aW9ucyB3aXRoCj4gKyAgIHN0YW5kYXJkIEMgY2FsbGluZyBjb252ZW50aW9ucywgaS5lLiB0 aGUgc3RhY2sgY29udGFpbnMgYSByZXR1cm4gYWRkcmVzcyBhdAo+ICsgICB0aGUgcHJlZGVmaW5l ZCBwbGFjZSBhbmQgYSByZXR1cm4gZnJvbSB0aGUgZnVuY3Rpb24gY2FuIGhhcHBlbiBpbiBhCj4g KyAgIHN0YW5kYXJkIHdheS4gV2hlbiBmcmFtZSBwb2ludGVycyBhcmUgZW5hYmxlZCwgc2F2ZS9y ZXN0b3JlIG9mIGZyYW1lCj4gKyAgIHBvaW50ZXIgc2hhbGwgaGFwcGVuIGF0IHRoZSBzdGFydC9l bmQgb2YgYSBmdW5jdGlvbiwgcmVzcGVjdGl2ZWx5LCB0b28uCj4gKwo+ICsgICBDaGVja2luZyB0 b29scyBsaWtlIGBgb2JqdG9vbGBgIHNob3VsZCBlbnN1cmUgc3VjaCBtYXJrZWQgZnVuY3Rpb25z IGNvbmZvcm0KPiArICAgdG8gdGhlc2UgcnVsZXMuIFRoZSB0b29scyBjYW4gYWxzbyBlYXNpbHkg YW5ub3RhdGUgdGhlc2UgZnVuY3Rpb25zIHdpdGgKPiArICAgZGVidWdnaW5nIGluZm9ybWF0aW9u IChsaWtlICpPUkMgZGF0YSopIGF1dG9tYXRpY2FsbHkuCj4gKwo+ICsyLiBgYFNZTV9DT0RFXypg YCAtLSBzcGVjaWFsIGZ1bmN0aW9ucyBjYWxsZWQgd2l0aCBzcGVjaWFsIHN0YWNrLiBCZSBpdAo+ ICsgICBpbnRlcnJ1cHQgaGFuZGxlcnMgd2l0aCBzcGVjaWFsIHN0YWNrIGNvbnRlbnQsIHRyYW1w b2xpbmVzLCBvciBzdGFydHVwCj4gKyAgIGZ1bmN0aW9ucy4KPiArCj4gKyAgIENoZWNraW5nIHRv b2xzIG1vc3RseSBpZ25vcmUgY2hlY2tpbmcgb2YgdGhlc2UgZnVuY3Rpb25zLiBCdXQgc29tZSBk ZWJ1Zwo+ICsgICBpbmZvcm1hdGlvbiBzdGlsbCBjYW4gYmUgZ2VuZXJhdGVkIGF1dG9tYXRpY2Fs bHkuIEZvciBjb3JyZWN0IGRlYnVnIGRhdGEsCj4gKyAgIHRoaXMgY29kZSBuZWVkcyBoaW50cyBs aWtlIGBgVU5XSU5EX0hJTlRfUkVHU2BgIHByb3ZpZGVkIGJ5IGRldmVsb3BlcnMuCj4gKwo+ICsz LiBgYFNZTV9EQVRBKmBgIC0tIG9idmlvdXNseSBkYXRhIGJlbG9uZ2luZyB0byBgYC5kYXRhYGAg c2VjdGlvbnMgYW5kIG5vdCB0bwo+ICsgICBgYC50ZXh0YGAuIERhdGEgZG8gbm90IGNvbnRhaW4g aW5zdHJ1Y3Rpb25zLCBzbyB0aGV5IGhhdmUgdG8gYmUgdHJlYXRlZAo+ICsgICBzcGVjaWFsbHkg YnkgdGhlIHRvb2xzOiB0aGV5IHNob3VsZCBub3QgdHJlYXQgdGhlIGJ5dGVzIGFzIGluc3RydWN0 aW9ucywKPiArICAgbm9yIGFzc2lnbiBhbnkgZGVidWcgaW5mb3JtYXRpb24gdG8gdGhlbS4KPiAr Cj4gK0luc3RydWN0aW9uIE1hY3Jvcwo+ICt+fn5+fn5+fn5+fn5+fn5+fn4KPiArVGhpcyBzZWN0 aW9uIGNvdmVycyBgYFNZTV9GVU5DXypgYCBhbmQgYGBTWU1fQ09ERV8qYGAgZW51bWVyYXRlZCBh Ym92ZS4KPiArCj4gKyogYGBTWU1fRlVOQ19TVEFSVGBgIGFuZCBgYFNZTV9GVU5DX1NUQVJUX0xP Q0FMYGAgYXJlIHN1cHBvc2VkIHRvIGJlICoqdGhlCj4gKyAgbW9zdCBmcmVxdWVudCBtYXJraW5n cyoqLiBUaGV5IGFyZSB1c2VkIGZvciBmdW5jdGlvbnMgd2l0aCBzdGFuZGFyZCBjYWxsaW5nCj4g KyAgY29udmVudGlvbnMgLS0gZ2xvYmFsIGFuZCBsb2NhbC4gTGlrZSBpbiBDLCB0aGV5IGJvdGgg YWxpZ24gdGhlIGZ1bmN0aW9ucyB0bwo+ICsgIGFyY2hpdGVjdHVyZSBzcGVjaWZpYyBgYF9fQUxJ R05gYCBieXRlcy4gVGhlcmUgYXJlIGFsc28gYGBfTk9BTElHTmBgIHZhcmlhbnRzCj4gKyAgZm9y IHNwZWNpYWwgY2FzZXMgd2hlcmUgZGV2ZWxvcGVycyBkbyBub3Qgd2FudCB0aGlzIGltcGxpY2l0 IGFsaWdubWVudC4KPiArCj4gKyAgV2Ugb2ZmZXIgYWxzbyBgYFNZTV9GVU5DX1NUQVJUX1dFQUtg YCBhbmQgYGBTWU1fRlVOQ19TVEFSVF9XRUFLX05PQUxJR05gYAo+ICsgIG1hcmtzIGFzIGFuIGFz c2VtYmxlciBjb3VudGVycGFydCBvZiB0aGUgKndlYWsqIGF0dHJpYnV0ZSBrbm93biBmcm9tIEMu CgpzL21hcmtzL21hcmtpbmdzLwoKCQkJLi4uIGNvdW50ZXJwYXJ0IHRvIHRoZSAqd2VhayouLi4K Cj4gKwo+ICsgIEFsbCBvZiB0aGVzZSAqKnNoYWxsKiogYmUgY291cGxlZCB3aXRoIGBgU1lNX0ZV TkNfRU5EYGAuIEZpcnN0LCBpdCBtYXJrcwo+ICsgIHRoZSBzZXF1ZW5jZSBvZiBpbnN0cnVjdGlv bnMgYXMgYSBmdW5jdGlvbiBhbmQgY29tcHV0ZXMgaXRzIHNpemUgdG8gdGhlCj4gKyAgZ2VuZXJh dGVkIG9iamVjdCBmaWxlLiBTZWNvbmQsIGl0IGFsc28gZWFzZXMgY2hlY2tpbmcgYW5kIHByb2Nl c3Npbmcgc3VjaAo+ICsgIG9iamVjdCBmaWxlcyBhcyB0aGUgdG9vbHMgY2FuIHRyaXZpYWxseSBm aW5kIGV4YWN0IHN0YXJ0IGFuZCBlbmQgb2YgYQo+ICsgIGZ1bmN0aW9uLgoKSSdkIGNoYW5nZSB0 aGF0IHRvICIuLi4gZmluZCBleGFjdCBmdW5jdGlvbiBib3VuZGFyaWVzLiIKCj4gKwo+ICsgIFNv IGluIG1vc3QgY2FzZXMsIGRldmVsb3BlcnMgc2hvdWxkIHdyaXRlIHNvbWV0aGluZyBsaWtlIGlu IHRoZSBmb2xsb3dpbmcKPiArICBleGFtcGxlLCBoYXZpbmcgbW9yZSBpbnN0cnVjdGlvbnMgaW4g YmV0d2VlbiB0aGUgbWFjcm9zLCBvZiBjb3Vyc2U6Ogo+ICsKPiArICAgIFNZTV9GVU5DX1NUQVJU KGZ1bmN0aW9uX2hvb2spCj4gKyAgICAgICAgcmV0cQo+ICsgICAgU1lNX0ZVTkNfRU5EKGZ1bmN0 aW9uX2hvb2spCgpKdXN0IHVzZSAiLi4uYXNtIGluc25zIC4uLiIgaW4gdGhlcmUgc28gdGhhdCB5 b3UgZG9uJ3QgaGF2ZSB0byBzYXkKImhhdmluZyBtb3JlIGluc3RydWN0aW9ucyBpbiBiZXR3ZWVu IHRoZSBtYWNyb3MsIG9mIGNvdXJzZSI6CgoJU1lNX0ZVTkNfU1RBUlQoZnVuY3Rpb25faG9vaykK CQkuLi4gYXNtIGluc25zIC4uLgoJU1lNX0ZVTkNfRU5EKGZ1bmN0aW9uX2hvb2spCgoKPiArICBJ biBmYWN0LCB0aGlzIGtpbmQgb2YgYW5ub3RhdGlvbiBjb3JyZXNwb25kcyB0byBub3cgZGVwcmVj YXRlZCBgYEVOVFJZYGAgYW5kCj4gKyAgYGBFTkRQUk9DYGAuCgoiLi4uIGNvcnJlc3BvbmRzIHRv IHRoZSBub3cgZGVwcmVjYXRlZCBgYEVOVFJZYGAgYW5kIGBgRU5EUFJPQ2BgIG1hY3Jvcy4iCgo+ ICsKPiArKiBgYFNZTV9GVU5DX1NUQVJUX0FMSUFTYGAgYW5kIGBgU1lNX0ZVTkNfU1RBUlRfTE9D QUxfQUxJQVNgYCBzZXJ2ZSBmb3IgdGhvc2UKPiArICB3aG8gZGVjaWRlZCB0byBoYXZlIHR3byBv ciBtb3JlIG5hbWVzIGZvciBvbmUgZnVuY3Rpb24uIFRoZSB0eXBpY2FsIHVzZSBpczo6Cj4gKwo+ ICsgICAgU1lNX0ZVTkNfU1RBUlRfQUxJQVMoX19tZW1zZXQpCj4gKyAgICBTWU1fRlVOQ19TVEFS VChtZW1zZXQpCj4gKyAgICAgICAgLi4uCj4gKyAgICBTWU1fRlVOQ19FTkQobWVtc2V0KQo+ICsg ICAgU1lNX0ZVTkNfRU5EX0FMSUFTKF9fbWVtc2V0KQo+ICsKPiArICBJbiB0aGlzIGV4YW1wbGUs IG9uZSBjYW4gY2FsbCBgYF9fbWVtc2V0YGAgb3IgYGBtZW1zZXRgYCB3aXRoIHRoZSBzYW1lCj4g KyAgcmVzdWx0LiBFeGNlcHQgdGhlIGRlYnVnIGluZm9ybWF0aW9uIGZvciB0aGUgaW5zdHJ1Y3Rp b25zIGlzIGdlbmVyYXRlZCB0bwo+ICsgIHRoZSBvYmplY3QgZmlsZSBvbmx5IG9uY2UgLS0gZm9y IHRoZSBub24tYGBBTElBU2BgIGNhc2UuCgpPbmUgc2VudGVuY2U6CgoiLi4uIHdpdGggdGhlIHNh bWUgcmVzdWx0LCBleGNlcHQgZm9yIHRoZSBkZWJ1Z2dpbmcgaW5mb3JtYXRpb24gd2hpY2ggaXMK Z2VuZXJhdGVkIGluIHRoZSBvYmplY3QgZmlsZSBvbmx5IG9uY2UgLSBmb3IgdGhlIG5vbi1hbGlh c2luZyBmdW5jdGlvbi4iCgo+ICsKPiArKiBgYFNZTV9DT0RFX1NUQVJUYGAgYW5kIGBgU1lNX0NP REVfU1RBUlRfTE9DQUxgYCBzaG91bGQgYmUgdXNlZCBvbmx5IGluCj4gKyAgc3BlY2lhbCBjYXNl cyAtLSBpZiB5b3Uga25vdyB3aGF0IHlvdSBhcmUgZG9pbmcuIFRoaXMgaXMgdXNlZCBleGNsdXNp dmVseQo+ICsgIGZvciBpbnRlcnJ1cHQgaGFuZGxlcnMgYW5kIHNpbWlsYXIgd2hlcmUgdGhlIGNh bGxpbmcgY29udmVudGlvbiBpcyBub3QgdGhlIEMKPiArICBvbmUuIGBgX05PQUxJR05gYCB2YXJp YW50cyBleGlzdCB0b28uIFRoZSB1c2UgaXMgdGhlIHNhbWUgYXMgZm9yIHRoZSBgYEZVTkNgYAo+ ICsgIGNhdGVnb3J5IGFib3ZlOjoKPiArCj4gKyAgICBTWU1fQ09ERV9TVEFSVF9MT0NBTChiYWRf cHV0X3VzZXIpCj4gKyAgICAgICAgbW92bCAkLUVGQVVMVCwlZWF4Cj4gKyAgICAgICAgRVhJVAoK CS4uLiBhc20gaW5zbnMgLi4uCgo+ICsgICAgU1lNX0NPREVfRU5EKGJhZF9wdXRfdXNlcikKPiAr Cj4gKyAgQWdhaW4sIGV2ZXJ5IGBgU1lNX0NPREVfU1RBUlQqYGAgKipzaGFsbCoqIGJlIGNvdXBs ZWQgYnkgYGBTWU1fQ09ERV9FTkRgYC4KCkJ0dywgdGhpcyBjb3VwbGluZzogSSBoYXZlbid0IGdv bmUgdGhyb3VnaCB0aGUgd2hvbGUgcGF0Y2hzZXQgYnV0IGRvIHdlCmhhdmUgYXV0b21hdGljIGNo ZWNraW5nIHdoaWNoIG1ha2VzIHN1cmUgYSBzdGFydGluZyBtYWNybyBpcyBjb3VwbGVkCndpdGgg dGhlIGNvcnJlY3QgZW5kaW5nIG1hY3JvPwoKPiArCj4gKyAgVG8gc29tZSBleHRlbnQsIHRoaXMg Y2F0ZWdvcnkgY29ycmVzcG9uZHMgdG8gZGVwcmVjYXRlZCBgYEVOVFJZYGAgYW5kCj4gKyAgYGBF TkRgYC4gRXhjZXB0IGBgRU5EYGAgaGFkIHNldmVyYWwgb3RoZXIgbWVhbmluZ3MgdG9vLgo+ICsK PiArKiBgYFNZTV9JTk5FUl9MQUJFTCpgYCBpcyB1c2VkIHRvIGRlbm90ZSBhIGxhYmVsIGluc2lk ZSBzb21lCj4gKyAgYGBTWU1fe0NPREUsRlVOQ31fU1RBUlRgYCBhbmQgYGBTWU1fe0NPREUsRlVO Q31fRU5EYGAuICBUaGV5IGFyZSB2ZXJ5IHNpbWlsYXIKPiArICB0byBDIGxhYmVscywgZXhjZXB0 IHRoZXkgY2FuIGJlIG1hZGUgZ2xvYmFsLiBBbiBleGFtcGxlIG9mIHVzZTo6Cj4gKwo+ICsgICAg U1lNX0NPREVfU1RBUlQoZnRyYWNlX2NhbGxlcikKPiArICAgICAgICAvKiBzYXZlX21jb3VudF9y ZWdzIGZpbGxzIGluIGZpcnN0IHR3byBwYXJhbWV0ZXJzICovCj4gKyAgICAgICAgLi4uCj4gKwo+ ICsgICAgU1lNX0lOTkVSX0xBQkVMKGZ0cmFjZV9jYWxsZXJfb3BfcHRyLCBTWU1fTF9HTE9CQUwp Cj4gKyAgICAgICAgLyogTG9hZCB0aGUgZnRyYWNlX29wcyBpbnRvIHRoZSAzcmQgcGFyYW1ldGVy ICovCj4gKyAgICAgICAgLi4uCj4gKwo+ICsgICAgU1lNX0lOTkVSX0xBQkVMKGZ0cmFjZV9jYWxs LCBTWU1fTF9HTE9CQUwpCj4gKyAgICAgICAgY2FsbCBmdHJhY2Vfc3R1Ygo+ICsgICAgICAgIC4u Lgo+ICsgICAgICAgIHJldHEKPiArICAgIFNZTV9DT0RFX0VORChmdHJhY2VfY2FsbGVyKQo+ICsK PiArRGF0YSBNYWNyb3MKPiArfn5+fn5+fn5+fn4KPiArU2ltaWxhciB0byBpbnN0cnVjdGlvbnMs IHdlIGhhdmUgYSBjb3VwbGUgb2YgbWFjcm9zIHRvIGRlc2NyaWJlIGRhdGEgaW4gdGhlCj4gK2Fz c2VtYmx5LgoKPiBBZ2FpbiwgdGhleSBoZWxwIGRlYnVnZ2VycyB0byB1bmRlcnN0YW5kIHRoZSBs YXlvdXQgb2YgdGhlIHJlc3VsdGluZwo+ICtvYmplY3QgZmlsZXMuCgpObyBuZWVkIGZvciB0aGF0 IHNlbnRlbmNlIC0gSSB0aGluayBpdCBpcyBjbGVhciBieSBub3cgd2hhdCB0aGV5J3JlIGZvci4K Oi0pCgo+ICsKPiArKiBgYFNZTV9EQVRBX1NUQVJUYGAgYW5kIGBgU1lNX0RBVEFfU1RBUlRfTE9D QUxgYCBtYXJrIHRoZSBzdGFydCBvZiBzb21lIGRhdGEKPiArICBhbmQgc2hhbGwgYmUgdXNlZCBp biBjb25qdW5jdGlvbiB3aXRoIGVpdGhlciBgYFNZTV9EQVRBX0VORGBgLCBvcgo+ICsgIGBgU1lN X0RBVEFfRU5EX0xBQkVMYGAuIFRoZSBsYXR0ZXIgYWRkcyBhbHNvIGEgbGFiZWwgdG8gdGhlIGVu ZCwgc28gdGhhdAo+ICsgIHBlb3BsZSBjYW4gdXNlIGBgbHN0YWNrYGAgYW5kIChsb2NhbCkgYGBs c3RhY2tfZW5kYGAgaW4gdGhlIGZvbGxvd2luZwo+ICsgIGV4YW1wbGU6Ogo+ICsKPiArICAgIFNZ TV9EQVRBX1NUQVJUX0xPQ0FMKGxzdGFjaykKPiArICAgICAgICAuc2tpcCA0MDk2Cj4gKyAgICBT WU1fREFUQV9FTkRfTEFCRUwobHN0YWNrLCBTWU1fTF9MT0NBTCwgbHN0YWNrX2VuZCkKPiArCj4g KyogYGBTWU1fREFUQWBgIGFuZCBgYFNZTV9EQVRBX0xPQ0FMYGAgYXJlIHZhcmlhbnRzIGZvciBz aW1wbGUsIG1vc3RseSBvbmUtbGluZQo+ICsgIGRhdGE6Ogo+ICsKPiArICAgIFNZTV9EQVRBKEhF QVAsICAgICAubG9uZyBybV9oZWFwKQo+ICsgICAgU1lNX0RBVEEoaGVhcF9lbmQsIC5sb25nIHJt X3N0YWNrKQo+ICsKPiArICBJbiB0aGUgZW5kLCB0aGV5IGV4cGFuZCB0byBgYFNZTV9EQVRBX1NU QVJUYGAgd2l0aCBgYFNZTV9EQVRBX0VORGBgCj4gKyAgaW50ZXJuYWxseS4KPiArCj4gK1N1cHBv cnQgTWFjcm9zCj4gK35+fn5+fn5+fn5+fn5+Cj4gK0FsbCB0aGUgYWJvdmUgcmVkdWNlIHRoZW1z ZWx2ZXMgdG8gc29tZSBpbnZvY2F0aW9uIG9mIGBgU1lNX1NUQVJUYGAsCj4gK2BgU1lNX0VORGBg LCBvciBgYFNZTV9FTlRSWWBgIGF0IGxhc3QuIE5vcm1hbGx5LCBkZXZlbG9wZXJzIHNob3VsZCBh dm9pZCB1c2luZwo+ICt0aGVzZS4KPiArCj4gK0Z1cnRoZXIsIGluIHRoZSBhYm92ZSBleGFtcGxl cywgb25lIGNvdWxkIHNlZSBgYFNZTV9MX0xPQ0FMYGAuIFRoZXJlIGFyZSBhbHNvCj4gK2BgU1lN X0xfR0xPQkFMYGAgYW5kIGBgU1lNX0xfV0VBS2BgLiBBbGwgYXJlIGludGVuZGVkIHRvIGRlbm90 ZSBsaW5rYWdlIG9mIGEKPiArc3ltYm9sIG1hcmtlZCBieSB0aGVtLiBUaGV5IGFyZSB1c2VkIGVp dGhlciBpbiBgYF9MQUJFTGBgIHZhcmlhbnRzIG9mIHRoZQo+ICtlYXJsaWVyIG1hY3Jvcywgb3Ig aW4gYGBTWU1fU1RBUlRgYC4KPiArCj4gKwo+ICtPdmVycmlkaW5nIE1hY3Jvcwo+ICt+fn5+fn5+ fn5+fn5+fn5+fgo+ICtBcmNoaXRlY3R1cmUgY2FuIGFsc28gb3ZlcnJpZGUgYW55IG9mIHRoZSBt YWNyb3MgaW4gdGhlaXIgb3duCgoiT3RoZXIgYXJjaGl0ZWN0dXJlcy4uLiAiCgo+ICtgYGFzbS9s aW5rYWdlLmhgYCwgaW5jbHVkaW5nIG1hY3JvcyBzcGVjaWZ5aW5nIHRoZSB0eXBlIG9mIGEgc3lt Ym9sCj4gKyhgYFNZTV9UX0ZVTkNgYCwgYGBTWU1fVF9PQkpFQ1RgYCwgYW5kIGBgU1lNX1RfTk9O RWBgKS4gIEFzIGV2ZXJ5IG1hY3JvCj4gK2Rlc2NyaWJlZCBpbiB0aGlzIGZpbGUgaXMgc3Vycm91 bmRlZCBieSBgYCNpZmRlZmBgICsgYGAjZW5kaWZgYCwgaXQgaXMgZW5vdWdoCj4gK3RvIGRlZmlu ZSB0aGUgbWFjcm9zIGRpZmZlcmVudGx5IGluIHRoZSBhZm9yZW1lbnRpb25lZCBhcmNoaXRlY3R1 cmUtZGVwZW5kZW50Cj4gK2hlYWRlci4KClRoeC4KCi0tIApSZWdhcmRzL0dydXNzLAogICAgQm9y aXMuCgpHb29kIG1haWxpbmcgcHJhY3RpY2VzIGZvciA0MDA6IGF2b2lkIHRvcC1wb3N0aW5nIGFu ZCB0cmltIHRoZSByZXBseS4KCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fClhlbi1kZXZlbCBtYWlsaW5nIGxpc3QKWGVuLWRldmVsQGxpc3RzLnhlbnByb2pl Y3Qub3JnCmh0dHBzOi8vbGlzdHMueGVucHJvamVjdC5vcmcvbWFpbG1hbi9saXN0aW5mby94ZW4t ZGV2ZWw=