28011 2015-02-13 20:48:23 +0000 Redefining RFC 2119 may and must 2016-12-16 19:55:21 +0000 1 1 1 Unclassified XPath / XQuery / XSLT Functions and Operators 3.1 Candidate Recommendation PC Linux CLOSED FIXED P2 normal --- 1 patrick mike cmsmcq public-qt-comments oldest_to_newest 117893 0 1574 patrick 2015-02-13 20:48:23 +0000 Created attachment 1574 The history of RFC2119 usage at W3C and the redefinition mistake. Section 1.6.3 Conformance terminology redefines may and must and does not follow RFC 2119. I have traced the error back to Extensible Markup Language (XML) 1.0 (Second Edition), http://www.w3.org/TR/2000/REC-xml-20001006, which used the definitions of may and must found in FO31. Those definitions were abandoned in Extensible Markup Language (XML) 1.0 (Third Edition), http://www.w3.org/TR/2004/REC-xml-20040204, citing RFC 2119 instead and that practice, of citing RFC 2119 has continued to date. Unfortunately, XML Schema Part 2: Datatypes Second Edition, http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/, fell between XML 1.0 2nd edition and XML 1.0 3rd edition. The redefining of RFC 2119, abandoned for ten (10) years now, should be avoided here for the sake of interoperability. I have attached a longer document that treats the history of this error more extensively. 117930 1 mike 2015-02-15 10:57:05 +0000 For anyone like me who was totally bewildered by the title of the attached document, "Will Robinson" apparently refers to a popular US TV programme: https://en.wikipedia.org/wiki/Danger,_Will_Robinson 117931 2 mike 2015-02-15 11:40:37 +0000 A couple of additional points: (a) The defined term "for compatibility" is never referenced as such; the definition should probably be removed. (b) Section 1.6.3 seems misplaced; it would make more sense to move it to 1.1 (c) I think it's inconsistent to say on the one hand that conformance rules are defined by the host language, and on the other hand to use RFC (or RFC-like) "must" language. I'm not sure we've ever really had a clear view on how much a host language is allowed to modify the spec. One could argue that any spec can choose to use parts of another spec selectively; if a spec A wants to cherry-pick arbitrarily from a spec B, there is nothing that B can say to prevent this. My feeling is that F+O DOES define conformance requirements (functions must behave as described), but it is up to other specs whether to adopt those requirements or not. A significant problem in switching to the RFC 2119 definition of "must" in F+O is that we often use the word in sentences like "The primary format token is always present and must not be zero-length." Here the requirement is not on the implementor of the spec, but on the user. The correct reading of the RFC definition is open to debate, but my interpretation is that it is always a requirement on the implementation, and because it is defined as an "absolute requirement" there is no room for discussion about what an implementation should do ("raise an error") if the requirement is not satisfied. 117932 3 patrick 2015-02-15 14:15:18 +0000 Michael, When you say: **** A significant problem in switching to the RFC 2119 definition of "must" in F+O is that we often use the word in sentences like "The primary format token is always present and must not be zero-length." Here the requirement is not on the implementor of the spec, but on the user. **** Although phrased as a requirement on a user, isn't the requirement on an implementation to not accept input that failed to conform to the requirement? In this case, an implementation must fail/reject input where the primary format token is absent or is of zero-length. Yes? 117933 4 patrick 2015-02-15 15:00:07 +0000 Michael, Lest we forget, the IETF covers the "user" case (if that is the case here) with this language from the RFC Editors Guidelines, http://www.rfc-editor.org/policy.html: **** Some standards-track documents use certain capitalized words ("MUST", "SHOULD", etc.) to specify precise requirement-levels for technical points. RFC 2119 (BCP 14) [BCP14] defines a default interpretation of these capitalized words in IETF documents. If this interpretation is used, RFC 2119 must be cited (as specified in RFC 2119) and included as a normative reference. Otherwise, the correct interpretation must be specified in the document. Avoid abuse of requirement-level words. They are intended to provide guidance to implementors about specific technical features, generally governed by considerations of interoperability. RFC 2119 says, "Imperatives of the type defined in this memo must be used with care and sparingly. In particular, they MUST only be used where it is actually required for interoperation or to limit behavior which has potential for causing harm (e.g., limiting retransmissions). For example, they must not be used to try to impose a particular method on implementors where the method is not required for interoperability." To simply specify a necessary logical relationship; the normal lower-case words should be used. On the other hand, if the capitalized words are used in a document, they must be used consistently throughout the document. **** So, uppercase MUST for implementation requirements and lowercase must for "necessary logical relationship." I persist in thinking your example is a requirement on the implementation but offer this as another aspect of the issue. 118034 5 mike 2015-02-19 17:56:49 +0000 We can certainly regard the sentence "The primary format token is always present and must not be zero-length." as a paraphrase for "The implementation must raise a dynamic error if the primary format token is absent or is zero-length." The question is whether we need to say explicitly that we are adopting this convention, and whether this would itself be a variation on the RFC definition of "must". 118267 6 cmsmcq 2015-03-03 23:59:04 +0000 For the record, it is not quite true that XML 1.0 2e was the first XML spec not to cite RFC 2119; the first edition also did not cite RFC 2119, but defined 'may' and 'must' in words modeled on those in ISO specs the editors knew and trusted. One reason to be cautious about the definitions in RFC 2119 is the casual circularity of the definition of 'MUST', which may perhaps be best illustrated if we replace the crucial words with words we do not in fact already know: 1. MAUN This word, or the terms "FARBLED" or "GRANFALLOON", mean that the definition is an absolute farblement of the specification. OK. So we use the word FARBLED if the definition is a FARBLEMENT. And a FARBLEMENT, we may infer, is something that is FARBLED. How that relates to anything else in the world is not clear to this reader. It's not hard to do better; though I say it myself, I think the XML spec did. Another reason is that the definitions in RFC 2119 are made awkward by the text's strenuous effort not to say what kinds of things it is talking about -- an effort which however fails in the course of the paragraph on MAY, which finally gives in and mentions 'implementations'. It is hard for this reader to see how to apply the definitions given in cases where a spec governs something other than software. The only reason that the flaws in RFC 2119's definitions are not catastrophic is that as far as I can tell no one ever, ever pays any attention whatsoever to the definition of these terms, but merely uses them the way other specifications do. That said, the XML spec refers to documents and processors because the spec defines conformance requirements both for documents and processors. Copying the definition into a spec which does not define a class of documents may not have been the best way to start. 119707 7 mike 2015-04-20 23:24:44 +0000 It's certainly true that (a) the use of "must" within F+O is a mess, (b) that it's not easy to sort out, and (c) that the mess does very little practical harm. The messiness arises in a number of separate ways. (a) The definitions of the terms are not directly linked to RFC2119; indeed, RFC2119 is not cited, normatively or otherwise. (b) There are three different renditions used for the word "must": normal text, bold text, and hyperlinked text. The use of bold and hyperlinked rendition appears to be interchangeable. (c) The word "must" sometimes refers to the implementation/processor, and sometimes to the caller of a function (as in, "a '$' sign must be escaped as '\$'".) The latter usage "A must be B" is shorthand for "if A is not B, the function raises a dynamic error". This is a very convenient shorthand, but it's not closely related to the usage described in the RFC definition nor the F+O definition of "must". (d) The use of "must" isn't directly linked to conformance criteria for the spec. This relates to the fact that F+O doesn't actually have any conformance criteria, on the theory that it is designed to be referenced from other specs rather than to be free-standing. I will propose a way forward in the next message. 119717 8 mike 2015-04-21 08:28:43 +0000 I propose to resolve these issues as follows: (a)/(c) I propose to retain local definitions of the terms "must" and "may" rather than simply deferring to RFC2119. The RFC definitions, as pointed out by MSMcQ, are too imprecise to be useful in the context of this specification without elaboration. However, I intend to add a non-normative reference to the RFC. Specifically, I propose using the following definitions: * The auxiliary verb MUST, when rendered in small capitals, indicates a precondition for conformance. ** When the sentence relates to an implementation of a function (for example "All implementations MUST recognize URIs of the form ...") then an implementation is not conformant unless it behaves as stated. ** When the sentence relates to the result of a function (for example "The result MUST have the same type as $arg") then the implementation is not conformant unless it delivers a result as stated. ** When the sentence relates to the arguments to a function (for example "The value of $arg MUST be a valid regular expression") then the implementation is not conformant unless it enforces the condition by raising a dynamic error whenever the condition is not satisfied. * The auxiliary verb MAY, when rendered in small capitals, indicates optional or discretionary behavior. The statement "An implementation MAY do X" implies that it is implementation-dependent whether or not it does X. Note: These definitions of the terms MUST and MAY are consistent with the definitions in RFC2119, but expressed in language appropriate to the subject matter of this particular specification. (b) I propose to use small caps for rendering the formal instances of MUST and MAY, as is done in the XSLT spec, replacing use of bold and hyperlink rendition. (d) Since MUST and MAY rely for their meaning on some notion of "conformance", I propose to rephrase section 1.1 to include such a notion. In particular I propose to be more precise about the freedoms available to a host language: * This recommendation contains a set of function specifications. It defines conformance at the level of individual functions. An implementation of a function conforms to a function specification in this recommendation if all the following conditions are satisfied: ** For all valid inputs to the function (both explicit arguments and implicit context dependencies), the result of the function meets the mandatory requirements of this specification ** For all invalid inputs to the function, the implementation signals (in some way appropriate to the calling environment) that a dynamic error has occurred. ** For a sequence of calls within the same EXECUTION SCOPE, the requirements of this recommendation regarding the STABILITY of results are satisfied (see section XXX). Other recommendations ("host languages") that reference this document may dictate: ** subsets or supersets of this set of functions to be available in particular environments ** mechanisms for invoking functions, supplying arguments, initializing the static and dynamic context, receiving results, and handling dynamic errors ** a concrete realization of concepts such as EXECUTION SCOPE ** which versions of other specifications referenced herein (for example, XML, XSD, or Unicode) are to be used Any behavior that is discretionary (implementation-defined or implementation-dependent) in this specification may be constrained by a host language. Note: Adding such constraints in a host language, however, is discouraged because it makes it difficult to re-use implementations of the function library across host languages. 120281 9 mike 2015-05-13 08:14:40 +0000 These changes were accepted and have been applied. 1574 2015-02-13 20:48:23 +0000 2015-02-13 20:48:23 +0000 The history of RFC2119 usage at W3C and the redefinition mistake. rfc2119-comment.txt text/plain 20369 patrick VGhpcyBvcmlnaW5hbGx5IGFwcGVhcmVkIGFzOiBSZWRlZmluaW5nIFJGQyAyMTE5PyBEYW5nZXIh IERhbmdlciEgV2lsbCBSb2JpbnNvbiEsIGh0dHA6Ly90bS5kdXJ1c2F1Lm5ldC8/cD01OTI4NgoK CkknbSBsYWdnaW5nIGJlaGluZCBpbiByZWFkaW5nIDxhIGhyZWY9Imh0dHA6Ly93d3cudzMub3Jn L1RSLzIwMTQvQ1IteHF1ZXJ5LTMxLTIwMTQxMjE4LyIgdGFyZ2V0PSJfYmxhbmsiPlhRdWVyeSAz LjE6IEFuIFhNTCBRdWVyeSBMYW5ndWFnZTwvYT4sIDxhIGhyZWY9Imh0dHA6Ly93d3cudzMub3Jn L1RSLzIwMTQvQ1IteHBhdGgtMzEtMjAxNDEyMTgvIiB0YXJnZXQ9Il9ibGFuayI+WE1MIFBhdGgg TGFuZ3VhZ2UgKFhQYXRoKSAzLjE8L2E+LCBhbmQsIDxhIGhyZWY9Imh0dHA6Ly93d3cudzMub3Jn L1RSLzIwMTQvQ1IteHBhdGgtZnVuY3Rpb25zLTMxLTIwMTQxMjE4LyIgdGFyZ2V0PSJfYmxhbmsi PlhQYXRoIGFuZCBYUXVlcnkgRnVuY3Rpb25zIGFuZCBPcGVyYXRvcnMgMy4xPC9hPiBpbiBvcmRl ciB0byBjb21tZW50IGJ5IDxzdHJvbmc+MTMgRmVicnVhcnkgMjAxNTwvc3Ryb25nPi4KCkluIG9y ZGVyIHRvIGNhdGNoIHVwIHRoaXMgcGFzdCB3ZWVrZW5kIEkgc3RhcnRlZCB0cnlpbmcgdG8gdGVh c2UgdGhlc2UgY2FuZGlkYXRlIHJlY29tbWVuZGF0aW9ucyBhcGFydCB0byBtYWtlIHRoZW0gZWFz aWVyIHRvIHByb29mLiBPbmUgb2YgdGhlIHRoaW5ncyBJIGFsd2F5cyBkbyBJIGNoZWNrIGZvciBr ZXkgd29yZCBjb25mb3JtYW5jZSBsYW5ndWFnZSBhbmQgdGhhdCBtZWFucywgb3V0c2lkZSBvZiBJ U08sIDxhIGhyZWY9Imh0dHA6Ly93d3cuaWV0Zi5vcmcvcmZjL3JmYzIxMTkudHh0IiB0YXJnZXQ9 Il9ibGFuayI+UkZDIDIxMTk8L2E+LiAKCkkgd2FzIHJlYWRpbmcgPGEgaHJlZj0iaHR0cDovL3d3 dy53My5vcmcvVFIvMjAxNC9DUi14cGF0aC1mdW5jdGlvbnMtMzEtMjAxNDEyMTgvIiB0YXJnZXQ9 Il9ibGFuayI+WFBhdGggYW5kIFhRdWVyeSBGdW5jdGlvbnMgYW5kIE9wZXJhdG9ycyAzLjE8L2E+ IChoZXJlaW4gRnVuY3Rpb25zIGFuZCBPcGVyYXRvcnMpIHdoZW4gSSBzYXc6Cgo8YmxvY2txdW90 ZT48c3Ryb25nPjEuMSBDb25mb3JtYW5jZTwvc3Ryb25nPgoKVGhlIEZ1bmN0aW9ucyBhbmQgT3Bl cmF0b3JzIHNwZWNpZmljYXRpb24gaXMgaW50ZW5kZWQgcHJpbWFyaWx5IGFzIGEgY29tcG9uZW50 IHRoYXQgY2FuIGJlIHVzZWQgYnkgb3RoZXIgc3BlY2lmaWNhdGlvbnMuIFRoZXJlZm9yZSwgRnVu Y3Rpb25zIGFuZCBPcGVyYXRvcnMgcmVsaWVzIG9uIHNwZWNpZmljYXRpb25zIHRoYXQgdXNlIGl0 IChzdWNoIGFzIFs8YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi8yMDE0L0NSLXhwYXRoLTMx LTIwMTQxMjE4LyIgdGFyZ2V0PSJfYmxhbmsiPlhNTCBQYXRoIExhbmd1YWdlIChYUGF0aCkgMy4x PC9hPl0sIFs8YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi8yMDE0L0NSLXhxdWVyeS0zMS0y MDE0MTIxOC8iIHRhcmdldD0iX2JsYW5rIj5YUXVlcnkgMy4xOiBBbiBYTUwgUXVlcnkgTGFuZ3Vh Z2U8L2E+XSwgYW5kIHBvdGVudGlhbGx5IGZ1dHVyZSB2ZXJzaW9ucyBvZiBYU0xUKSB0byBzcGVj aWZ5IGNvbmZvcm1hbmNlIGNyaXRlcmlhIGZvciB0aGVpciByZXNwZWN0aXZlIGVudmlyb25tZW50 cy4KLi4uCjwvYmxvY2txdW90ZT4KClRoYXQgd29ya3MuIFlvdSBoYXZlIGEgbm9ybWF0aXZlIGRv Y3VtZW50IG9mIGRlZmluaXRpb25zLCBldGMuLCBhbmQgc29tZSBvdGhlciBzdGFuZGFyZCBjaXRl cyB0aG9zZSBkZWZpbml0aW9ucyBhbmQgc3VwcGxpZXMgdGhlIDxjb2RlPm11c3QsPC9jb2RlIDxj b2RlPnNob3VsZDwvY29kZT4sIDxjb2RlPm1heTwvY29kZT4gYWNjb3JkaW5nIHRvIFJGQyAyMTE5 LiBOb3QgY29tbW9uIGJ1dCB0aGF0IHdvcmtzLgoKQnV0IHRoZW4gSSBzdGFydGVkIHJ1bm5pbmcg c2NyaXB0cyBmb3IgdXNhZ2Ugb2Yga2V5IHdvcmRzIGFuZCBJIGZvdW5kIGluICAgRnVuY3Rpb25z IGFuZCBPcGVyYXRvcnM6Cgo8YmxvY2txdW90ZT48c3Ryb25nPjEuNi4zIENvbmZvcm1hbmNlIHRl cm1pbm9sb2d5PC9zdHJvbmc+Ci4uLgoKW0RlZmluaXRpb25dIDxzdHJvbmc+bWF5PC9zdHJvbmc+ CgpDb25mb3JtaW5nIGRvY3VtZW50cyBhbmQgcHJvY2Vzc29ycyBhcmUgcGVybWl0dGVkIHRvLCBi dXQgbmVlZCBub3QsIGJlaGF2ZSBhcyBkZXNjcmliZWQuCgpbRGVmaW5pdGlvbl0gPHN0cm9uZz5t dXN0PC9zdHJvbmc+CgpDb25mb3JtaW5nIGRvY3VtZW50cyBhbmQgcHJvY2Vzc29ycyBhcmUgcmVx dWlyZWQgdG8gYmVoYXZlIGFzIGRlc2NyaWJlZDsgb3RoZXJ3aXNlLCB0aGV5IGFyZSBlaXRoZXIg bm9uLWNvbmZvcm1hbnQgb3IgZWxzZSBpbiBlcnJvci48L2Jsb2NrcXVvdGU+CgpUaHVzIHRoZSB0 aXRsZTogPHNwYW4gc3R5bGU9ImNvbG9yOnJlZCI+UmVkZWZpbmluZyBSRkMgMjExOT8gRGFuZ2Vy ISBEYW5nZXIhIFdpbGwgUm9iaW5zb24hPC9zcGFuPgoKUkZDIDIxMTkgcmVhZHMgaW4gcGFydDoK CjxibG9ja3F1b3RlPjEuIE1VU1QgICBUaGlzIHdvcmQsIG9yIHRoZSB0ZXJtcyAiUkVRVUlSRUQi IG9yICJTSEFMTCIsIG1lYW4gdGhhdCB0aGUgZGVmaW5pdGlvbiBpcyBhbiBhYnNvbHV0ZSByZXF1 aXJlbWVudCBvZiB0aGUgc3BlY2lmaWNhdGlvbi4KCjUuIE1BWSAgIFRoaXMgd29yZCwgb3IgdGhl IGFkamVjdGl2ZSAiT1BUSU9OQUwiLCBtZWFuIHRoYXQgYW4gaXRlbSBpcyB0cnVseSBvcHRpb25h bC4gIE9uZSB2ZW5kb3IgbWF5IGNob29zZSB0byBpbmNsdWRlIHRoZSBpdGVtIGJlY2F1c2UgYSBw YXJ0aWN1bGFyIG1hcmtldHBsYWNlIHJlcXVpcmVzIGl0IG9yIGJlY2F1c2UgdGhlIHZlbmRvciBm ZWVscyB0aGF0IGl0IGVuaGFuY2VzIHRoZSBwcm9kdWN0IHdoaWxlIGFub3RoZXIgdmVuZG9yIG1h eSBvbWl0IHRoZSBzYW1lIGl0ZW0uIEFuIGltcGxlbWVudGF0aW9uIHdoaWNoIGRvZXMgbm90IGlu Y2x1ZGUgYSBwYXJ0aWN1bGFyIG9wdGlvbiBNVVNUIGJlIHByZXBhcmVkIHRvIGludGVyb3BlcmF0 ZSB3aXRoIGFub3RoZXIgaW1wbGVtZW50YXRpb24gd2hpY2ggZG9lcyBpbmNsdWRlIHRoZSBvcHRp b24sIHRob3VnaCBwZXJoYXBzIHdpdGggcmVkdWNlZCBmdW5jdGlvbmFsaXR5LiBJbiB0aGUgc2Ft ZSB2ZWluIGFuIGltcGxlbWVudGF0aW9uIHdoaWNoIGRvZXMgaW5jbHVkZSBhIHBhcnRpY3VsYXIg b3B0aW9uIE1VU1QgYmUgcHJlcGFyZWQgdG8gaW50ZXJvcGVyYXRlIHdpdGggYW5vdGhlciBpbXBs ZW1lbnRhdGlvbiB3aGljaCBkb2VzIG5vdCBpbmNsdWRlIHRoZSBvcHRpb24gKGV4Y2VwdCwgb2Yg Y291cnNlLCBmb3IgdGhlIGZlYXR1cmUgdGhlIG9wdGlvbiBwcm92aWRlcy4pCgo2LiBHdWlkYW5j ZSBpbiB0aGUgdXNlIG9mIHRoZXNlIEltcGVyYXRpdmVzCgpJbXBlcmF0aXZlcyBvZiB0aGUgdHlw ZSBkZWZpbmVkIGluIHRoaXMgbWVtbyBtdXN0IGJlIHVzZWQgd2l0aCBjYXJlIGFuZCBzcGFyaW5n bHkuICBJbiBwYXJ0aWN1bGFyLCB0aGV5IE1VU1Qgb25seSBiZSB1c2VkIHdoZXJlIGl0IGlzIGFj dHVhbGx5IHJlcXVpcmVkIGZvciBpbnRlcm9wZXJhdGlvbiBvciB0byBsaW1pdCBiZWhhdmlvciB3 aGljaCBoYXMgcG90ZW50aWFsIGZvciBjYXVzaW5nIGhhcm0gKGUuZy4sIGxpbWl0aW5nIHJldHJh bnNtaXNzc2lvbnMpICBGb3IgZXhhbXBsZSwgdGhleSBtdXN0IG5vdCBiZSB1c2VkIHRvIHRyeSB0 byBpbXBvc2UgYSBwYXJ0aWN1bGFyIG1ldGhvZCBvbiBpbXBsZW1lbnRvcnMgd2hlcmUgdGhlIG1l dGhvZCBpcyBub3QgcmVxdWlyZWQgZm9yIGludGVyb3BlcmFiaWxpdHkuPC9ibG9ja3F1b3RlPgoK Rmlyc3QsIHRoZSByZWZlcmVuY2luZyBvZiBSRkMgMjExOSBpcyBzdGFuZGFyZCBwcmFjdGljZSBh dCB0aGUgVzNDLCBhdCBsZWFzdCB3aXRoIHJlZ2FyZCB0byBYTUwgc3BlY2lmaWNhdGlvbnMuIEkg d2FudGVkIHRvIGhhdmUgbW9yZSB0aGFuIHBlcnNvbmFsIGV4cGVyaWVuY2UgdG8gY2l0ZSBzbyBJ IGNvbGxlY3RlZCB0aGUgZmlmdHktZWlnaHQgY3VycmVudCBYTUwgc3BlY2lmaWNhdGlvbnMgYW5k IHN1bW1hcml6ZSB0aGVtIGluIHRoZSBsaXN0IGF0IHRoZSBlbmQgb2YgdGhpcyBwb3N0LiAKCk9m IHRoZSBmaWZ0eS1uaW5lICg1OSkgY3VycmVudCBYTUwgc3BlY2lmaWNhdGlvbnMgKHRoZXJlIG1h eSBiZSBvdGhlcnMsIHRoZSBXM0MgaGFzIGFiYW5kb25lZCBzaW1wbHkgbGlzdGluZyBpdHMgd29y ayB3aXRob3V0IGV4dHJhbmVvdXMgZ3JvdXBpbmdzKSwgZmlmdHktdHdvIG9mIHRoZSBzdGFuZGFy ZHMgY2l0ZSBhbmQgZm9sbG93IFJGQyAyMTE5LiBUaHJlZSBvZiB0aGUgcmVtYWluaW5nIHNldmVu ICg3KSBmYWlsIHRvIGNpdGUgUkZDIGR1ZSB0byBlcnJvcnMgaW4gZWRpdGluZy4gCgpUaGUgZmlu YWwgZm91ciAoNCkgYXMgaXQgd2VyZSB0aGF0IGRvbid0IGNpdGUgUkZDIDIxMTkgYXJlIGEgZ29v ZCBpbGx1c3RyYXRpb24gb2YgaG93IGVycm9ycyBnZXQgcGVycGV0dWF0ZWQgZnJvbSBvbmUgc3Rh bmRhcmQgdG8gYW5vdGhlci4KClRoZSBmaXJzdCBXM0MgWE1MIHNwZWNpZmljYXRpb24gdG8gbm90 IGNpdGUgUkZDIDIxMTkgd2FzOiA8YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi8yMDAwL1JF Qy14bWwtMjAwMDEwMDYiIHRhcmdldD0iX2JsYW5rIj5FeHRlbnNpYmxlIE1hcmt1cCBMYW5ndWFn ZSAoWE1MKSAxLjAgKFNlY29uZCBFZGl0aW9uKTwvYT4gd2hlcmUgaXQgcmVhZHMgaW4gcGFydDoK CjxibG9ja3F1b3RlPjEuMiBUZXJtaW5vbG9neQoKPHN0cm9uZz5tYXk8L3N0cm9uZz4KCltEZWZp bml0aW9uOiBDb25mb3JtaW5nIGRvY3VtZW50cyBhbmQgWE1MIHByb2Nlc3NvcnMgYXJlIHBlcm1p dHRlZCB0byBidXQgbmVlZCBub3QgYmVoYXZlIGFzIGRlc2NyaWJlZC5dCgo8c3Ryb25nPm11c3Q8 L3N0cm9uZz4KCltEZWZpbml0aW9uOiBDb25mb3JtaW5nIGRvY3VtZW50cyBhbmQgWE1MIHByb2Nl c3NvcnMgYXJlIHJlcXVpcmVkIHRvIGJlaGF2ZSBhcyBkZXNjcmliZWQ7IG90aGVyd2lzZSB0aGV5 IGFyZSBpbiBlcnJvci4gXTwvYmxvY2txdW90ZT4KCjxzcGFuIHN0eWxlPSJjb2xvcjpyZWQiPlRo ZSBkZWZpbml0aW9ucyBvZiA8Y29kZT5tdXN0PC9jb2RlPiBhbmQgPGNvZGU+bWF5PC9jb2RlPiB3 ZXJlIDxzdHJvbmc+QUJBTkRPTkVEPC9zdHJvbmc+IGluPC9zcGFuPiA8YSBocmVmPSJodHRwOi8v d3d3LnczLm9yZy9UUi8yMDA0L1JFQy14bWwtMjAwNDAyMDQiIHRhcmdldD0iX2JsYW5rIj5FeHRl bnNpYmxlIE1hcmt1cCBMYW5ndWFnZSAoWE1MKSAxLjAgKFRoaXJkIEVkaXRpb24pPC9hPiwgd2hp Y2ggc2ltcGx5IGRyb3BwZWQgdGhvc2UgZGVmaW5pdGlvbnMgYW5kIGluc3RlYWQgcmVhZHMgaW4g cGFydDoKCjxibG9ja3F1b3RlPjEuMiBUZXJtaW5vbG9neQoKVGhlIHRlcm1pbm9sb2d5IHVzZWQg dG8gZGVzY3JpYmUgWE1MIGRvY3VtZW50cyBpcyBkZWZpbmVkIGluIHRoZSBib2R5IG9mIHRoaXMg c3BlY2lmaWNhdGlvbi4gVGhlIGtleSB3b3JkcyA8Y29kZT5tdXN0LCBtdXN0IG5vdCwgcmVxdWly ZWQsIHNoYWxsLCBzaGFsbCBub3QsIHNob3VsZCwgc2hvdWxkIG5vdCwgcmVjb21tZW5kZWQsIG1h eSwgYW5kIG9wdGlvbmFsPC9jb2RlPiwgd2hlbiBlbXBoYXNpemVkLCBhcmUgdG8gYmUgaW50ZXJw cmV0ZWQgYXMgZGVzY3JpYmVkIGluIFtJRVRGIFJGQyAyMTE5XS48L2Jsb2NrcXVvdGU+CgpUaGUg ZXhjbHVzaXZlIHVzZSBvZiBSRkMgMjExOSBjb250aW51ZXMgdGhyb3VnaCA8YSBocmVmPSJodHRw Oi8vd3d3LnczLm9yZy9UUi8yMDA2L1JFQy14bWwtMjAwNjA4MTYiIHRhcmdldD0iX2JsYW5rIj5F eHRlbnNpYmxlIE1hcmt1cCBMYW5ndWFnZSAoWE1MKSAxLjAgKEZvdXJ0aCBFZGl0aW9uKTwvYT4g dG8gdGhlIGN1cnJlbnQgPGEgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvMjAwOC9SRUMteG1s LTIwMDgxMTI2LyIgdGFyZ2V0PSJfYmxhbmsiPkV4dGVuc2libGUgTWFya3VwIExhbmd1YWdlIChY TUwpIDEuMCAoRmlmdGggRWRpdGlvbik8L2E+CgpIb3dldmVyLCBhcyBpcyBvZnRlbiBzYWlkLCB3 aGF0ZXZlciBnb29kIGVkaXRpbmcgd2UgZG8gaXMgaW50ZXJyZWQgd2l0aCB1cyBhbmQgYW55IGVy cm9ycyB3ZSBtYWtlIGxpdmUgb24uIAoKQmVmb3JlIHRoZSBhYmFuZG9ubWVudCBvZiBhdHRlbXB0 cyB0byBkZWZpbmUgPGNvZGU+bWF5PC9jb2RlPiBhbmQgPGNvZGU+bXVzdDwvY29kZT4gYXBwZWFy ZWQgaW4gWE1MIDNyZCBlZGl0aW9uLCA8YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi8yMDA0 L1JFQy14bWxzY2hlbWEtMS0yMDA0MTAyOC8iIHRhcmdldD0iX2JsYW5rIj5YTUwgU2NoZW1hIFBh cnQgMTogU3RydWN0dXJlcyBTZWNvbmQgRWRpdGlvbjwvYT4gYW5kIDxhIGhyZWY9Imh0dHA6Ly93 d3cudzMub3JnL1RSLzIwMDQvUkVDLXhtbHNjaGVtYS0yLTIwMDQxMDI4LyIgdGFyZ2V0PSJfYmxh bmsiPlhNTCBTY2hlbWEgUGFydCAyOiBEYXRhdHlwZXMgU2Vjb25kIEVkaXRpb248L2E+IGNpdGUg WE1MIDJuZCBlZGl0aW9uIGFzIHRoZWlyIHJhdGlvbmFsZSBmb3IgZGVmaW5pbmcgPGNvZGU+bWF5 PC9jb2RlPiBhbmQgPGNvZGU+bXVzdDwvY29kZT4uIFRoYXQgZXJyb3IgaGFzIG5ldmVyIGJlZW4g Y29ycmVjdGVkLiAKCldoaWNoIGJyaW5ncyB1cyB0byA8YSBocmVmPSJodHRwOi8vd3d3LnczLm9y Zy9UUi8yMDEyL1JFQy14bWxzY2hlbWExMS0yLTIwMTIwNDA1LyIgdGFyZ2V0PSJfYmxhbmsiPlcz QyBYTUwgU2NoZW1hIERlZmluaXRpb24gTGFuZ3VhZ2UgKFhTRCkgMS4xIFBhcnQgMjogRGF0YXR5 cGVzPC9hPiB3aGljaCBpcyB0aGUgbGFzdCBXM0MgWE1MIHNwZWNpZmljYXRpb24gdG8gbm90IGNp dGUgUkZDIDIxMTkuCgpYU0QgMS4xIFBhcnQgMiByZWFkcyBpbiBwYXJ0LCB1bmRlciBBcHBlbmRp eCBJIENoYW5nZXMgc2luY2UgdmVyc2lvbiAxLjAsIEkuNCBPdGhlciBDaGFuZ2VzOiAKCjxibG9j a3F1b3RlPlRoZSBkZWZpbml0aW9ucyBvZiA8Y29kZT5tdXN0PC9jb2RlPiwgPGNvZGU+bXVzdCBu b3QsPC9jb2RlPiBhbmQgPGNvZGU+wrdlcnJvcsK3PC9jb2RlPiBoYXZlIGJlZW4gY2hhbmdlZCB0 byBzcGVjaWZ5IHRoYXQgcHJvY2Vzc29ycyBtdXN0IGRldGVjdCBhbmQgcmVwb3J0IGVycm9ycyBp biBzY2hlbWFzIGFuZCBzY2hlbWEgZG9jdW1lbnRzIChhbHRob3VnaCB0aGUgcXVhbGl0eSBhbmQg bGV2ZWwgb2YgZGV0YWlsIGluIHRoZSBlcnJvciByZXBvcnQgaXMgbm90IGNvbnN0cmFpbmVkKS48 L2Jsb2NrcXVvdGU+CgpUaGUgcHJvYmxlbSBiZWluZyA8YSBocmVmPSJodHRwOi8vd3d3LnczLm9y Zy9UUi8yMDA0L1JFQy14bWxzY2hlbWEtMi0yMDA0MTAyOC8iIHRhcmdldD0iX2JsYW5rIj5YTUwg U2NoZW1hIFBhcnQgMjogRGF0YXR5cGVzIFNlY29uZCBFZGl0aW9uPC9hPjwvbGk+IHJlbGllcyB1 cG9uIDxhIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSLzIwMDQvUkVDLXhtbHNjaGVtYS0yLTIw MDQxMDI4LyIgdGFyZ2V0PSJfYmxhbmsiPlhNTCBTY2hlbWEgUGFydCAyOiBEYXRhdHlwZXMgU2Vj b25kIEVkaXRpb248L2E+IHdoaWNoIGNpdGVzIDxhIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RS LzIwMDAvUkVDLXhtbC0yMDAwMTAwNiIgdGFyZ2V0PSJfYmxhbmsiPkV4dGVuc2libGUgTWFya3Vw IExhbmd1YWdlIChYTUwpIDEuMCAoU2Vjb25kIEVkaXRpb24pPC9hPiBhcyB0aGUgcmVhc29uIGZv ciByZWRlZmluaW5nIHRoZSB0ZXJtcyA8Y29kZT5tYXk8L2NvZGU+IGFuZCA8Y29kZT5tdXN0PC9j b2RlPi4gCgo8c3Ryb25nPlRoZSByZWRlZmluaW5nIG9mIG1heSBhbmQgbXVzdCByZWxpZXMgdXBv biBsYW5ndWFnZSBpbiBhIHN1cGVyY2VkZWQgdmVyc2lvbiBvZiB0aGUgWE1MIHN0YW5kYXJkLiBM YW5ndWFnZSB0aGF0IHdhcyBkZWxldGVkIHRlbiAoMTApIHllYXJzIGFnbyBmcm9tIHRoZSBYTUwg c3RhbmRhcmQuPC9zdHJvbmc+CgpJZiB5b3UgaGF2ZSByZWFkIHRoaXMgZmFyLCB5b3UgaGF2ZSBh IHByZXR0eSBnb29kIGd1ZXNzIHRoYXQgSSBhbSBnb2luZyB0byBzdWdnZXN0IHRoYXQgPGEgaHJl Zj0iaHR0cDovL3d3dy53My5vcmcvVFIvMjAxNC9DUi14cGF0aC1mdW5jdGlvbnMtMzEtMjAxNDEy MTgvIiB0YXJnZXQ9Il9ibGFuayI+WFBhdGggYW5kIFhRdWVyeSBGdW5jdGlvbnMgYW5kIE9wZXJh dG9ycyAzLjE8L2E+IGRyb3AgdGhlIGF0dGVtcHQgdG8gcmVkZWZpbmUgdGVybXMgdGhhdCBhcHBl YXIgaW4gUkZDIDIxMTkuIAoKRmlyc3QsIHJlZGVmaW5pbmcgd2lkZWx5IHVzZWQgdGVybXMgZm9y IGNvbmZvcm1hbmNlIGlzIGNsZWFybHkgYSBiYWQgaWRlYS4gRG8geW91IG1lYW4gUkZDMjExOSA8 Y29kZT5tdXN0PC9jb2RlPiBvciBkbyB5b3UgbWVhbiBhbmQgRiZhbXA7TyA8Y29kZT5tdXN0PC9j b2RlPj8gQ2xlYXJseSBkaWZmZXJlbnQuIElmIGEgcmVxdWlyZW1lbnQgaGFzIGFuIFJGQzIxMTkg bXVzdCwgbXkgYXBwbGljYXRpb24gZWl0aGVyIGNvbmZvcm1zIG9yIGZhaWxzLiBJZiBhIHJlcXVp cmVtZW50IGhhcyBhbiBGJmFtcDtPIDxjb2RlPm11c3Q8L2NvZGU+LCBteSBhcHBsaWNhdGlvbiBt YXkgc2ltcGxlIGJlIGluIGVycm9yLiBBbGwgdGhlIHRpbWUuIElzIHRoYXQgdXNlZnVsPwoKU2Vj b25kLCBieSByZWRlZmluaW5nIDxjb2RlPm11c3Q8L2NvZGU+LCB3ZSBsb3NlIHRoZSBpbnRlcm9w ZXJhYmlsaXR5IGFzcGVjdHMgYXMgZGVmaW5lIGJ5IFJGQzIxMTkgZm9yIGFsbCB1c2VzIG9mIDxj b2RlPm11c3Q8L2NvZGU+LiBTdXJlbHkgaW50ZXJvcGVyYWJpbGl0eSBpcyBhIGdvYWwgb2YgRnVu Y3Rpb25zIGFuZCBPcGVyYXRvcnMuIFllcz8gCgpUaGlyZCwgdGhlIGhpc3Rvcnkgb2YgcmVkZWZp bmluZyA8Y29kZT5tYXk8L2NvZGU+IGFuZCA8Y29kZT5tdXN0PC9jb2RlPiBhdCB0aGUgVzNDIHNo b3dzICh0byBtZSkgdGhlIHBlcnBldHVhdGlvbiBvZiBhbiBlcnJvciBsb25nIGJleW9uZCBpdHMg Y29ycmVjdGlvbiBkYXRlLiBJdCdzIHRpbWUgdG8gcHV0IGFuIGVuZCB0byByZWRlZmluaW5nIG1h eSBhbmQgbXVzdC4gCgpQUzogQmVmb3JlIHlvdSBkZWNpZGUgeW91ICJrbm93IiB0aGUgZGlmZmVy ZW5jZSBpbiB1cHBlciBhbmQgbG93ZXIgY2FzZSBrZXkgd29yZHMgZnJvbSBSRkMgMjExOSwgdGFr ZSBhIGxvb2sgYXQ6IDxhIGhyZWY9Imh0dHA6Ly93d3cucmZjLWVkaXRvci5vcmcvcG9saWN5Lmh0 bWwiIHRhcmdldD0iX2JsYW5rIj5SRkMgRWRpdG9yaWFsIEd1aWRlbGluZXMgYW5kIFByb2NlZHVy ZXM8L2E+LCA8c3Ryb25nPk5vcm1hdGl2ZSBSZWZlcmVuY2VzIHRvIFJGQyAyMTE5PC9zdHJvbmc+ LiBTdW1tYXJ5LCBVUFBFUiBDQVNFIGlzIG5vcm1hdGl2ZSwgbG93ZXIgY2FzZSBpcyAiYSBuZWNl c3NhcnkgbG9naWNhbCByZWxhdGlvbnNoaXAuIiAKClBQUzogVHJhY2tpbmcgdGhpcyBlcnJvciBk b3duIHRvb2sgbG9uZ2VyIHRoYW4gZXhwZWN0ZWQgc28gaXQgd2lsbCBiZSBsYXRlciB0aGlzIHdl ZWsgYmVmb3JlIEkgaGF2ZSBhbnl0aGluZyB0aGF0IG1heSBoZWxwIHdpdGggcHJvb2ZpbmcgdGhl IHNwZWNpZmljYXRpb25zLiAKCjxocj4KClhNTCBTdGFuZGFyZHMgQ29uc3VsdGVkIGluIHByZXBh cmF0aW9uIG9mIHRoaXMgcG9zdC4gWSA9IENpdGVzIFJGQyAyMTE5LCBOID0gRG9lcyBub3QgY2l0 ZSBSRkMgMjExOS4KCgo8dWw+CjxoND5Gb2xsb3cgUkZDIDIxMTk8L2g0PgoKPGxpPlkgPGEgaHJl Zj0iaHR0cDovL3d3dy53My5vcmcvVFIvMjAxMC9SRUMteG1sLXN0eWxlc2hlZXQtMjAxMDEwMjgi IHRhcmdldD0iX2JsYW5rIj5Bc3NvY2lhdGluZyBTdHlsZSBTaGVldHMgd2l0aCBYTUwgZG9jdW1l bnRzIDEuMCAoU2Vjb25kIEVkaXRpb24pPC9hPgoKPC9saT48bGk+WSA8YSBocmVmPSJodHRwOi8v d3d3LnczLm9yZy9UUi8yMDAxL1JFQy14bWwtYzE0bi0yMDAxMDMxNSIgdGFyZ2V0PSJfYmxhbmsi PkNhbm9uaWNhbCBYTUwgVmVyc2lvbiAxLjA8L2E+Cgo8L2xpPjxsaT5ZIDxhIGhyZWY9Imh0dHA6 Ly93d3cudzMub3JnL1RSLzIwMDgvUkVDLXhtbC1jMTRuMTEtMjAwODA1MDIvIiB0YXJnZXQ9Il9i bGFuayI+Q2Fub25pY2FsIFhNTCBWZXJzaW9uIDEuMTwvYT4KCjwvbGk+PGxpPlkgPGEgaHJlZj0i aHR0cDovL3d3dy53My5vcmcvVFIvMjAwNS9SRUMtY2hhcm1vZC0yMDA1MDIxNS8iIHRhcmdldD0i X2JsYW5rIj5DaGFyYWN0ZXIgTW9kZWwgZm9yIHRoZSBXb3JsZCBXaWRlIFdlYiAxLjA6IEZ1bmRh bWVudGFsczwvYT4KCjwvbGk+PGxpPlkgPGEgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvMjAw Mi9SRUMteG1sZW5jLWRlY3J5cHQtMjAwMjEyMTAiIHRhcmdldD0iX2JsYW5rIj5EZWNyeXB0aW9u IFRyYW5zZm9ybSBmb3IgWE1MIFNpZ25hdHVyZTwvYT4KCjwvbGk+PGxpPlkgPGEgaHJlZj0iaHR0 cDovL3d3dy53My5vcmcvVFIvMjAxNC9SRUMtZXhpLTIwMTQwMjExLyIgdGFyZ2V0PSJfYmxhbmsi PkVmZmljaWVudCBYTUwgSW50ZXJjaGFuZ2UgKEVYSSkgRm9ybWF0IDEuMCAoU2Vjb25kIEVkaXRp b24pPC9hPjwvbGk+Cgo8bGk+WSA8YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi8yMDAyL1JF Qy14bWwtZXhjLWMxNG4tMjAwMjA3MTgvIiB0YXJnZXQ9Il9ibGFuayI+RXhjbHVzaXZlIFhNTCBD YW5vbmljYWxpemF0b24gVmVyc2lvbiAxLjA8L2E+Cgo8L2xpPjxsaT5ZIDxhIGhyZWY9Imh0dHA6 Ly93d3cudzMub3JnL1RSLzIwMDgvUkVDLXhtbC0yMDA4MTEyNi8iIHRhcmdldD0iX2JsYW5rIj5F eHRlbnNpYmxlIE1hcmt1cCBMYW5ndWFnZSAoWE1MKSAxLjAgKEZpZnRoIEVkaXRpb24pPC9hPgoK PC9saT48bGk+WSA8YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi8yMDA2L1JFQy14bWwxMS0y MDA2MDgxNiIgdGFyZ2V0PSJfYmxhbmsiPkV4dGVuc2libGUgTWFya3VwIExhbmd1YWdlIChYTUwp IDEuMSAoU2Vjb25kIEVkaXRpb24pPC9hPgoKPC9saT48bGk+WSA8YSBocmVmPSJodHRwOi8vd3d3 LnczLm9yZy9UUi8yMDA2L1JFQy14c2wxMS0yMDA2MTIwNS8iIHRhcmdldD0iX2JsYW5rIj5FeHRl bnNpYmxlIFN0eWxlc2hlZXQgTGFuZ3VhZ2UgKFhTTCkgVmVyc2lvbiAxLjE8L2E+Cgo8L2xpPjxs aT5ZIDxhIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSLzIwMDEvUkVDLXhzbC0yMDAxMTAxNS8i IHRhcmdldD0iX2JsYW5rIj5FeHRlbnNpYmxlIFN0eWxlc2hlZXQgTGFuZ3VhZ2UgKFhTTCkgVmVy c2lvbiAxLjA8L2E+Cgo8L2xpPjxsaT5ZIDxhIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSLzIw MDcvUkVDLWl0cy0yMDA3MDQwMy8iIHRhcmdldD0iX2JsYW5rIj5JbnRlcm5hdGlvbmFsaXphdGlv biBUYWcgU2V0IChJVFMpIFZlcnNpb24gMS4wPC9hPgoKPC9saT48bGk+WSA8YSBocmVmPSJodHRw Oi8vd3d3LnczLm9yZy9UUi8yMDEzL1JFQy1pdHMyMC0yMDEzMTAyOS8iIHRhcmdldD0iX2JsYW5r Ij5JbnRlcm5hdGlvbmFsaXphdGlvbiBUYWcgU2V0IChJVFMpIFZlcnNpb24gMi4wPC9hPgoKPC9s aT48bGk+WSA8YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi8yMDA5L1JFQy14bWwtbmFtZXMt MjAwOTEyMDgvIiB0YXJnZXQ9Il9ibGFuayI+TmFtZXNwYWNlcyBpbiBYTUwgMS4wIChUaGlyZCBF ZGl0aW9uKTwvYT4KCjwvbGk+PGxpPlkgPGEgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvMjAw Ni9SRUMteG1sLW5hbWVzMTEtMjAwNjA4MTYiIHRhcmdldD0iX2JsYW5rIj5OYW1lc3BhY2VzIGlu IFhNTCAxLjEgKFNlY29uZCBFZGl0aW9uKTwvYT4KCjwvbGk+PGxpPlkgPGEgaHJlZj0iaHR0cDov L3d3dy53My5vcmcvVFIvMjAxMi9SRUMteG1sc2NoZW1hMTEtMS0yMDEyMDQwNS8iIHRhcmdldD0i X2JsYW5rIj5XM0MgWE1MIFNjaGVtYSBEZWZpbml0aW9uIExhbmd1YWdlIChYU0QpIDEuMSBQYXJ0 IDE6IFN0cnVjdHVyZXM8L2E+PC9saT4KCjxsaT5ZIDxhIGhyZWY9Imh0dHA6Ly93d3cudzMub3Jn L1RSLzIwMDkvUkVDLXhmb3Jtcy0yMDA5MTAyMC8iIHRhcmdldD0iX2JsYW5rIj5YRm9ybXMgMS4x PC9hPgoKPC9saT48bGk+WSA8YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi8yMDEwL1JFQy14 aHRtbC1tb2R1bGFyaXphdGlvbi0yMDEwMDcyOSIgdGFyZ2V0PSJfYmxhbmsiPlhIVE1MJnRyYWRl OyBNb2R1bGFyaXphdGlvbiAxLjEgLSBTZWNvbmQgRWRpdGlvbjwvYT4KCjwvbGk+PGxpPlkgPGEg aHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvMjAwOS9SRUMteG1sYmFzZS0yMDA5MDEyOC8iIHRh cmdldD0iX2JsYW5rIj5YTUwgQmFzZSAoU2Vjb25kIEVkaXRpb24pPC9hPgoKPC9saT48bGk+WSA8 YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi8yMDEzL1JFQy14bWxlbmMtY29yZTEtMjAxMzA0 MTEvIiB0YXJnZXQ9Il9ibGFuayI+WE1MIEVuY3J5cHRpb24gU3ludGF4IGFuZCBQcm9jZXNzaW5n IFZlcnNpb24gMS4xPC9hPgoKPC9saT48bGk+WSA8YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9U Ui8yMDA1L1JFQy14bWwtaWQtMjAwNTA5MDkvIiB0YXJnZXQ9Il9ibGFuayI+eG1sOmlkIFZlcnNp b24gMS4wPC9hPgoKPC9saT48bGk+WSA8YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi8yMDA2 L1JFQy14aW5jbHVkZS0yMDA2MTExNS8iIHRhcmdldD0iX2JsYW5rIj5YTUwgSW5jbHVzaW9ucyAo WEluY2x1ZGUpIFZlcnNpb24gMS4wIChTZWNvbmQgRWRpdGlvbik8L2E+Cgo8L2xpPjxsaT5ZIDxh IGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSLzIwMDQvUkVDLXhtbC1pbmZvc2V0LTIwMDQwMjA0 IiB0YXJnZXQ9Il9ibGFuayI+WE1MIEluZm9ybWF0aW9uIFNldCAoU2Vjb25kIEVkaXRpb24pPC9h PgoKPC9saT48bGk+WSA8YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi8yMDA1L1JFQy14a21z Mi1iaW5kaW5ncy0yMDA1MDYyOC8iIHRhcmdldD0iX2JsYW5rIj5YTUwgS2V5IE1hbmFnZW1lbnQg U3BlY2lmaWNhdGlvbiAoWEtNUyAyLjApIEJpbmRpbmdzPC9hPgoKPC9saT48bGk+WSA8YSBocmVm PSJodHRwOi8vd3d3LnczLm9yZy9UUi8yMDA1L1JFQy14a21zMi0yMDA1MDYyOC8iIHRhcmdldD0i X2JsYW5rIj5YTUwgS2V5IE1hbmFnZW1lbnQgU3BlY2lmaWNhdGlvbiAoWEtNUyAyLjApPC9hPgoK PC9saT48bGk+WSA8YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi8yMDAxL1JFQy14bGluay0y MDAxMDYyNy8iIHRhcmdldD0iX2JsYW5rIj5YTUwgTGlua2luZyBMYW5ndWFnZSAoWExpbmspIFZl cnNpb24gMS4wPC9hPgoKPC9saT48bGk+WSA8YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi8y MDEwL1JFQy14bGluazExLTIwMTAwNTA2LyIgdGFyZ2V0PSJfYmxhbmsiPlhNTCBMaW5raW5nIExh bmd1YWdlIChYTGluaykgVmVyc2lvbiAxLjE8L2E+Cgo8L2xpPjxsaT5ZIDxhIGhyZWY9Imh0dHA6 Ly93d3cudzMub3JnL1RSLzIwMTAvUkVDLXhwYXRoMjAtMjAxMDEyMTQvIiB0YXJnZXQ9Il9ibGFu ayI+WE1MIFBhdGggTGFuZ3VhZ2UgKFhQYXRoKSAyLjAgKFNlY29uZCBFZGl0aW9uKTwvYT4KCjwv bGk+Cgo8bGk+WSA8YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi8yMDEzL1JFQy14bWxkc2ln LXByb3BlcnRpZXMtMjAxMzA0MTEvIiB0YXJnZXQ9Il9ibGFuayI+WE1MIFNpZ25hdHVyZSBQcm9w ZXJ0aWVzPC9hPgoKPC9saT48bGk+WSA8YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi8yMDA4 L1JFQy14bWxkc2lnLWNvcmUtMjAwODA2MTAvIiB0YXJnZXQ9Il9ibGFuayI+WE1MIFNpZ25hdHVy ZSBTeW50YXggYW5kIFByb2Nlc3NpbmcgKFNlY29uZCBFZGl0aW9uKTwvYT4KCjwvbGk+PGxpPlkg PGEgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvMjAxMy9SRUMteG1sZHNpZy1jb3JlMS0yMDEz MDQxMS8iIHRhcmdldD0iX2JsYW5rIj5YTUwgU2lnbmF0dXJlIFN5bnRheCBhbmQgUHJvY2Vzc2lu ZyBWZXJzaW9uIDEuMTwvYT4KCjwvbGk+PGxpPlkgPGEgaHJlZj0iaHR0cDovL3d3dy53My5vcmcv VFIvMjAxMC9SRUMteHF1ZXJ5eC0yMDEwMTIxNC8iIHRhcmdldD0iX2JsYW5rIj5YTUwgU3ludGF4 IGZvciBYUXVlcnkgMS4wIChYUXVlcnlYKSAoU2Vjb25kIEVkaXRpb24pPC9hPgoKPC9saT48bGk+ WSA8YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi8yMDA1L1JFQy14b3AxMC0yMDA1MDEyNS8i IHRhcmdldD0iX2JsYW5rIj5YTUwtYmluYXJ5IE9wdGltaXplZCBQYWNrYWdpbmc8L2E+Cgo8L2xp PjxsaT5ZIDxhIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSLzIwMDIvUkVDLXhtbGRzaWctZmls dGVyMi0yMDAyMTEwOC8iIHRhcmdldD0iX2JsYW5rIj5YTUwtU2lnbmF0dXJlIFhQYXRoIEZpbHRl ciAyLjA8L2E+Cgo8L2xpPjxsaT5ZIDxhIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSLzIwMDMv UkVDLXhwdHItZWxlbWVudC0yMDAzMDMyNS8iIHRhcmdldD0iX2JsYW5rIj5YUG9pbnRlciBlbGVt ZW50KCkgU2NoZW1lPC9hPgoKPC9saT48bGk+WSA8YSBocmVmPSIiaHR0cDovL3d3dy53My5vcmcv VFIvMjAwMy9SRUMteHB0ci1mcmFtZXdvcmstMjAwMzAzMjUvPlhQb2ludGVyIEZyYW1ld29yazwv YT4KCjwvbGk+PGxpPlkgPGEgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvMjAwMy9SRUMteHB0 ci14bWxucy0yMDAzMDMyNS8iIHRhcmdldD0iX2JsYW5rIj5YUG9pbnRlciB4bWxucygpIFNjaGVt ZTwvYT4KCjwvbGk+PGxpPlkgPGEgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvMjAxMC9SRUMt eHByb2MtMjAxMDA1MTEvIiB0YXJnZXQ9Il9ibGFuayI+WFByb2M6IEFuIFhNTCBQaXBlbGluZSBM YW5ndWFnZTwvYT4KCjwvbGk+PGxpPlkgPGEgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvMjAx MC9SRUMteHF1ZXJ5LTIwMTAxMjE0LyIgdGFyZ2V0PSJfYmxhbmsiPlhRdWVyeSAxLjA6IEFuIFhN TCBRdWVyeSBMYW5ndWFnZSAoU2Vjb25kIEVkaXRpb24pPC9hPgoKPC9saT48bGk+WSA8YSBocmVm PSJodHRwOi8vd3d3LnczLm9yZy9UUi8yMDEwL1JFQy14cGF0aC1kYXRhbW9kZWwtMjAxMDEyMTQv IiB0YXJnZXQ9Il9ibGFuayI+WFF1ZXJ5IDEuMCBhbmQgWFBhdGggMi4wIERhdGEgTW9kZWwgKFhE TSkgKFNlY29uZCBFZGl0aW9uKTwvYT4KCjwvbGk+PGxpPlkgPGEgaHJlZj0iaHR0cDovL3d3dy53 My5vcmcvVFIvMjAxNC9SRUMteHF1ZXJ5LTMwLTIwMTQwNDA4LyIgdGFyZ2V0PSJfYmxhbmsiPlhR dWVyeSAzLjA6IEFuIFhNTCBRdWVyeSBMYW5ndWFnZTwvYT4KCjwvbGk+PGxpPlkgPGEgaHJlZj0i aHR0cDovL3d3dy53My5vcmcvVFIvMjAxNC9SRUMteHBhdGgtZGF0YW1vZGVsLTMwLTIwMTQwNDA4 LyIgdGFyZ2V0PSJfYmxhbmsiPlhRdWVyeSBhbmQgWFBhdGggRGF0YSBNb2RlbCAzLjA8L2E+Cgo8 L2xpPjxsaT5ZIDxhIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSLzIwMTEvUkVDLXhwYXRoLWZ1 bGwtdGV4dC0xMC0yMDExMDMxNy8iIHRhcmdldD0iX2JsYW5rIj5YUXVlcnkgYW5kIFhQYXRoIEZ1 bGwgVGV4dCAxLjA8L2E+Cgo8L2xpPjxsaT5ZIDxhIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RS LzIwMTEvUkVDLXhxdWVyeS11cGRhdGUtMTAtMjAxMTAzMTcvIiB0YXJnZXQ9Il9ibGFuayI+WFF1 ZXJ5IFVwZGF0ZSBGYWNpbGl0eSAxLjA8L2E+Cgo8L2xpPjxsaT5ZIDxhIGhyZWY9Imh0dHA6Ly93 d3cudzMub3JnL1RSLzIwMTQvUkVDLXhxdWVyeXgtMzAtMjAxNDA0MDgvIiB0YXJnZXQ9Il9ibGFu ayI+WFF1ZXJ5WCAzLjA8L2E+Cgo8L2xpPjxsaT5ZIDxhIGhyZWY9Imh0dHA6Ly93d3cudzMub3Jn L1RSLzIwMDcvUkVDLXhzbHQyMC0yMDA3MDEyMy8iIHRhcmdldD0iX2JsYW5rIj5YU0wgVHJhbnNm b3JtYXRpb25zIChYU0xUKSBWZXJzaW9uIDIuMDwvYT4KCjwvbGk+PGxpPlkgPGEgaHJlZj0iaHR0 cDovL3d3dy53My5vcmcvVFIvMjAxMC9SRUMteHNsdC14cXVlcnktc2VyaWFsaXphdGlvbi0yMDEw MTIxNC8iIHRhcmdldD0iX2JsYW5rIj5YU0xUIDIuMCBhbmQgWFF1ZXJ5IDEuMCBTZXJpYWxpemF0 aW9uIChTZWNvbmQgRWRpdGlvbik8L2E+Cgo8L2xpPjxsaT5ZIDxhIGhyZWY9Imh0dHA6Ly93d3cu dzMub3JnL1RSLzIwMTQvUkVDLXhzbHQteHF1ZXJ5LXNlcmlhbGl6YXRpb24tMzAtMjAxNDA0MDgv IiB0YXJnZXQ9Il9ibGFuayI+WFNMVCBhbmQgWFF1ZXJ5IFNlcmlhbGl6YXRpb24gMy4wPC9hPjwv bGk+Cgo8aDQ+UmVseSBvbiBvdGhlciBzdGFuZGFyZHMgdGhhdCBjaXRlIFJGQyAyMTE5PC9oND4K CjxsaT5OIDxhIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSLzIwMTQvUkVDLXhwYXRoLWZ1bmN0 aW9ucy0zMC0yMDE0MDQwOC8iIHRhcmdldD0iX2JsYW5rIj5YUGF0aCBhbmQgWFF1ZXJ5IEZ1bmN0 aW9ucyBhbmQgT3BlcmF0b3JzIDMuMDwvYT4gMS4xIENvbmZvcm1hbmNlICJUaGUgRnVuY3Rpb25z IGFuZCBPcGVyYXRvcnMgc3BlY2lmaWNhdGlvbiBpcyBpbnRlbmRlZCBwcmltYXJpbHkgYXMgYSBj b21wb25lbnQgdGhhdCBjYW4gYmUgdXNlZCBieSBvdGhlciBzcGVjaWZpY2F0aW9ucy4gVGhlcmVm b3JlLCBGdW5jdGlvbnMgYW5kIE9wZXJhdG9ycyByZWxpZXMgb24gc3BlY2lmaWNhdGlvbnMgdGhh dCB1c2UgaXQgKHN1Y2ggYXMgWzxhIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSL3hwYXRoLTMw LyIgdGFyZ2V0PSJfYmxhbmsiPlhNTCBQYXRoIExhbmd1YWdlIChYUGF0aCkgMy4wPC9hPl0sIFs8 YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi94c2x0LTMwLyIgdGFyZ2V0PSJfYmxhbmsiPlhT TCBUcmFuc2Zvcm1hdGlvbnMgKFhTTFQpIFZlcnNpb24gMy4wPC9hPl0gYW5kIFs8YSBocmVmPSJo dHRwOi8vd3d3LnczLm9yZy9UUi94cXVlcnktMzAvIiB0YXJnZXQ9Il9ibGFuayI+WFF1ZXJ5IDMu MDogQW4gWE1MIFF1ZXJ5IExhbmd1YWdlPC9hPl0pIHRvIHNwZWNpZnkgY29uZm9ybWFuY2UgY3Jp dGVyaWEgZm9yIHRoZWlyIHJlc3BlY3RpdmUgZW52aXJvbm1lbnRzLiI8L2xpPgoKPGxpPk4gPGEg aHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvMTk5OS9SRUMteHBhdGgtMTk5OTExMTYiIHRhcmdl dD0iX2JsYW5rIj5YTUwgUGF0aCBMYW5ndWFnZSAoWFBhdGgpIFZlcnNpb24gMS4wPC9hPiBDb25m b3JtYW5jZTogIlhQYXRoIGlzIGludGVuZGVkIHByaW1hcmlseSBhcyBhIGNvbXBvbmVudCB0aGF0 IGNhbiBiZSB1c2VkIGJ5IG90aGVyIHNwZWNpZmljYXRpb25zLiBUaGVyZWZvcmUsIFhQYXRoIHJl bGllcyBvbiBzcGVjaWZpY2F0aW9ucyB0aGF0IHVzZSBYUGF0aCAoc3VjaCBhcyBbPGEgaGVyZj0i aHR0cDovL3d3dy53My5vcmcvVFIvV0QteHB0ciIgdGFyZ2V0PSJfYmxhbmsiPlhQb2ludGVyPC9h Pl0gYW5kIFs8YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi94c2x0IiB0YXJnZXQ9Il9ibGFu ayI+WFNMVDwvYT5dKSB0byBzcGVjaWZ5IGNyaXRlcmlhIGZvciBjb25mb3JtYW5jZSBvZiBpbXBs ZW1lbnRhdGlvbnMgb2YgWFBhdGggYW5kIGRvZXMgbm90IGRlZmluZSBhbnkgY29uZm9ybWFuY2Ug Y3JpdGVyaWEgZm9yIGluZGVwZW5kZW50IGltcGxlbWVudGF0aW9ucyBvZiBYUGF0aC4iPC9saT4K CjxsaT5OIDxhIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSLzIwMTAvUkVDLXhxdWVyeS1zZW1h bnRpY3MtMjAxMDEyMTQvIiB0YXJnZXQ9Il9ibGFuayI+WFF1ZXJ5IDEuMCBhbmQgWFBhdGggMi4w IEZvcm1hbCBTZW1hbnRpY3MgKFNlY29uZCBFZGl0aW9uKTwvYT4gNiBDb25mb3JtYW5jZSAiVGhl IFhRdWVyeSBGb3JtYWwgU2VtYW50aWNzIGlzIGludGVuZGVkIHByaW1hcmlseSBhcyBhIGNvbXBv bmVudCB0aGF0IGNhbiBiZSB1c2VkIGJ5IFs8YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi8y MDEwL1JFQy14cXVlcnktMjAxMDEyMTQvIiB0YXJnZXQ9Il9ibGFuayI+WFF1ZXJ5IDEuMDogQW4g WE1MIFF1ZXJ5IExhbmd1YWdlIChTZWNvbmQgRWRpdGlvbik8L2E+XSwgb3IgYSBob3N0IGxhbmd1 YWdlIG9mIFs8YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi8yMDEwL1JFQy14cGF0aDIwLTIw MTAxMjE0LyIgdGFyZ2V0PSJfYmxhbmsiPlhNTCBQYXRoIExhbmd1YWdlIChYUGF0aCkgMi4wIChT ZWNvbmQgRWRpdGlvbik8L2E+XS4gVGhlcmVmb3JlLCB0aGUgWFF1ZXJ5IEZvcm1hbCBTZW1hbnRp Y3MgcmVsaWVzIG9uIHNwZWNpZmljYXRpb25zIHRoYXQgdXNlIGl0IChzdWNoIGFzIFtYUGF0aCAy LjBdLCBbWFNMVCAyLjBdLCBhbmQgW1hRdWVyeV0pIHRvIHNwZWNpZnkgY29uZm9ybWFuY2UgY3Jp dGVyaWEgaW4gdGhlaXIgcmVzcGVjdGl2ZSBlbnZpcm9ubWVudHMuIFNwZWNpZmljYXRpb25zIHRo YXQgc2V0IGNvbmZvcm1hbmNlIGNyaXRlcmlhIGZvciB0aGVpciB1c2Ugb2YgdGhlIGZvcm1hbCBz ZW1hbnRpY3MgbXVzdCBub3QgcmVsYXggdGhlIGNvbnN0cmFpbnRzIGV4cHJlc3NlZCBpbiB0aGlz IHNwZWNpZmljYXRpb24uIjwvbGk+Cgo8bGk+TiA8YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9U Ui8yMDEwL1JFQy14cGF0aC1mdW5jdGlvbnMtMjAxMDEyMTQvIiB0YXJnZXQ9Il9ibGFuayI+WFF1 ZXJ5IDEuMCBhbmQgWFBhdGggMi4wIEZ1bmN0aW9ucyBhbmQgT3BlcmF0b3JzIChTZWNvbmQgRWRp dGlvbik8L2E+IDEuMSBDb25mb3JtYW5jZSAiVGhlIEZ1bmN0aW9ucyBhbmQgT3BlcmF0b3JzIHNw ZWNpZmljYXRpb24gaXMgaW50ZW5kZWQgcHJpbWFyaWx5IGFzIGEgY29tcG9uZW50IHRoYXQgY2Fu IGJlIHVzZWQgYnkgb3RoZXIgc3BlY2lmaWNhdGlvbnMuIFRoZXJlZm9yZSwgRnVuY3Rpb25zIGFu ZCBPcGVyYXRvcnMgcmVsaWVzIG9uIHNwZWNpZmljYXRpb25zIHRoYXQgdXNlIGl0IChzdWNoIGFz IFs8YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi94cGF0aDIwLyIgdGFyZ2V0PSJfYmxhbmsi PlhNTCBQYXRoIExhbmd1YWdlIChYUGF0aCkgMi4wPC9hPl0sIFs8YSBocmVmPSJodHRwOi8vd3d3 LnczLm9yZy9UUi94c2x0MjAvIiB0YXJnZXQ9Il9ibGFuayI+WFNMIFRyYW5zZm9ybWF0aW9ucyAo WFNMVCkgVmVyc2lvbiAyLjA8L2E+XSBhbmQgWzxhIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RS L3hxdWVyeS8iIHRhcmdldD0iX2JsYW5rIj5YUXVlcnkgMS4wOiBBbiBYTUwgUXVlcnkgTGFuZ3Vh Z2U8L2E+XSkgdG8gc3BlY2lmeSBjb25mb3JtYW5jZSBjcml0ZXJpYSBmb3IgdGhlaXIgcmVzcGVj dGl2ZSBlbnZpcm9ubWVudHMuIjwvbGk+Cgo8aDQ+UG9zc2libGUgRXJyb3JzIGluIG9taXR0aW5n IFJGQyAyMTE5PC9oND4KCjxsaT5OIDxhIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSLzIwMTQv UkVDLWV4aS1wcm9maWxlLTIwMTQwOTA5LyIgdGFyZ2V0PSJfYmxhbmsiPkVmZmljaWVudCBYTUwg SW50ZXJjaGFuZ2UgKEVYSSkgUHJvZmlsZSBmb3IgbGltaXRpbmcgdXNhZ2Ugb2YgZHluYW1pYyBt ZW1vcnk8L2E+IFByb2ZpbGUgb2YgRVhJIEZvcm1hdCAxLjAgYnV0IG5vIGNpdGF0aW9uIG9mIFJG QzIxMTkuIERvZXMgdXNlIG1peGVkIHVwcGVyIGFuZCBsb3dlciBjYXNlICJtdXN0LiI8L2xpPgoK PGxpPk4gPGEgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvMjAxNC9SRUMteHBhdGgtMzAtMjAx NDA0MDgvIiB0YXJnZXQ9Il9ibGFuayI+WE1MIFBhdGggTGFuZ3VhZ2UgKFhQYXRoKSAzLjA8L2E+ IFJGQyAyMTE5IGFwcGVhcnMgaW4gbm9ybWF0aXZlIHJlZmVyZW5jZXMgYnV0IG5ldmVyIGNpdGVk IGluIHRoZSB0ZXh0LjwvbGk+Cgo8bGk+TiA8YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi8x OTk5L1JFQy14c2x0LTE5OTkxMTE2IiB0YXJnZXQ9Il9ibGFuayI+WFNMIFRyYW5zZm9ybWF0aW9u cyAoWFNMVCkgVmVyc2lvbiAxLjA8L2E+ICh1c2VzICJtdXN0IiBidXQgYWxsIGxvd2VyIGNhc2Uu IFNlZSAxNyBmb3IgImNvbmZvcm1hbmNlLiI8L2xpPgoKPGg0PkRvIE5vdCBGb2xsb3cgUkZDIDIx MTk8L2g0PgoKPGxpPk4gPGEgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvMjAwMC9SRUMteG1s LTIwMDAxMDA2IiB0YXJnZXQ9Il9ibGFuayI+RXh0ZW5zaWJsZSBNYXJrdXAgTGFuZ3VhZ2UgKFhN TCkgMS4wIChTZWNvbmQgRWRpdGlvbik8L2E+PC9saT4KCgo8bGk+TiA8YSBocmVmPSJodHRwOi8v d3d3LnczLm9yZy9UUi8yMDA0L1JFQy14bWxzY2hlbWEtMS0yMDA0MTAyOC8iIHRhcmdldD0iX2Js YW5rIj5YTUwgU2NoZW1hIFBhcnQgMTogU3RydWN0dXJlcyBTZWNvbmQgRWRpdGlvbjwvYT48L2xp PgoKPGxpPk4gPGEgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvMjAwNC9SRUMteG1sc2NoZW1h LTItMjAwNDEwMjgvIiB0YXJnZXQ9Il9ibGFuayI+WE1MIFNjaGVtYSBQYXJ0IDI6IERhdGF0eXBl cyBTZWNvbmQgRWRpdGlvbjwvYT48L2xpPgoKPGxpPk4gPGEgaHJlZj0iaHR0cDovL3d3dy53My5v cmcvVFIvMjAxMi9SRUMteG1sc2NoZW1hMTEtMi0yMDEyMDQwNS8iIHRhcmdldD0iX2JsYW5rIj5X M0MgWE1MIFNjaGVtYSBEZWZpbml0aW9uIExhbmd1YWdlIChYU0QpIDEuMSBQYXJ0IDI6IERhdGF0 eXBlczwvYT48L2xpPgo8L3VsPgo=