PHVsPgogIDxsaT48YSBocmVmPSIjSW50cm9kdWN0aW9uIj5JbnRyb2R1Y3Rpb248L2E+PC9saT4KICA8bGk+PGEgaHJlZj0iI0NTTVMtSG93LUl0LVdvcmtzIj5JbnNpZGUgdGhlIENoZW1pY2FsIFNhZmV0eSBNYW5hZ2VtZW50IFN5c3RlbTogSG93IEl0IFdvcmtzIGFuZCBXaHkgSXQgTWF0dGVyczwvYT48L2xpPgogIDxsaT48YSBocmVmPSIjQ1NNUy1JbmR1c3RyeS1BcHBsaWNhdGlvbnMiPkNTTVMgaW4gQWN0aW9uOiBJbmR1c3RyeSBBcHBsaWNhdGlvbnMsIENoYWxsZW5nZXMgYW5kIENTTVMgUm9sZXM8L2E+PC9saT4KICA8bGk+PGEgaHJlZj0iI0NTTVMtS2V5LUZlYXR1cmVzIj5LZXkgRmVhdHVyZXMgb2YgYSBDaGVtaWNhbCBTYWZldHkgTWFuYWdlbWVudCBTeXN0ZW08L2E+PC9saT4KICA8bGk+PGEgaHJlZj0iI0NTTVMtQ29tcGxpYW5jZSI+V2h5IFVTIEJ1c2luZXNzZXMgQ2Fu4oCZdCBBZmZvcmQgdG8gT3Zlcmxvb2sgQ1NNUyBDb21wbGlhbmNlPC9hPjwvbGk+CiAgPGxpPjxhIGhyZWY9IiNDaGFpbi1vZi1DdXN0b2R5Ij5CcmVha2luZyBEb3duIHRoZSBDaGFpbiBvZiBDdXN0b2R5IFByb2NlZHVyZTwvYT48L2xpPgo8L3VsPgo=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PHNlY3Rpb24gaWQ9IkNTTVMtS2V5LUZlYXR1cmVzIj4KICA8aDI+S2V5IEZlYXR1cmVzIG9mIGEgQ2hlbWljYWwgU2FmZXR5IE1hbmFnZW1lbnQgU3lzdGVtPC9oMj4KICA8cD5JZiBhbnkgb3JnYW5pemF0aW9uIGlzIGV2YWx1YXRpbmcgQ1NNUyBvcHRpb25zLCBpdOKAmXMgZXNzZW50aWFsIHRvIHVuZGVyc3RhbmQgdGhlIGZlYXR1cmVzIHRoYXQgdHJ1bHkgYWRkIHZhbHVlLiBUaGUgZm9sbG93aW5nIGd1aWRlIGhpZ2hsaWdodHMgdGhlIGNvcmUgY2FwYWJpbGl0aWVzIGV2ZXJ5IG1vZGVybiBDU01TIHNob3VsZCBvZmZlciB0byBlbnN1cmUgY2hlbWljYWwgc2FmZXR5LCBzdHJlYW1saW5lIHdvcmtmbG93cywgYW5kIHByb3RlY3QgYm90aCBwZW9wbGUgYW5kIHRoZSBlbnZpcm9ubWVudC48L3A+CiAgPHVsPgogICAgPGxpPjxzdHJvbmc+Q2xvdWQtQmFzZWQgQWNjZXNzOjwvc3Ryb25nPiBDU01TIHByb3ZpZGVzIGEgdmlldyBvZiB3aGF0IGlzIGdvaW5nIG9uIHJlbW90ZWx5IGFuZCB1cGRhdGVzIGluIHJlYWwgdGltZS48L2xpPgogICAgPGxpPjxzdHJvbmc+TW9iaWxlIENvbXBhdGliaWxpdHk6PC9zdHJvbmc+IEFjY2VzcyB0aGUgTG9vayBVcCBTRFMgb3IgaGF6YXJkIGRhdGEgdmlhIG1vYmlsZSBkZXZpY2VzIGFzIHNvb24gYXMgcG9zc2libGUuPC9saT4KICAgIDxsaT48c3Ryb25nPlJlZ3VsYXRvcnkgQ29tcGxpYW5jZSBUb29sczo8L3N0cm9uZz4gT1NIQSwgRVBBIGFuZCBET1QgY29tcGxpYW5jZSBjaGVja3MgYnVpbHQtaW4uPC9saT4KICAgIDxsaT48c3Ryb25nPkF1dG9tYXRlZCBBbGVydHM6PC9zdHJvbmc+IEV4cGlyZWQgY2hlbWljYWxzLCBsb3cgcXVhbnRpdHkgbGV2ZWxzLCBhbmQgdHJhaW5pbmcgZHVlIGRhdGVzLjwvbGk+CiAgICA8bGk+PHN0cm9uZz5JbnRlZ3JhdGlvbiBDYXBhYmlsaXRpZXM6PC9zdHJvbmc+IENvbXBsaW1lbnRzIGFueSBFUlAsIExJTVMgb3IgRUhTIG1hbmFnZW1lbnQgc3lzdGVtLjwvbGk+CiAgPC91bD4KPC9zZWN0aW9uPg==PHNlY3Rpb24gaWQ9IkNTTVMtQ29tcGxpYW5jZSI+CiAgPGgyPldoeSBVUyBCdXNpbmVzc2VzIENhbuKAmXQgQWZmb3JkIHRvIE92ZXJsb29rIENTTVMgQ29tcGxpYW5jZTwvaDI+CiAgPHVsPgogICAgPGxpPjxzdHJvbmc+UmVndWxhdG9yeSBQcmVzc3VyZTo8L3N0cm9uZz4gT1NIQSBmaW5lcyBmb3IgY2hlbWljYWwgc2FmZXR5IHZpb2xhdGlvbnMgY2FuIGJlIHVwIHRvICQxNiwxMzEgcGVyIGluY2lkZW50IChpbiAyMDI1KS48L2xpPgogICAgPGxpPjxzdHJvbmc+T3BlcmF0aW9uYWwgQ29udGludWl0eTo8L3N0cm9uZz4gQ1NNUyByZWR1Y2VzIHRoZSByaXNrIG9mIHNhZmV0eSB2aW9sYXRpb25zIG9yIGluc3BlY3Rpb24gZmFpbHVyZXMgdGhhdCBjb3VsZCBkaXNydXB0IG9wZXJhdGlvbnMuPC9saT4KICAgIDxsaT48c3Ryb25nPkJyYW5kIFByb3RlY3Rpb246PC9zdHJvbmc+IEEgc2luZ2xlIGhhemFyZG91cyByZWxlYXNlIGNhbiBsZWFkIHRvIGxvc2luZyBjdXN0b21lciB0cnVzdC48L2xpPgogIDwvdWw+CiAgPHA+VGhpcyBjaGFpbiBvZiBjdXN0b2R5IGNhbiBiZSBwcmVzZXJ2ZWQgZHVyaW5nIHByb3NlY3V0aW9uLCBidXQgb3V0c2lkZSBvZiB0aGF0IGVuZm9yY2VtZW50IGNvbnRleHQgdGhlcmUgYXJlIG1vcmUgdGhhbiBoYWxmIGEgZG96ZW4gcHJvcG9zZWQgdXNlcyBmb3IgdGhpcyB2YWx1ZSBwcm9wb3NpdGlvbiBpbiB2YXJpb3VzIHN0YWdlcyBvZiBkZXBsb3ltZW50LjwvcD4KPC9zZWN0aW9uPg==PHNlY3Rpb24gaWQ9IkNoYWluLW9mLUN1c3RvZHkiPgogIDxoMj5CcmVha2luZyBEb3duIHRoZSBDaGFpbiBvZiBDdXN0b2R5IFByb2NlZHVyZTwvaDI+CiAgPHA+VGhpcyBjaGFpbiBvZiBjdXN0b2R5IGNhbiBiZSBwcmVzZXJ2ZWQgZHVyaW5nIHByb3NlY3V0aW9uLiBTdGlsbCwgb3V0c2lkZSBvZiB0aGF0IGVuZm9yY2VtZW50IGNvbnRleHQsIHRoZXJlIGFyZSBtb3JlIHRoYW4gaGFsZiBhIGRvemVuIHByb3Bvc2VkIHVzZXMgZm9yIHRoaXMgdmFsdWUgcHJvcG9zaXRpb24gaW4gdmFyaW91cyBzdGFnZXMgb2YgZGVwbG95bWVudC4gQnJlYWtpbmcgZG93biB0aGUgcHJvY2VzcyBpbnRvIGNsZWFyLCBhY3Rpb25hYmxlIHN0ZXBzIGhlbHBzIGJ1c2luZXNzZXMgbWFpbnRhaW4gY29udHJvbCBmcm9tIGFjcXVpc2l0aW9uIHRvIGRpc3Bvc2FsLjwvcD4KICA8dWw+CiAgICA8bGk+PHN0cm9uZz5FdmFsdWF0ZSBDdXJyZW50IENoZW1pY2FsIE1hbmFnZW1lbnQ6PC9zdHJvbmc+IENTTVMgZmluZHMgdGhlIGdhcHMgYW5kIHBlcmZvcm1zIHJpc2sgYXNzZXNzbWVudHMuPC9saT4KICAgIDxsaT48c3Ryb25nPlBpY2sgYSBTY2FsYWJsZSBTeXN0ZW06PC9zdHJvbmc+IEVuc3VyZXMgaXQgY2FuIHNjYWxlIHdpdGggeW91ciBidXNpbmVzcyBvcGVyYXRpb25zLjwvbGk+CiAgICA8bGk+PHN0cm9uZz5FbmdhZ2UgTWFqb3IgU3Rha2Vob2xkZXJzOjwvc3Ryb25nPiBJbnZvbHZlcyBFSFMgbWFuYWdlcnMsIG9wZXJhdGlvbnMgbWFuYWdlbWVudCBhbmQgSVQgbWFuYWdlbWVudC48L2xpPgogICAgPGxpPjxzdHJvbmc+T2ZmZXIgQWRkaXRpb25hbCBUcmFpbmluZzo8L3N0cm9uZz4gRW5zdXJlcyBlbXBsb3llZXMga25vdyBob3cgdG8gdXNlIHRoZSBzeXN0ZW0gcHJvcGVybHkuPC9saT4KICAgIDxsaT48c3Ryb25nPkF1ZGl0ICYgVXBkYXRlOjwvc3Ryb25nPiBIZWxwcyBydW4gYXVkaXRzIGFuZCB1cGRhdGUgdGhlIHN5c3RlbSBwZXJpb2RpY2FsbHkuPC9saT4KICA8L3VsPgo8L3NlY3Rpb24+
