From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 9242 invoked by alias); 2 Sep 2012 11:21:05 -0000 Received: (qmail 9223 invoked by uid 22791); 2 Sep 2012 11:21:00 -0000 X-SWARE-Spam-Status: No, hits=-4.7 required=5.0 tests=AWL,BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FROM,KHOP_RCVD_TRUST,KHOP_THREADED,RCVD_IN_DNSWL_LOW,RCVD_IN_HOSTKARMA_YE X-Spam-Check-By: sourceware.org Received: from mail-vc0-f169.google.com (HELO mail-vc0-f169.google.com) (209.85.220.169) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Sun, 02 Sep 2012 11:20:42 +0000 Received: by vcbfl13 with SMTP id fl13so5278052vcb.0 for ; Sun, 02 Sep 2012 04:20:42 -0700 (PDT) Received: by 10.220.228.131 with SMTP id je3mr9656566vcb.73.1346584841966; Sun, 02 Sep 2012 04:20:41 -0700 (PDT) MIME-Version: 1.0 Received: by 10.220.152.194 with HTTP; Sun, 2 Sep 2012 04:20:01 -0700 (PDT) In-Reply-To: <83sjb2q2yw.fsf@gnu.org> References: <503DCEE4.2010706@mentor.com> <83sjb2q2yw.fsf@gnu.org> From: Hui Zhu Date: Sun, 02 Sep 2012 11:21:00 -0000 Message-ID: Subject: Re: [PATCH] target attributes [5/5] doc To: Eli Zaretskii Cc: Hui Zhu , gdb-patches@sourceware.org, stan_shebs@mentor.com Content-Type: multipart/mixed; boundary=14dae9ccd5a22a549404c8b6374a X-IsSubscribed: yes Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2012-09/txt/msg00003.txt.bz2 --14dae9ccd5a22a549404c8b6374a Content-Type: text/plain; charset=ISO-8859-1 Content-length: 16829 Oops. I am so sorry that I post a old version of this patch. So sorry about that. The attachment is the right version. Please help me with it. Thanks, Hui On Sat, Sep 1, 2012 at 3:24 AM, Eli Zaretskii wrote: >> Date: Wed, 29 Aug 2012 16:12:20 +0800 >> From: Hui Zhu >> >> This patch add doc about target attributes in the doc. > > Thanks. > >> +If @var{n} is the number of trace state variable, Push the value of > ^^^^^^^^^^^^^^^^^^^^^^^ > "of a trace state variable". Also, "push", with a lower-case 'p'. > >> +If @var{n} is the id of target attribute, push the value of target >> +attribute @var{n} and do the type convert according the type of >> +target attribute @var{n} and the stack type. > > If @var{n} is the id of a target attribute, push the value of that > attribute after converting the type of the attribute according to > the stack type. > > I have a question: what does it mean for a number N to be "the id of > an attribute"? Obviously, some context is missing here, because I > fail to understand how a number can identify an attribute. > >> @item @code{setv} (0x2d) @var{n}: @result{} @var{v} >> -Set trace state variable number @var{n} to the value found on the top >> +If @var{n} is the number of trace state variable, set trace state >> +variable number @var{n} to the value found on the top >> of the stack. The stack is unchanged, so that the value is readily > > I don't understand the reason for the change. The new text seems to > say the same as the old one (and the old one was more clear). > >> +If @var{n} is the id of target attribute, do the type convert according >> +the type of target attribute @var{n} and the stack type, set to >> +target attribute @var{n}. > > If you leave the old text, this addition will be unnecessary. > > If you want to point out that the value at stack top can identify a > trace variable or an attribute, then just say so: > > The value at stack top can identify either a trace variable or an > attribute. > >> +@kindex maint load-target-attributes >> +@item maint load-target-attributes @var{filename} >> +Load @ref{Target Attributes} from a XML file. >> + >> +@kindex maint clear-target-attributes >> +@item maint clear-target-attributes >> +Remove all @ref{Target Attributes}. > > Why is this command needed? Shouldn't GDB load the attributes > automatically? > >> +The value of the variable is @var{value}. This will be unlongest value > ^^^^^^^^^ > I believe you meant "ulongest". > > Also, I don't think we mention "ulongest" anywhere else in the > manual. Would it be good enough to use "unsigned integer" instead? > >> +that is convert from the current value of the target attribute. > ^^^^^^^ > "converted" > >> +Or hardware register of this target attribute is busy that cannot >> +access. > > This is not a sentence. I believe you meant something like this: > > This would occur, for example, if the user is examining a trace > frame in which the requested target attribute was not collected, or > if the hardware register holding this target attribute is busy and > cannot be accessed. > >> +Set unlongest value that is convert from the value that want set to > ^^^^^^^^^ ^^^^^^^ >> +target attribute to target attribute @var{var}. > > Same typos; and see the comments above about "ulongest". > > Also, "that want set to target attribute to target attribute" is not > correct English. What did you want to say there? > >> +Some of @value{GDBN} target have some special attributes that can be >> +access. > ^^^^^^ > "accessed" > >> +@value{GDBN} can access target attributes directly or through agent >> +code that running in target. > ^^^^^^^^^^^^ > "that is running" > >> +A target attributes will include name, id, type, access mode, >> +the breakpoint type that it support, the breakpoint address that >> +it support. > > This needs to be rephrased, but I need to understand what you meant > first. I can understand about the name, ID, type, and access mode. > But what does "the breakpoint type that it supports" mean? Same > question about "the breakpoint address that it supports". What are > these about? > > Based on the example you provide further down, I'm guessing that the > former is a series of YES/NO values for the various breakpoint types > we have in GDB, where YES means that kind of breakpoint is supported. > While the latter gives the ranges of addresses for this attribute. > But I still don't understand the semantics: what does it mean to say > that attribute 'foo' "supports software-breakpoint", and what do the > address ranges mean? > >> +@menu >> +* Retrieving Target Attributes:: How target attributes are fetched from a target. >> +* Format of Target Attributes:: The contents of a target attributes list. >> +* Access Target Attributes:: Access target attributes. >> +* Example of Target Attributes:: Example of target attributes in gdbserver. >> +@end menu > > This menu is malformed. Please format it like we do with other menus > in the manual, including alignment and line length. > >> +Target attributes can be read from the target automatically. >> +The default behavior is to read the attributes from the target. > > Does the second sentence mean that automatic reading is the default? > Or does it mean something else? > >> +@value{GDBN} retrieves it via the remote protocol using > ^^ > "the attributes" ("it" is just one thing, not many). > >> + The contents of it are >> +an XML document, of the form described in >> +@ref{Format of Target Attributes}. > > I would rephrase: > > The attributes are received in the form of an XML document described > in @ref{Format of Target Attributes}. > >> +Here is a simple target attributes list that include two target >> +attributes ``foo'' and ``bar'': > > Please use @samp instead of ``...''. > >> +@smallexample >> + >> + >> + >> + >> + >> + >> + > > This line is too long, please break it into 2. > >> + >> + > > Likewise. > >> + > > Likewise. > >> +This define the @samp{name}, @samp{id} , @samp{type} > ^^^^^^ > "defines" > >> +and @samp{target-only-cond-check} of a target attribute. > > What is target-only-cond-check? It was never mentioned before. > > I think this whole sentence should be removed, it doesn't add anything > to the XML fragment you show. > >> +If @samp{target-only-cond-check} set to @samp{yes}, GDB will not check the > ^^^ > @value{GDBN} > >> + If @samp{target-only-cond-check} not >> +define, it means @samp{no}. > > If @samp{target-only-cond-check} is not defines, it defaults to > @samp{no}. > >> +@smallexample >> + >> +@end smallexample > > What does this example show? > >> +This define the agent access mode of a target attribute. > ^^^^^^ > "defines" > > Also, please have a ":" at the end of this sentence, to indicate that > the explanation refers to the next example. > >> +If @samp{read} or @samp{write} not define, it means @samp{no}. > > This sentence should follow the example. Please rephrase it: > > If neither @samp{read} nor @samp{write} are defined, they both > default to @samp{no}. > >> +This define the GDB access mode of a target attribute. > ^^^ > @value{GDBN}. > > Also, please make the same changes as for the agent access mode. > >> +If @samp{read} or @samp{write} not define, it means @samp{no}. >> +@smallexample >> + >> +@end smallexample > > Likewise. > >> +This define the breakpoint type that a target attribute can be used in >> +the condition or commands of these type breakpoints. >> +If a type is not defined, it means @samp{no}. >> +@smallexample >> + >> +@end smallexample >> + >> +This define the breakpoint address range that a target attribute can be used >> +in the condition or commands of the breakpoints that inside this address range. > > As I mentioned above, this business with breakpoint support is > unclear. What does it mean to "use an attribute in the condition or > commands for the breakpoint"? > >> +If not define any address, this target attribute support any address. > > This seems to be contrary to the other defaults, which are > restrictive, while this one is permissive. Why the difference? > >> +@node Access Target Attributes >> +@section Access Target Attributes >> +@cindex access target attributes > > Please use "target attribute access" instead. > >> +@item info target-attributes >> +Status of target attributes. >> + >> +@item Access target attributes in agent code. >> +Target attributes can be accessed in breakpoint condition and actions. >> + >> +@item Access target attributes in GDB. >> +Target attributes can be accessed in print commands and expressions as >> +if they were convenience variables. >> + >> +@end table > > Sorry, I don't understand this description. Are you describing some > kind of display of target attributes? If so, an example would help a > lot. > >> +@node Example of Target Attributes >> +@section Example of Target Attributes >> +@cindex example of target attributes > > The rest of the text seems to indicate that this is not an example, > but an optional feature. > >> +Gdbserver include target attributes to count how many times does each >> +breakpoint pass. >> + >> +This function will not be built in default. To build it with gdbsrver, >> +need add @code{--enable-break-count} in the config command. >> + >> +Gdbserver include three target attributes: >> + >> +@table @samp >> + >> +@item $break_count_on >> +This is the switch of the breakpoints pass count function. >> +The default value of it is 0, the breakpoints pass count function is closed. >> +If it is set to 1, function is opened and the count value of all >> +the breakpoints will reset to 0 when inferior stop and continue again. >> +If it is set to 2, function is opened and the count value will not be reset. >> + >> +@item $break_count_select >> +When count function is opened, set the address of breakpoint to >> +$break_count_select to select which count value you want to access >> +in $break_count_val. >> + >> +@ $break_count_val >> +It will return the value of a breakpoint pass count if access it from GDB. >> +When access it inside the condition of a breakpoint, its value is the value >> +of this breakpoint pass count. >> + >> +@end table >> + >> +Following example show how to use breakpoints pass count function in condition: >> + >> +@smallexample >> +(gdb) target remote :1234 >> +Remote debugging using :1234 >> +Reading symbols from /lib64/ld-linux-x86-64.so.2...(no debugging symbols found)...done. >> +Loaded symbols for /lib64/ld-linux-x86-64.so.2 >> +0x00007ffff7ddb6b0 in ?? () from /lib64/ld-linux-x86-64.so.2 >> +(gdb) list >> +1 int >> +2 main() >> +3 @{ >> +4 int a = 1; >> +5 >> +6 while (1) >> +7 printf("%d\n", a++); >> +8 @} >> +(gdb) set $break_count_on=1 >> +(gdb) b 7 >> +Breakpoint 1 at 0x400503: file 1.c, line 7. >> +(gdb) condition 1 ($break_count_val == 10) >> +(gdb) c >> +Continuing. >> + >> +Breakpoint 1, main () at 1.c:7 >> +7 printf("%d\n", a++); >> + >> +In gdbserver part, you can see that: >> +Process /home/teawater/tmp/a.out created; pid = 7937 >> +Listening on port 1234 >> +Remote debugging from host 127.0.0.1 >> +Found breakpoint condition. >> +Found breakpoint condition. >> +Found breakpoint condition. >> +1 >> +2 >> +3 >> +4 >> +5 >> +6 >> +7 >> +8 >> +9 >> +@end smallexample >> + >> +Following example show how to use breakpoints pass count show a address >> +passed times: >> + >> +@smallexample >> +(gdb) set non-stop on >> +(gdb) set target-async on >> +(gdb) target remote :1234 >> +Remote debugging using :1234 >> +[New Thread 7944] >> +(gdb) >> +[Thread 7944] #1 stopped. >> +0x00007ffff7ddb6b0 in ?? () >> +set $break_count_on=2 >> +(gdb) list >> +1 int >> +2 main() >> +3 @{ >> +4 int a = 1; >> +5 >> +6 while (1) >> +7 printf("%d\n", a++); >> +8 @} >> +(gdb) b 7 >> +Breakpoint 1 at 0x400503: file 1.c, line 7. >> +(gdb) condition 1 ($break_count_val == 0) >> +(gdb) c& >> +Continuing. >> +(gdb) p $break_count_val >> +$1 = 96965 >> +(gdb) p $break_count_val >> +$2 = 148548 >> +@end smallexample >> + >> @node Operating System Information >> @appendix Operating System Information >> @cindex operating system information > > I rephrased all this as below: > > Gdbserver includes an optional feature that uses target attributes > in order to count how many times does each breakpoint is hit. > > This feature will not be built by default. To build it with gdbsrver, > you need to use the @option{--enable-break-count} option to the > @command{configure} script. > > When built with this feature, gdbserver will support three target > attributes: > > @table @samp > > @item $break_count_on > This attribute activates and deactivates the breakpoints pass-count feature. > Its default value is 0, which means the breakpoints pass-count > feature is inactive. > If $break_count_on is set to 1, the feature is active. The count > value of every breakpoint will be reset to 0 when the inferior stops. > If $break_count_on is set to 2, the feature is active, but the count > value will not be reset when the inferior stops. > > My comments are that using 0, 1, and 2 for $break_count_on is not very > helpful; better use some more mnemonic values. > > @item $break_count_select > When the pass-count feature is active, set the address of breakpoint to > $break_count_select to select which count value you want to access > in $break_count_val. > > Not clear, please elaborate or give an example. > > @item $break_count_val > This attribute holds the value of a breakpoint pass-count. It is > useful for accessing the value it from @value{GDBN}. > When access is from inside the condition of a breakpoint, its value > is the pass-count of this breakpoint. > @end table > > The following example shows how to use breakpoints pass-count > in conditions: > > @smallexample > (gdb) target remote :1234 > Remote debugging using :1234 > Reading symbols from /lib64/ld-linux-x86-64.so.2...(no debugging symbols found)...done. > Loaded symbols for /lib64/ld-linux-x86-64.so.2 > 0x00007ffff7ddb6b0 in ?? () from /lib64/ld-linux-x86-64.so.2 > (gdb) list > 1 int > 2 main() > 3 @{ > 4 int a = 1; > 5 > 6 while (1) > 7 printf("%d\n", a++); > 8 @} > (gdb) set $break_count_on=1 > (gdb) b 7 > Breakpoint 1 at 0x400503: file 1.c, line 7. > (gdb) condition 1 ($break_count_val == 10) > (gdb) c > Continuing. > > Breakpoint 1, main () at 1.c:7 > 7 printf("%d\n", a++); > @end smallexample > > In gdbserver part, you can see that: > > @smallexample > Process /home/teawater/tmp/a.out created; pid = 7937 > Listening on port 1234 > Remote debugging from host 127.0.0.1 > Found breakpoint condition. > Found breakpoint condition. > Found breakpoint condition. > 1 > 2 > 3 > 4 > 5 > 6 > 7 > 8 > 9 > @end smallexample > > The following example show how to use breakpoint pass-count to show > how many times an address was passed: > > @smallexample > (gdb) set non-stop on > (gdb) set target-async on > (gdb) target remote :1234 > Remote debugging using :1234 > [New Thread 7944] > (gdb) > [Thread 7944] #1 stopped. > 0x00007ffff7ddb6b0 in ?? () > set $break_count_on=2 > (gdb) list > 1 int > 2 main() > 3 @{ > 4 int a = 1; > 5 > 6 while (1) > 7 printf("%d\n", a++); > 8 @} > (gdb) b 7 > Breakpoint 1 at 0x400503: file 1.c, line 7. > (gdb) condition 1 ($break_count_val == 0) > (gdb) c& > Continuing. > (gdb) p $break_count_val > $1 = 96965 > (gdb) p $break_count_val > $2 = 148548 > @end smallexample --14dae9ccd5a22a549404c8b6374a Content-Type: text/plain; charset=US-ASCII; name="target_attribute_doc.txt" Content-Disposition: attachment; filename="target_attribute_doc.txt" Content-Transfer-Encoding: base64 X-Attachment-Id: f_h6m1tha30 Content-length: 17463 LS0tIGEvZG9jL2FnZW50ZXhwci50ZXhpCisrKyBiL2RvYy9hZ2VudGV4cHIu dGV4aQpAQCAtNDUwLDggKzQ1MCwxMiBAQCBhbGlnbm1lbnQgd2l0aGluIHRo ZSBieXRlY29kZSBzdHJlYW07IHRoCiByZWdpc3RlciBudW1iZXIgb25lIGJ5 dGUgYXQgYSB0aW1lLgogCiBAaXRlbSBAY29kZXtnZXR2fSAoMHgyYykgQHZh cntufTogQHJlc3VsdHt9IEB2YXJ7dn0KLVB1c2ggdGhlIHZhbHVlIG9mIHRy YWNlIHN0YXRlIHZhcmlhYmxlIG51bWJlciBAdmFye259LCB3aXRob3V0IHNp Z24KLWV4dGVuc2lvbi4KK1B1c2ggdGhlIHZhbHVlIG9mIHRyYWNlIHN0YXRl IHZhcmlhYmxlIG9yIHRhcmdldCBhdHRyaWJ1dGUgbnVtYmVyCitAdmFye259 LgorCitJZiBAdmFye259IGlzIGEgdHJhY2Ugc3RhdGUgdmFyaWFibGUsIHRo ZSB2YWx1ZSBpcyBub3Qgc2lnbi1leHRlbmRlZC4KK0lmIEB2YXJ7bn0gaXMg dGhlIGlkIG9mIGEgdGFyZ2V0IGF0dHJpYnV0ZSwgaXQgaXMgdHlwZS1jb252 ZXJ0ZWQKK2FjY29yZGluZyB0byB0aGUgdHlwZSBvZiB0aGUgdGFyZ2V0IGF0 dHJpYnV0ZS4uCiAKIFRoZSB2YXJpYWJsZSBudW1iZXIgQHZhcntufSBpcyBl bmNvZGVkIGFzIGEgMTYtYml0IHVuc2lnbmVkIGludGVnZXIKIGltbWVkaWF0 ZWx5IGZvbGxvd2luZyB0aGUgQGNvZGV7Z2V0dn0gYnl0ZWNvZGUuICBJdCBp cyBhbHdheXMgc3RvcmVkIG1vc3QKQEAgLTQ2MiwxMCArNDY2LDE1IEBAIGFs aWdubWVudCB3aXRoaW4gdGhlIGJ5dGVjb2RlIHN0cmVhbTsgdGgKIHJlZ2lz dGVyIG51bWJlciBvbmUgYnl0ZSBhdCBhIHRpbWUuCiAKIEBpdGVtIEBjb2Rl e3NldHZ9ICgweDJkKSBAdmFye259OiBAcmVzdWx0e30gQHZhcnt2fQotU2V0 IHRyYWNlIHN0YXRlIHZhcmlhYmxlIG51bWJlciBAdmFye259IHRvIHRoZSB2 YWx1ZSBmb3VuZCBvbiB0aGUgdG9wCi1vZiB0aGUgc3RhY2suICBUaGUgc3Rh Y2sgaXMgdW5jaGFuZ2VkLCBzbyB0aGF0IHRoZSB2YWx1ZSBpcyByZWFkaWx5 Ci1hdmFpbGFibGUgaWYgdGhlIGFzc2lnbm1lbnQgaXMgcGFydCBvZiBhIGxh cmdlciBleHByZXNzaW9uLiAgVGhlCi1oYW5kbGluZyBvZiBAdmFye259IGlz IGFzIGRlc2NyaWJlZCBmb3IgQGNvZGV7Z2V0dn0uCitJZiBAdmFye259IGlz IHRoZSBudW1iZXIgb2YgYSB0cmFjZSBzdGF0ZSB2YXJpYWJsZSwgc2V0IHRo YXQgdmFyaWFibGUKK3RvIHRoZSB2YWx1ZSBmb3VuZCBvbiB0aGUgdG9wIG9m IHRoZSBzdGFjay4gIFRoZSBzdGFjayBpcyB1bmNoYW5nZWQsCitzbyB0aGF0 IHRoZSB2YWx1ZSBpcyByZWFkaWx5IGF2YWlsYWJsZSBpZiB0aGUgYXNzaWdu bWVudCBpcyBwYXJ0IG9mIGEKK2xhcmdlciBleHByZXNzaW9uLiAgVGhlIGhh bmRsaW5nIG9mIEB2YXJ7bn0gaXMgYXMgZGVzY3JpYmVkIGZvcgorQGNvZGV7 Z2V0dn0uCisKK0lmIEB2YXJ7bn0gaXMgdGhlIGlkIG9mIGEgdGFyZ2V0IGF0 dHJpYnV0ZSwgZG8gdGhlIHR5cGUgY29udmVyc2lvbgorYWNjb3JkaW5nIHRv IHRoZSB0eXBlIG9mIHRhcmdldCBhdHRyaWJ1dGUgQHZhcntufSwgYW5kIHNl dCB0YXJnZXQKK2F0dHJpYnV0ZSBAdmFye259IHRvIHRoZSByZXN1bHQuCiAK IEBpdGVtIEBjb2Rle3RyYWNlfSAoMHgwYyk6IEB2YXJ7YWRkcn0gQHZhcntz aXplfSBAcmVzdWx0e30KIFJlY29yZCB0aGUgY29udGVudHMgb2YgdGhlIEB2 YXJ7c2l6ZX0gYnl0ZXMgYXQgQHZhcnthZGRyfSBpbiBhIHRyYWNlCi0tLSBh L2RvYy9nZGIudGV4aW5mbworKysgYi9kb2MvZ2RiLnRleGluZm8KQEAgLTE3 OSw2ICsxNzksNyBAQCBzb2Z0d2FyZSBpbiBnZW5lcmFsLiAgV2Ugd2lsbCBt aXNzIGhpbS4KICogQWdlbnQgRXhwcmVzc2lvbnM6OiAgICAgICAgICAgVGhl IEdEQiBBZ2VudCBFeHByZXNzaW9uIE1lY2hhbmlzbQogKiBUYXJnZXQgRGVz Y3JpcHRpb25zOjogICAgICAgICBIb3cgdGFyZ2V0cyBjYW4gZGVzY3JpYmUg dGhlbXNlbHZlcyB0bwogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBAdmFsdWV7R0RCTn0KKyogVGFyZ2V0IEF0dHJpYnV0ZXM6OiAgICAgICAg ICAgQ29udHJvbGxpbmcgYXR0cmlidXRlcyBvZiB0aGUgdGFyZ2V0CiAqIE9w ZXJhdGluZyBTeXN0ZW0gSW5mb3JtYXRpb246OiBHZXR0aW5nIGFkZGl0aW9u YWwgaW5mb3JtYXRpb24gZnJvbQogICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgdGhlIG9wZXJhdGluZyBzeXN0ZW0KICogVHJhY2UgRmlsZSBG b3JtYXQ6OgkJR0RCIHRyYWNlIGZpbGUgZm9ybWF0CkBAIC0zNDkzMiw2ICsz NDkzMywxNCBAQCBJZiBzZWN0aW9uIHdhcyBub3Qgc3BlY2lmaWVkLCB0aGUg c2VjdGlvCiBpcyBhbHNvIHByaW50ZWQuICBGb3IgZHluYW1pY2FsbHkgbGlu a2VkIGV4ZWN1dGFibGVzLCB0aGUgbmFtZSBvZgogZXhlY3V0YWJsZSBvciBz aGFyZWQgbGlicmFyeSBjb250YWluaW5nIHRoZSBzeW1ib2wgaXMgcHJpbnRl ZCBhcyB3ZWxsLgogCitAa2luZGV4IG1haW50IGxvYWQtdGFyZ2V0LWF0dHJp YnV0ZXMKK0BpdGVtIG1haW50IGxvYWQtdGFyZ2V0LWF0dHJpYnV0ZXMgQHZh cntmaWxlbmFtZX0KK0xvYWQgQHJlZntUYXJnZXQgQXR0cmlidXRlc30gZnJv bSBhbiBYTUwgZmlsZS4KKworQGtpbmRleCBtYWludCBjbGVhci10YXJnZXQt YXR0cmlidXRlcworQGl0ZW0gbWFpbnQgY2xlYXItdGFyZ2V0LWF0dHJpYnV0 ZXMKK1JlbW92ZSBhbGwgQHJlZntUYXJnZXQgQXR0cmlidXRlc30uCisKIEBl bmQgdGFibGUKIAogVGhlIGZvbGxvd2luZyBjb21tYW5kIGlzIHVzZWZ1bCBm b3Igbm9uLWludGVyYWN0aXZlIGludm9jYXRpb25zIG9mCkBAIC0zNjYxMSw2 ICszNjYyMCwxMSBAQCBUaGVzZSBhcmUgdGhlIGN1cnJlbnRseSBkZWZpbmVk IHN0dWIgZmVhCiBAdGFiIEBzYW1wey19CiBAdGFiIFllcwogCitAaXRlbSBA c2FtcHtxWGZlcjp0YXJnZXQtYXR0cmlidXRlczpyZWFkfQorQHRhYiBObwor QHRhYiBAc2FtcHstfQorQHRhYiBZZXMKKwogQGl0ZW0gQHNhbXB7cVhmZXI6 bGlicmFyaWVzOnJlYWR9CiBAdGFiIE5vCiBAdGFiIEBzYW1wey19CkBAIC0z Njc2NSw2ICszNjc3OSw5IEBAIFRoZSByZW1vdGUgc3R1YiB1bmRlcnN0YW5k cyB0aGUgQHNhbXB7cVgKIFRoZSByZW1vdGUgc3R1YiB1bmRlcnN0YW5kcyB0 aGUgQHNhbXB7cVhmZXI6ZmVhdHVyZXM6cmVhZH0gcGFja2V0CiAoQHB4cmVm e3FYZmVyIHRhcmdldCBkZXNjcmlwdGlvbiByZWFkfSkuCiAKK0BpdGVtIHFY ZmVyOnRhcmdldC1hdHRyaWJ1dGVzOnJlYWQKK1RoZSByZW1vdGUgc3R1YiB1 bmRlcnN0YW5kcyB0aGUgQHNhbXB7cVhmZXI6dGFyZ2V0LWF0dHJpYnV0ZXM6 cmVhZH0gcGFja2V0KEBweHJlZntxWGZlciB0YXJnZXQgYXR0cmlidXRlcyBy ZWFkfSkuCisKIEBpdGVtIHFYZmVyOmxpYnJhcmllczpyZWFkCiBUaGUgcmVt b3RlIHN0dWIgdW5kZXJzdGFuZHMgdGhlIEBzYW1we3FYZmVyOmxpYnJhcmll czpyZWFkfSBwYWNrZXQKIChAcHhyZWZ7cVhmZXIgbGlicmFyeSBsaXN0IHJl YWR9KS4KQEAgLTM3MDIyLDYgKzM3MDM5LDE1IEBAIGFsd2F5cyBsb2FkZWQg ZnJvbSB0aGUgQHNhbXB7dGFyZ2V0LnhtbH0KIFRoaXMgcGFja2V0IGlzIG5v dCBwcm9iZWQgYnkgZGVmYXVsdDsgdGhlIHJlbW90ZSBzdHViIG11c3QgcmVx dWVzdCBpdCwKIGJ5IHN1cHBseWluZyBhbiBhcHByb3ByaWF0ZSBAc2FtcHtx U3VwcG9ydGVkfSByZXNwb25zZSAoQHB4cmVme3FTdXBwb3J0ZWR9KS4KIAor QGl0ZW0gcVhmZXI6dGFyZ2V0LWF0dHJpYnV0ZXM6cmVhZDpAdmFye29mZnNl dH0sQHZhcntsZW5ndGh9CitAYW5jaG9ye3FYZmVyIHRhcmdldCBhdHRyaWJ1 dGVzIHJlYWR9CitBY2Nlc3MgdGhlIHRhcmdldCBhdHRyaWJ1dGVzLiAgQHhy ZWZ7Rm9ybWF0IG9mIFRhcmdldCBBdHRyaWJ1dGVzfS4gIFRoZQorYW5uZXgg cGFydCBvZiB0aGUgZ2VuZXJpYyBAc2FtcHtxWGZlcn0gcGFja2V0IG11c3Qg YmUgZW1wdHkKKyhAcHhyZWZ7cVhmZXIgcmVhZH0pLgorCitUaGlzIHBhY2tl dCBpcyBub3QgcHJvYmVkIGJ5IGRlZmF1bHQ7IHRoZSByZW1vdGUgc3R1YiBt dXN0IHJlcXVlc3QgaXQsCitieSBzdXBwbHlpbmcgYW4gYXBwcm9wcmlhdGUg QHNhbXB7cVN1cHBvcnRlZH0gcmVzcG9uc2UgKEBweHJlZntxU3VwcG9ydGVk fSkuCisKIEBpdGVtIHFYZmVyOmxpYnJhcmllczpyZWFkOkB2YXJ7YW5uZXh9 OkB2YXJ7b2Zmc2V0fSxAdmFye2xlbmd0aH0KIEBhbmNob3J7cVhmZXIgbGli cmFyeSBsaXN0IHJlYWR9CiBBY2Nlc3MgdGhlIHRhcmdldCdzIGxpc3Qgb2Yg bG9hZGVkIGxpYnJhcmllcy4gIEB4cmVme0xpYnJhcnkgTGlzdCBGb3JtYXR9 LgpAQCAtMzcyNDksNiArMzcyNzUsMzYgQEAgVGhlIHJlbW90ZSBzZXJ2ZXIg Y3JlYXRlZCBhIG5ldyBwcm9jZXNzLgogQSBiYWRseSBmb3JtZWQgcmVxdWVz dCBvciBhbiBlcnJvciB3YXMgZW5jb3VudGVyZWQuCiBAZW5kIHRhYmxlCiAK K0BpdGVtIHFUQTpAdmFye3Zhcn0KK0BjaW5kZXggdGFyZ2V0IGF0dHJpYnV0 ZSB2YWx1ZSwgcmVtb3RlIHJlcXVlc3QKK0BjaW5kZXggQHNhbXB7cVRBfSBw YWNrZXQKK0FzayB0aGUgc3R1YiBmb3IgdGhlIHZhbHVlIG9mIHRoZSB0YXJn ZXQgYXR0cmlidXRlIGlkIEB2YXJ7dmFyfS4KKworUmVwbGllczoKK0B0YWJs ZSBAc2FtcAorQGl0ZW0gVkB2YXJ7dmFsdWV9CitUaGUgdmFsdWUgb2YgdGhl IHZhcmlhYmxlIGlzIEB2YXJ7dmFsdWV9LCBlbmNvZGVkIGluIGhleC4KKwor QGl0ZW0gVQorVGhlIHZhbHVlIG9mIHRoZSB0YXJnZXQgYXR0cmlidXRlIGlz IHVua25vd24uICBUaGlzIHdvdWxkIG9jY3VyLAorZm9yIGV4YW1wbGUsIGlm IHRoZSB1c2VyIGlzIGV4YW1pbmluZyBhIHRyYWNlIGZyYW1lIGluIHdoaWNo IHRoZQorcmVxdWVzdGVkIHRhcmdldCBhdHRyaWJ1dGUgd2FzIG5vdCBjb2xs ZWN0ZWQsIG9yIHBlcmhhcHMgdGhlCithdHRyaWJ1dGUgaXMgYXNzb2NpYXRl ZCB3aXRoIGEgaGFyZHdhcmUgcmVnaXN0ZXIgdGhhdCBpcyBub3QKK3ByZXNl bnRseSBhY2Nlc3NpYmxlLgorQGVuZCB0YWJsZQorCitAaXRlbSBRVEE6QHZh cntufTpAdmFye3ZhbHVlfQorQGNpbmRleCB0YXJnZXQgYXR0cmlidXRlIHZh bHVlLCByZW1vdGUgc2V0CitAY2luZGV4IEBzYW1we1FUQX0gcGFja2V0CitT ZXQgdGhlIHRhcmdldCBhdHRyaWJ1dGUgQHZhcnt2YXJ9IHRvIGhhdmUgdGhl IHZhbHVlIEB2YXJ7dmFsdWV9LgorUmVwbHk6CitAdGFibGUgQHNhbXAKK0Bp dGVtIE9LCitmb3Igc3VjY2VzcworQGl0ZW0gRSBAdmFye05OfQorZm9yIGFu IGVycm9yCitAZW5kIHRhYmxlCisKIEBlbmQgdGFibGUKIAogQG5vZGUgQXJj aGl0ZWN0dXJlLVNwZWNpZmljIFByb3RvY29sIERldGFpbHMKQEAgLTQwMzA5 LDYgKzQwMzY1LDI0NSBAQCB0aHJvdWdoIEBzYW1we0IzMX0uCiBUaGUgQHNh bXB7b3JnLmdudS5nZGIudGljNnguYzZ4cH0gZmVhdHVyZSBpcyBvcHRpb25h bC4gIEl0IHNob3VsZAogY29udGFpbiByZWdpc3RlcnMgQHNhbXB7VFNSfSwg QHNhbXB7SUxDfSBhbmQgQHNhbXB7UklMQ30uCiAKK0Bub2RlIFRhcmdldCBB dHRyaWJ1dGVzCitAYXBwZW5kaXggVGFyZ2V0IEF0dHJpYnV0ZXMKK0BjaW5k ZXggdGFyZ2V0IGF0dHJpYnV0ZXMKKworU29tZSBAdmFsdWV7R0RCTn0gdGFy Z2V0cyBtYXkgaGF2ZSBzb21lIHNwZWNpYWwgYXR0cmlidXRlcyB0aGF0IGFy ZQorc3BlY2lmaWMgdG8gdGhhdCB0YXJnZXQsIHN1Y2ggYXMgaGFyZHdhcmUg cmVnaXN0ZXJzLCBzb2Z0d2FyZSBmbGFncworbWFuYWdlZCBieSBhIHN0dWIg b3IgYWdlbnQsIGFuZCBzbyBvbi4gIEB2YWx1ZXtHREJOfSBjYW4gYWNjZXNz IHRhcmdldAorYXR0cmlidXRlcyBkaXJlY3RseSwgb3IgdGhyb3VnaCBhZ2Vu dCBjb2RlIHRoYXQgaXMgcnVubmluZyBvbiB0aGUKK3RhcmdldC4KKworQSB0 YXJnZXQgYXR0cmlidXRlIG1heSBpbmNsdWRlIG5hbWUsIGlkLCB0eXBlLCBh Y2Nlc3MgbW9kZSwgdGhlCiticmVha3BvaW50IHR5cGUsIGFuZCBhIGJyZWFr cG9pbnQgYWRkcmVzcy4KKworVGFyZ2V0IGF0dHJpYnV0ZXMgYXJlIHNvbGVs eSBkZWZpbmVkIGJ5IHRoZSB0YXJnZXQgYW5kIHN1cHBsaWVkIHRvCitAdmFs dWV7R0RCTn0gZHVyaW5nIGEgZGVidWdnaW5nIHNlc3Npb24uICBUaGUgdGFy Z2V0IHN1cHBsaWVzIHRoZW0gaW4KK1hNTCBmb3JtYXQsIEB2YWx1ZXtHREJO fSBtdXN0IGJlIGxpbmtlZCB3aXRoIHRoZSBFeHBhdCBsaWJyYXJ5IGluCitv cmRlciB0byB1c2UgYXR0cmlidXRlcy4gIEB4cmVme0V4cGF0fS4KKworQG1l bnUKKyogUmV0cmlldmluZyBUYXJnZXQgQXR0cmlidXRlczo6CUhvdyB0YXJn ZXQgYXR0cmlidXRlcyBhcmUgZmV0Y2hlZCBmcm9tIGEgdGFyZ2V0CisqIEZv cm1hdCBvZiBUYXJnZXQgQXR0cmlidXRlczo6CQlUaGUgY29udGVudHMgb2Yg YSB0YXJnZXQgYXR0cmlidXRlcyBsaXN0CisqIEFjY2VzcyBUYXJnZXQgQXR0 cmlidXRlczo6CQlBY2Nlc3MgdGFyZ2V0IGF0dHJpYnV0ZXMKKyogRXhhbXBs ZSBvZiBUYXJnZXQgQXR0cmlidXRlczo6CUV4YW1wbGUgb2YgdGFyZ2V0IGF0 dHJpYnV0ZXMgaW4gZ2Ric2VydmVyCitAZW5kIG1lbnUKKworQG5vZGUgUmV0 cmlldmluZyBUYXJnZXQgQXR0cmlidXRlcworQHNlY3Rpb24gUmV0cmlldmlu ZyBUYXJnZXQgQXR0cmlidXRlcworQGNpbmRleCByZXRyaWV2aW5nIHRhcmdl dCBhdHRyaWJ1dGVzCisKK1RhcmdldCBhdHRyaWJ1dGVzIGNhbiBiZSByZWFk IGZyb20gdGhlIHRhcmdldCBhdXRvbWF0aWNhbGx5LiAgVGhlCitkZWZhdWx0 IGJlaGF2aW9yIGlzIHRvIHJlYWQgdGhlIGF0dHJpYnV0ZXMgZnJvbSB0aGUg dGFyZ2V0LgorQHZhbHVle0dEQk59IHJldHJpZXZlcyBpdCB2aWEgdGhlIHJl bW90ZSBwcm90b2NvbCB1c2luZworQHNhbXB7cVhmZXI6dGFyZ2V0LWF0dHJp YnV0ZXM6cmVhZH0gcmVxdWVzdHMgKEBweHJlZntxWGZlciB0YXJnZXQKK2F0 dHJpYnV0ZXMgcmVhZH0pLiAgVGhlIGNvbnRlbnRzIGFyZSBhbiBYTUwgZG9j dW1lbnQsIGluIHRoZSBmb3JtCitkZXNjcmliZWQgYXQgQHJlZntGb3JtYXQg b2YgVGFyZ2V0IEF0dHJpYnV0ZXN9LgorCitAbm9kZSBGb3JtYXQgb2YgVGFy Z2V0IEF0dHJpYnV0ZXMKK0BzZWN0aW9uIEZvcm1hdCBvZiBUYXJnZXQgQXR0 cmlidXRlcworQGNpbmRleCBmb3JtYXQgb2YgdGFyZ2V0IGF0dHJpYnV0ZXMK KworSGVyZSBpcyBhIHNpbXBsZSB0YXJnZXQgYXR0cmlidXRlcyBsaXN0IHRo YXQgaW5jbHVkZSB0d28gdGFyZ2V0CithdHRyaWJ1dGVzIGBgZm9vJycgYW5k IGBgYmFyJyc6CisKK0BzbWFsbGV4YW1wbGUKKzx0YXJnZXQtYXR0cmlidXRl cz4KKwk8dGFyZ2V0LWF0dHJpYnV0ZSBuYW1lPSJmb28iIGlkPSIxIiB0eXBl PSJpbnQ4IiA+CisJCTxhY2Nlc3M+CisJCQk8YWdlbnQgcmVhZD0ieWVzIiB3 cml0ZT0ibm8iLz4KKwkJCTxnZGIgd3JpdGU9InllcyIgcmVhZD0ieWVzIi8+ CisJCTwvYWNjZXNzPgorCQk8c3VwcG9ydCBzb2Z0d2FyZS1icmVha3BvaW50 PSJ5ZXMiIGhhcmR3YXJlLWJyZWFrcG9pbnQ9InllcyIgaGFyZHdhcmUtd2F0 Y2hwb2ludD0ieWVzIiB0cmFjZXBvaW50PSJ5ZXMiLz4KKwkJPGFkZHJlc3Nl cz4KKwkJCTxhZGRyZXNzIHN0YXJ0PSIweDEyMyIgZW5kPSIweDQ1NiIgLz4K KwkJCTxhZGRyZXNzIHN0YXJ0PSIweDc4OSIgZW5kPSIweDExMTEiIC8+CisJ CTwvYWRkcmVzc2VzPgorCTwvdGFyZ2V0LWF0dHJpYnV0ZT4KKwk8dGFyZ2V0 LWF0dHJpYnV0ZSBuYW1lPSJiYXIiIGlkPSIyIiB0eXBlPSJpbnQzMiIgdGFy Z2V0LW9ubHktY29uZC1jaGVjaz0ieWVzIj4KKwkJPGFjY2Vzcz4KKwkJCTxh Z2VudCByZWFkPSJ5ZXMiIHdyaXRlPSJubyIvPgorCQkJPGdkYiByZWFkPSJ5 ZXMiLz4KKwkJPC9hY2Nlc3M+CisJCTxzdXBwb3J0IHNvZnR3YXJlLWJyZWFr cG9pbnQ9InllcyIgaGFyZHdhcmUtYnJlYWtwb2ludD0ieWVzIiB0cmFjZXBv aW50PSJ5ZXMiLz4KKwk8L3RhcmdldC1hdHRyaWJ1dGU+Cis8L3RhcmdldC1h dHRyaWJ1dGVzPgorQGVuZCBzbWFsbGV4YW1wbGUKKworVGhpcyBkZWZpbmVz IHRoZSBAc2FtcHtuYW1lfSwgQHNhbXB7aWR9ICwgQHNhbXB7dHlwZX0KK2Fu ZCBAc2FtcHt0YXJnZXQtb25seS1jb25kLWNoZWNrfSBvZiBhIHRhcmdldCBh dHRyaWJ1dGUuCitUaGUgdHlwZSBjYW4gYmUgQHNhbXB7aW50OH0sIEBzYW1w e3VpbnQ4fSwgQHNhbXB7aW50MTZ9LCBAc2FtcHt1aW50MTZ9LAorQHNhbXB7 aW50MzJ9LCBAc2FtcHt1aW50MzJ9LCBAc2FtcHtpbnQ2NH0gb3IgQHNhbXB7 dWludDY0fS4KK0lmIEBzYW1we3RhcmdldC1vbmx5LWNvbmQtY2hlY2t9IHNl dCB0byBAc2FtcHt5ZXN9LCBHREIgd2lsbCBub3QgY2hlY2sgdGhlCitjb25k aXRpb24gb2YgYnJlYWtwb2ludCBpbiBpdHMgc2lkZS4gIElmIEBzYW1we3Rh cmdldC1vbmx5LWNvbmQtY2hlY2t9IG5vdAorZGVmaW5lLCBpdCBtZWFucyBA c2FtcHtub30uCisKK0BzbWFsbGV4YW1wbGUKKzx0YXJnZXQtYXR0cmlidXRl IG5hbWU9ImZvbyIgaWQ9IjEiIHR5cGU9ImludDgiID4KK0BlbmQgc21hbGxl eGFtcGxlCisKK1RoaXMgZGVmaW5lcyB0aGUgYWdlbnQgYWNjZXNzIG1vZGUg b2YgYSB0YXJnZXQgYXR0cmlidXRlLgorSWYgQHNhbXB7cmVhZH0gb3IgQHNh bXB7d3JpdGV9IGlzIG5vdCBkZWZpbmVkLCBpdCBtZWFucyBAc2FtcHtub30u CisKK0BzbWFsbGV4YW1wbGUKKzxhZ2VudCByZWFkPSJ5ZXMiIHdyaXRlPSJu byIvPgorQGVuZCBzbWFsbGV4YW1wbGUKKworVGhpcyBkZWZpbmVzIHRoZSBH REIgYWNjZXNzIG1vZGUgb2YgYSB0YXJnZXQgYXR0cmlidXRlLgorSWYgQHNh bXB7cmVhZH0gb3IgQHNhbXB7d3JpdGV9IGlzIG5vdCBkZWZpbmVkLCBpdCBt ZWFucyBAc2FtcHtub30uCisKK0BzbWFsbGV4YW1wbGUKKzxnZGIgd3JpdGU9 InllcyIgcmVhZD0ieWVzIi8+CitAZW5kIHNtYWxsZXhhbXBsZQorCitUaGlz IGRlZmluZXMgdGhlIGJyZWFrcG9pbnQgdHlwZSB0aGF0IGEgdGFyZ2V0IGF0 dHJpYnV0ZSBjYW4gYmUgdXNlZAoraW4gdGhlIGNvbmRpdGlvbiBvciBjb21t YW5kcyBvZiB0aGVzZSB0eXBlIGJyZWFrcG9pbnRzLiAgSWYgYSB0eXBlIGlz Citub3QgZGVmaW5lZCwgaXQgbWVhbnMgQHNhbXB7bm99LgorCitAc21hbGxl eGFtcGxlCis8c3VwcG9ydCBzb2Z0d2FyZS1icmVha3BvaW50PSJ5ZXMiIGhh cmR3YXJlLWJyZWFrcG9pbnQ9InllcyIgaGFyZHdhcmUtd2F0Y2hwb2ludD0i eWVzIiB0cmFjZXBvaW50PSJ5ZXMiLz4KK0BlbmQgc21hbGxleGFtcGxlCisK K1RoaXMgZGVmaW5lIHRoZSBicmVha3BvaW50IGFkZHJlc3MgcmFuZ2UgdGhh dCBhIHRhcmdldCBhdHRyaWJ1dGUgY2FuCitiZSB1c2VkIGluIHRoZSBjb25k aXRpb24gb3IgY29tbWFuZHMgb2YgdGhlIGJyZWFrcG9pbnRzIHRoYXQgYXJl CitpbnNpZGUgdGhpcyBhZGRyZXNzIHJhbmdlLiAgSWYgYWRkcmVzcyBpcyBk ZWZpbmVkLCB0aGlzIHRhcmdldAorYXR0cmlidXRlIHN1cHBvcnRzIGFueSBh ZGRyZXNzLgorCitAc21hbGxleGFtcGxlCis8YWRkcmVzc2VzPgorCTxhZGRy ZXNzIHN0YXJ0PSIweDEyMyIgZW5kPSIweDQ1NiIgLz4KKwk8YWRkcmVzcyBz dGFydD0iMHg3ODkiIGVuZD0iMHgxMTExIiAvPgorPC9hZGRyZXNzZXM+CitA ZW5kIHNtYWxsZXhhbXBsZQorCitAbm9kZSBBY2Nlc3MgVGFyZ2V0IEF0dHJp YnV0ZXMKK0BzZWN0aW9uIEFjY2VzcyBUYXJnZXQgQXR0cmlidXRlcworQGNp bmRleCBhY2Nlc3MgdGFyZ2V0IGF0dHJpYnV0ZXMKKworVGFyZ2V0IGF0dHJp YnV0ZXMgbWF5IGJlIHVzZWQgaW4gYnJlYWtwb2ludCBjb25kaXRpb25zIGFu ZCBhY3Rpb25zLAorYXMgd2VsbCBhcyBiZWluZyBpbmNsdWRlZCBpbiBleHBy ZXNzaW9ucyBhbmQgcHJpbnQgY29tbWFuZHMuICBUaGUKK3N5bnRheCBpcyB0 aGUgc2FtZSBhcyBmb3IgY29udmVuaWVuY2UgdmFyaWFibGVzOyB0YXJnZXQg YXR0cmlidXRlcword2lsbCBtYXNrIGNvbnZlbmllbmNlIHZhcmlhYmxlcyBv ZiB0aGUgc2FtZSBuYW1lLgorCitAdGFibGUgQGNvZGUKKworQGtpbmRleCBp bmZvIHRhcmdldC1hdHRyaWJ1dGVzCitAaXRlbSBpbmZvIHRhcmdldC1hdHRy aWJ1dGVzCitTdGF0dXMgb2YgdGFyZ2V0IGF0dHJpYnV0ZXMuCisKK0BlbmQg dGFibGUKKworQG5vZGUgRXhhbXBsZSBvZiBUYXJnZXQgQXR0cmlidXRlcwor QHNlY3Rpb24gRXhhbXBsZSBvZiBUYXJnZXQgQXR0cmlidXRlcworQGNpbmRl eCBleGFtcGxlIG9mIHRhcmdldCBhdHRyaWJ1dGVzCisKK0dkYnNlcnZlciBp bmNsdWRlcyBhIHRhcmdldCBhdHRyaWJ1dGUgdG8gY291bnQgaG93IG1hbnkg dGltZXMgZWFjaAorYnJlYWtwb2ludCBoYXMgYmVlbiBwYXNzZWQuCisKK1Ro aXMgZnVuY3Rpb24gd2lsbCBub3QgYmUgYnVpbHQgaW4gYnkgZGVmYXVsdC4g IFRvIGluY2x1ZGUgaXQgaW4KK2dkYnNlcnZlciwgYWRkIEBjb2Rley0tZW5h YmxlLWJyZWFrLWNvdW50fSBpbiB0aGUgY29uZmlnIGNvbW1hbmQuCitXaGVu IGJ1aWx0IHdpdGggdGhpcyBvcHRpb24sIGdkYnNlcnZlciB3aWxsIHJlcG9y dCB0aHJlZSB0YXJnZXQKK2F0dHJpYnV0ZXM6CisKK0B0YWJsZSBAc2FtcAor CitAaXRlbSAkYnJlYWtfY291bnRfb24KK1RoaXMgaXMgdGhlIHN3aXRjaCBv ZiB0aGUgYnJlYWtwb2ludHMgcGFzcyBjb3VudCBmdW5jdGlvbi4gIFRoZQor ZGVmYXVsdCB2YWx1ZSBvZiBpdCBpcyAwLCB0aGUgYnJlYWtwb2ludHMgcGFz cyBjb3VudCBmdW5jdGlvbiBpcworZGlzYWJsZWQuICBJZiBpdCBpcyBzZXQg dG8gMSwgY291bnRpbmcgaXMgZW5hYmxlZCwgYW5kIHRoZSBjb3VudCB2YWx1 ZQorb2YgYWxsIHRoZSBicmVha3BvaW50cyB3aWxsIHJlc2V0IHRvIDAgd2hl biB0aGUgaW5mZXJpb3Igc3RvcHMgYW5kCitjb250aW51ZXMgYWdhaW4uICBJ ZiBpdCBpcyBzZXQgdG8gMiwgZnVuY3Rpb24gaXMgZW5hYmxlZCwgYnV0IHRo ZQorY291bnQgdmFsdWUgd2lsbCBub3QgYmUgcmVzZXQuCisKK0BpdGVtICRi cmVha19jb3VudF9zZWxlY3QKK1doZW4gdGhlIGNvdW50IGZ1bmN0aW9uIGlz IGVuYWJsZWQsIHRoaXMgc2V0cyB0aGUgYWRkcmVzcyBvZiB0aGUKK2JyZWFr cG9pbnQgd2hvc2UgaGl0cyB3aWxsIGJlIGNvdW50ZWQgaW4gJGJyZWFrX2Nv dW50X3ZhbC4KKworQGl0ZW0gJGJyZWFrX2NvdW50X3ZhbAorVGhpcyBpcyB0 aGUgY3VycmVudCB2YWx1ZSBvZiB0aGUgYnJlYWtwb2ludCBwYXNzIGNvdW50 LgorCitAZW5kIHRhYmxlCisKK1RoZSBmb2xsb3dpbmcgZXhhbXBsZSBzaG93 cyBob3cgdG8gdXNlIHRoZSBicmVha3BvaW50cyBwYXNzIGNvdW50CitmdW5j dGlvbiBpbiBhIGJyZWFrcG9pbnQgY29uZGl0aW9uOgorCitAc21hbGxleGFt cGxlCisoZ2RiKSB0YXJnZXQgcmVtb3RlIDoxMjM0CitSZW1vdGUgZGVidWdn aW5nIHVzaW5nIDoxMjM0CitSZWFkaW5nIHN5bWJvbHMgZnJvbSAvbGliNjQv bGQtbGludXgteDg2LTY0LnNvLjIuLi4obm8gZGVidWdnaW5nIHN5bWJvbHMg Zm91bmQpLi4uZG9uZS4KK0xvYWRlZCBzeW1ib2xzIGZvciAvbGliNjQvbGQt bGludXgteDg2LTY0LnNvLjIKKzB4MDAwMDdmZmZmN2RkYjZiMCBpbiA/PyAo KSBmcm9tIC9saWI2NC9sZC1saW51eC14ODYtNjQuc28uMgorKGdkYikgbGlz dAorMQlpbnQKKzIJbWFpbigpCiszCUB7Cis0CSAgaW50CWEgPSAxOworNQor NgkgIHdoaWxlICgxKQorNwkgICAgcHJpbnRmKCIlZFxuIiwgYSsrKTsKKzgJ QH0KKyhnZGIpIHNldCAkYnJlYWtfY291bnRfb249MQorKGdkYikgYiA3CitC cmVha3BvaW50IDEgYXQgMHg0MDA1MDM6IGZpbGUgMS5jLCBsaW5lIDcuCiso Z2RiKSBjb25kaXRpb24gMSAoJGJyZWFrX2NvdW50X3ZhbCA9PSAxMCkKKyhn ZGIpIGMKK0NvbnRpbnVpbmcuCisKK0JyZWFrcG9pbnQgMSwgbWFpbiAoKSBh dCAxLmM6NworNwkgICAgcHJpbnRmKCIlZFxuIiwgYSsrKTsKKworSW4gZ2Ri c2VydmVyIHBhcnQsIHlvdSBjYW4gc2VlIHRoYXQ6CitQcm9jZXNzIC9ob21l L3RlYXdhdGVyL3RtcC9hLm91dCBjcmVhdGVkOyBwaWQgPSA3OTM3CitMaXN0 ZW5pbmcgb24gcG9ydCAxMjM0CitSZW1vdGUgZGVidWdnaW5nIGZyb20gaG9z dCAxMjcuMC4wLjEKK0ZvdW5kIGJyZWFrcG9pbnQgY29uZGl0aW9uLgorRm91 bmQgYnJlYWtwb2ludCBjb25kaXRpb24uCitGb3VuZCBicmVha3BvaW50IGNv bmRpdGlvbi4KKzEKKzIKKzMKKzQKKzUKKzYKKzcKKzgKKzkKK0BlbmQgc21h bGxleGFtcGxlCisKK1RoZSBmb2xsb3dpbmcgZXhhbXBsZSBzaG93cyBob3cg dG8gdXNlIGJyZWFrcG9pbnRzIHBhc3MgY291bnQgdG8gc2hvdworYW4gYWRk cmVzcyBwYXNzZWQgdGltZXM6CisKK0BzbWFsbGV4YW1wbGUKKyhnZGIpIHNl dCBub24tc3RvcCBvbgorKGdkYikgc2V0IHRhcmdldC1hc3luYyBvbgorKGdk YikgdGFyZ2V0IHJlbW90ZSA6MTIzNAorUmVtb3RlIGRlYnVnZ2luZyB1c2lu ZyA6MTIzNAorW05ldyBUaHJlYWQgNzk0NF0KKyhnZGIpCitbVGhyZWFkIDc5 NDRdICMxIHN0b3BwZWQuCisweDAwMDA3ZmZmZjdkZGI2YjAgaW4gPz8gKCkK K3NldCAkYnJlYWtfY291bnRfb249MgorKGdkYikgbGlzdAorMQlpbnQKKzIJ bWFpbigpCiszCUB7Cis0CSAgaW50CWEgPSAxOworNQorNgkgIHdoaWxlICgx KQorNwkgICAgcHJpbnRmKCIlZFxuIiwgYSsrKTsKKzgJQH0KKyhnZGIpIGIg NworQnJlYWtwb2ludCAxIGF0IDB4NDAwNTAzOiBmaWxlIDEuYywgbGluZSA3 LgorKGdkYikgY29uZGl0aW9uIDEgKCRicmVha19jb3VudF92YWwgPT0gMCkK KyhnZGIpIGMmCitDb250aW51aW5nLgorKGdkYikgcCAkYnJlYWtfY291bnRf dmFsCiskMSA9IDk2OTY1CisoZ2RiKSBwICRicmVha19jb3VudF92YWwKKyQy ID0gMTQ4NTQ4CitAZW5kIHNtYWxsZXhhbXBsZQorCiBAbm9kZSBPcGVyYXRp bmcgU3lzdGVtIEluZm9ybWF0aW9uCiBAYXBwZW5kaXggT3BlcmF0aW5nIFN5 c3RlbSBJbmZvcm1hdGlvbgogQGNpbmRleCBvcGVyYXRpbmcgc3lzdGVtIGlu Zm9ybWF0aW9uCg== --14dae9ccd5a22a549404c8b6374a--