PGgyPlRhYmxlIG9mIENvbnRlbnRzPC9oMj4KPG9sPgogIDxsaT48YSBocmVmPSIjaW50cm9kdWN0aW9uIj5JbnRyb2R1Y3Rpb248L2E+PC9saT4KICA8bGk+PGEgaHJlZj0iI2NoZW1pY2FsLXByb3BlcnRpZXMtYW5kLXBoeXNpY2FsLWNoYXJhY3RlcmlzdGljcyI+Q2hlbWljYWwgUHJvcGVydGllcyBhbmQgUGh5c2ljYWwgQ2hhcmFjdGVyaXN0aWNzPC9hPgogICAgPG9sPgogICAgICA8bGk+PGEgaHJlZj0iI2Jhc2ljLXByb3BlcnRpZXMiPkJhc2ljIFByb3BlcnRpZXM8L2E+PC9saT4KICAgICAgPGxpPjxhIGhyZWY9IiNwaHlzaWNhbC1wcm9wZXJ0aWVzIj5QaHlzaWNhbCBQcm9wZXJ0aWVzPC9hPjwvbGk+CiAgICAgIDxsaT48YSBocmVmPSIjY2hlbWljYWwtcmVhY3Rpdml0eSI+Q2hlbWljYWwgUmVhY3Rpdml0eTwvYT48L2xpPgogICAgPC9vbD4KICA8L2xpPgogIDxsaT48YSBocmVmPSIjcHJvZHVjdGlvbi1hbmQtbWFudWZhY3R1cmluZy1pbmR1c3RyaWFsLXByb2R1Y3Rpb24tbWV0aG9kcyI+UHJvZHVjdGlvbiBhbmQgTWFudWZhY3R1cmluZzogSW5kdXN0cmlhbCBQcm9kdWN0aW9uIE1ldGhvZHM8L2E+CiAgICA8b2w+CiAgICAgIDxsaT48YSBocmVmPSIjbWVtYnJhbmUtY2VsbC10ZWNobm9sb2d5Ij5NZW1icmFuZSBDZWxsIFRlY2hub2xvZ3k8L2E+PC9saT4KICAgICAgPGxpPjxhIGhyZWY9IiNkaWFwaHJhZ20tY2VsbC10ZWNobm9sb2d5Ij5EaWFwaHJhZ20gQ2VsbCBUZWNobm9sb2d5PC9hPjwvbGk+CiAgICAgIDxsaT48YSBocmVmPSIjbWVyY3VyeS1jZWxsLXRlY2hub2xvZ3kiPk1lcmN1cnkgQ2VsbCBUZWNobm9sb2d5PC9hPjwvbGk+CiAgICAgIDxsaT48YSBocmVmPSIjcHJvZHVjdGlvbi1jaGVtaXN0cnkiPlByb2R1Y3Rpb24gQ2hlbWlzdHJ5PC9hPjwvbGk+CiAgICA8L29sPgogIDwvbGk+CiAgPGxpPjxhIGhyZWY9IiNtYWpvci11c2VzLWFuZC1hcHBsaWNhdGlvbnMtaW5kdXN0cmlhbC1hcHBsaWNhdGlvbnMiPk1ham9yIFVzZXMgYW5kIEFwcGxpY2F0aW9uczogSW5kdXN0cmlhbCBBcHBsaWNhdGlvbnM8L2E+CiAgICA8b2w+CiAgICAgIDxsaT48YSBocmVmPSIjY2hlbWljYWwtbWFudWZhY3R1cmluZyI+Q2hlbWljYWwgTWFudWZhY3R1cmluZzwvYT48L2xpPgogICAgICA8bGk+PGEgaHJlZj0iI3NwZWNpYWxpemVkLWluZHVzdHJpZXMiPlNwZWNpYWxpemVkIEluZHVzdHJpZXM8L2E+PC9saT4KICAgICAgPGxpPjxhIGhyZWY9IiNhZ3JpY3VsdHVyYWwtYXBwbGljYXRpb25zIj5BZ3JpY3VsdHVyYWwgQXBwbGljYXRpb25zPC9hPjwvbGk+CiAgICAgIDxsaT48YSBocmVmPSIjd2F0ZXItdHJlYXRtZW50LWFuZC1kaXNpbmZlY3Rpb24iPldhdGVyIFRyZWF0bWVudCBhbmQgRGlzaW5mZWN0aW9uPC9hPjwvbGk+CiAgICA8L29sPgogIDwvbGk+CiAgPGxpPjxhIGhyZWY9IiNoZWFsdGgtaGF6YXJkcy1hbmQtdG94aWNvbG9naWNhbC1lZmZlY3RzIj5IZWFsdGggSGF6YXJkcyBhbmQgVG94aWNvbG9naWNhbCBFZmZlY3RzPC9hPgogICAgPG9sPgogICAgICA8bGk+PGEgaHJlZj0iI2FjdXRlLWhlYWx0aC1lZmZlY3RzIj5BY3V0ZSBIZWFsdGggRWZmZWN0czwvYT48L2xpPgogICAgICA8bGk+PGEgaHJlZj0iI29jY3VwYXRpb25hbC1leHBvc3VyZS1saW1pdHMiPk9jY3VwYXRpb25hbCBFeHBvc3VyZSBMaW1pdHM8L2E+PC9saT4KICAgICAgPGxpPjxhIGhyZWY9IiNjaHJvbmljLWhlYWx0aC1lZmZlY3RzIj5DaHJvbmljIEhlYWx0aCBFZmZlY3RzPC9hPjwvbGk+CiAgICA8L29sPgogIDwvbGk+CiAgPGxpPjxhIGhyZWY9IiNzYWZldHktcHJvdG9jb2xzLWFuZC1wZXJzb25hbC1wcm90ZWN0aXZlLWVxdWlwbWVudCI+U2FmZXR5IFByb3RvY29scyBhbmQgUGVyc29uYWwgUHJvdGVjdGl2ZSBFcXVpcG1lbnQ8L2E+CiAgICA8b2w+CiAgICAgIDxsaT48YSBocmVmPSIjcGVyc29uYWwtcHJvdGVjdGl2ZS1lcXVpcG1lbnQtcmVxdWlyZW1lbnRzIj5QZXJzb25hbCBQcm90ZWN0aXZlIEVxdWlwbWVudCBSZXF1aXJlbWVudHM8L2E+PC9saT4KICAgICAgPGxpPjxhIGhyZWY9IiNzYWZlLWhhbmRsaW5nLXByb2NlZHVyZXMiPlNhZmUgSGFuZGxpbmcgUHJvY2VkdXJlczwvYT48L2xpPgogICAgICA8bGk+PGEgaHJlZj0iI2ltbWVkaWF0ZS1yZXNwb25zZS1wcm9jZWR1cmVzIj5JbW1lZGlhdGUgUmVzcG9uc2UgUHJvY2VkdXJlczwvYT48L2xpPgogICAgPC9vbD4KICA8L2xpPgogIDxsaT48YSBocmVmPSIjZGV0ZWN0aW9uLWFuZC1tb25pdG9yaW5nLXN5c3RlbXMiPkRldGVjdGlvbiBhbmQgTW9uaXRvcmluZyBTeXN0ZW1zPC9hPgogICAgPG9sPgogICAgICA8bGk+PGEgaHJlZj0iI2dhcy1kZXRlY3Rpb24tdGVjaG5vbG9naWVzIj5HYXMgRGV0ZWN0aW9uIFRlY2hub2xvZ2llczwvYT48L2xpPgogICAgICA8bGk+PGEgaHJlZj0iI2ZpeGVkLW1vbml0b3Jpbmctc3lzdGVtcyI+Rml4ZWQgTW9uaXRvcmluZyBTeXN0ZW1zPC9hPjwvbGk+CiAgICA8L29sPgogIDwvbGk+CiAgPGxpPjxhIGhyZWY9IiNlbnZpcm9ubWVudGFsLWltcGFjdC1tYW5hZ2VtZW50Ij5FbnZpcm9ubWVudGFsIEltcGFjdCBNYW5hZ2VtZW50PC9hPgogICAgPG9sPgogICAgICA8bGk+PGEgaHJlZj0iI2VtaXNzaW9uLWNvbnRyb2wiPkVtaXNzaW9uIENvbnRyb2w8L2E+PC9saT4KICAgICAgPGxpPjxhIGhyZWY9IiN3YXN0ZS1tYW5hZ2VtZW50Ij5XYXN0ZSBNYW5hZ2VtZW50PC9hPjwvbGk+CiAgICAgIDxsaT48YSBocmVmPSIjc3VzdGFpbmFibGUtYWx0ZXJuYXRpdmVzIj5TdXN0YWluYWJsZSBBbHRlcm5hdGl2ZXM8L2E+PC9saT4KICAgIDwvb2w+CiAgPC9saT4KICA8bGk+PGEgaHJlZj0iI2NvbmNsdXNpb24iPkNvbmNsdXNpb248L2E+PC9saT4KPC9vbD4KPGgyIGlkPSJpbnRyb2R1Y3Rpb24iPkludHJvZHVjdGlvbjwvaDI+CjxwPgogIENobG9yaW5lIHN0YW5kcyBhcyBvbmUgb2YgdGhlIG1vc3QgdmVyc2F0aWxlIGFuZCBpbXBvcnRhbnQgY2hlbWljYWwgZWxlbWVudHMgaW4gbW9kZXJuIGluZHVzdHJ5IGFuZCBwdWJsaWMgaGVhbHRoLiAKICBUaGlzIHBhbGUgeWVsbG93LWdyZWVuIGdhcyBoYXMgcmV2b2x1dGlvbml6ZWQgd2F0ZXIgdHJlYXRtZW50LCBpbmR1c3RyaWFsIHByb2Nlc3NlcywgYW5kIGNvdW50bGVzcyBhcHBsaWNhdGlvbnMgdGhhdCAKICBzYWZlZ3VhcmQgaHVtYW4gaGVhbHRoIGFuZCBhZHZhbmNlIHRlY2hub2xvZ2ljYWwgY2FwYWJpbGl0aWVzLiBIb3dldmVyLCBpdHMgaW1tZW5zZSB1dGlsaXR5IGNvbWVzIHdpdGggc2lnbmlmaWNhbnQgaGF6YXJkcyAKICB0aGF0IHJlcXVpcmUgY2FyZWZ1bCB1bmRlcnN0YW5kaW5nIGFuZCByaWdvcm91cyBzYWZldHkgcHJvdG9jb2xzLgo8L3A+Cg==PGgyIGlkPSJjaGVtaWNhbC1wcm9wZXJ0aWVzLWFuZC1waHlzaWNhbC1jaGFyYWN0ZXJpc3RpY3MiPkNoZW1pY2FsIFByb3BlcnRpZXMgYW5kIFBoeXNpY2FsIENoYXJhY3RlcmlzdGljczwvaDI+CjxwPgogIENobG9yaW5lIHJlbWFpbnMgYW4gaW5kaXNwZW5zYWJsZSBjaGVtaWNhbCBpbiBtb2Rlcm4gc29jaWV0eSwgcHJvdmlkaW5nIGNyaXRpY2FsIGJlbmVmaXRzIGZvciBwdWJsaWMgaGVhbHRoIHRocm91Z2ggd2F0ZXIgZGlzaW5mZWN0aW9uIGFuZCBlbmFibGluZyBjb3VudGxlc3MgaW5kdXN0cmlhbCBwcm9jZXNzZXMuIEhvd2V2ZXIsIGl0cyBpbmhlcmVudCBoYXphcmRzIGRlbWFuZCB1bndhdmVyaW5nIGNvbW1pdG1lbnQgdG8gc2FmZXR5IHByb3RvY29scywgcHJvcGVyIHRyYWluaW5nLCBhbmQgcmVndWxhdG9yeSBjb21wbGlhbmNlLiBMZXQncyB1bmRlcnN0YW5kIHRoZSBiYXNpYyBwcm9wZXJ0aWVzIGZpcnN0Ogo8L3A+Cgo8aDMgaWQ9ImJhc2ljLXByb3BlcnRpZXMiPkJhc2ljIFByb3BlcnRpZXM8L2gzPgo8cD4KICBDaGxvcmluZSAoQ2zigoIpIGlzIGEgaGFsb2dlbiBlbGVtZW50IHdpdGggYXRvbWljIG51bWJlciAxNyBhbmQgbW9sZWN1bGFyIHdlaWdodCBvZiA3MC45MDYgZy9tb2wuIFVuZGVyIHN0YW5kYXJkIGNvbmRpdGlvbnMsIGNobG9yaW5lIGV4aXN0cyBhcyBhIGdyZWVuaXNoLXllbGxvdyBnYXMgd2l0aCBhIGNoYXJhY3RlcmlzdGljIHB1bmdlbnQsIGlycml0YXRpbmcgb2RvciB0aGF0IGJlY29tZXMgZGV0ZWN0YWJsZSBhdCBjb25jZW50cmF0aW9ucyBhcyBsb3cgYXMgMC4yNeKAkzAuNCBwcG0uIFRoZSBnYXMgaXMgYXBwcm94aW1hdGVseSAyLjUgdGltZXMgaGVhdmllciB0aGFuIGFpciwgY2F1c2luZyBpdCB0byBzZXR0bGUgaW4gbG93LWx5aW5nIGFyZWFzIHVubGVzcyBkaXNwZXJzZWQgYnkgd2luZC4KPC9wPgoKPGgzIGlkPSJwaHlzaWNhbC1wcm9wZXJ0aWVzIj5QaHlzaWNhbCBQcm9wZXJ0aWVzPC9oMz4KPHA+CiAgQ2hsb3JpbmUgaGFzIGRpc3RpbmN0IHBoeXNpY2FsIGNoYXJhY3RlcmlzdGljcyB0aGF0IGFyZSBjcnVjaWFsIGZvciBzYWZlIGhhbmRsaW5nOgo8L3A+Cjx1bD4KICA8bGk+PHN0cm9uZz5NZWx0aW5nIHBvaW50Ojwvc3Ryb25nPiAtMTAxLjDCsEMgKC0xNDkuOMKwRik8L2xpPgogIDxsaT48c3Ryb25nPkJvaWxpbmcgcG9pbnQ6PC9zdHJvbmc+IC0zNC4wwrBDICgtMjkuMsKwRik8L2xpPgogIDxsaT48c3Ryb25nPkRlbnNpdHk6PC9zdHJvbmc+IDMuMjE0IGcvTCBhdCBzdGFuZGFyZCBjb25kaXRpb25zPC9saT4KICA8bGk+PHN0cm9uZz5Tb2x1YmlsaXR5Ojwvc3Ryb25nPiBQb29ybHkgc29sdWJsZSBpbiB3YXRlciAoMC4zJSB0byAwLjclKSBkZXBlbmRpbmcgb24gdGVtcGVyYXR1cmU8L2xpPgo8L3VsPgo8cD4KICBUaGUgZWxlbWVudCB0cmFuc2l0aW9ucyBmcm9tIGdhcyB0byBsaXF1aWQgdW5kZXIgcHJlc3N1cmUsIHdpdGggbGlxdWlkIGNobG9yaW5lIGFwcGVhcmluZyBhcyBhIGNsZWFyLCBhbWJlci1jb2xvcmVkIHN1YnN0YW5jZS4KPC9wPgoKPGgzIGlkPSJjaGVtaWNhbC1yZWFjdGl2aXR5Ij5DaGVtaWNhbCBSZWFjdGl2aXR5PC9oMz4KPHA+CiAgQ2hsb3JpbmUgaXMgaGlnaGx5IHJlYWN0aXZlIGFuZCBzZXJ2ZXMgYXMgYSBzdHJvbmcgb3hpZGl6aW5nIGFnZW50LiBJdCByZWFkaWx5IGZvcm1zIGNvbXBvdW5kcyB3aXRoIG5lYXJseSBhbGwgb3RoZXIgZWxlbWVudHMgZHVlIHRvIGl0cyBoaWdoIGVsZWN0cm9uZWdhdGl2aXR5ICgzLjE2KS4gS2V5IHJlYWN0aXZpdHkgY2hhcmFjdGVyaXN0aWNzIGluY2x1ZGU6CjwvcD4KPHVsPgogIDxsaT48c3Ryb25nPk94aWRhdGlvbiBzdGF0ZXM6PC9zdHJvbmc+IFR5cGljYWxseSAtMSwgYnV0IGNhbiByYW5nZSBmcm9tICsxIHRvICs3PC9saT4KICA8bGk+PHN0cm9uZz5GbGFtbWFiaWxpdHk6PC9zdHJvbmc+IE5vbi1mbGFtbWFibGUgYnV0IHN1cHBvcnRzIGNvbWJ1c3Rpb248L2xpPgogIDxsaT48c3Ryb25nPkV4cGxvc2l2ZSByZWFjdGlvbnM6PC9zdHJvbmc+IEZvcm1zIGV4cGxvc2l2ZSBjb21wb3VuZHMgd2l0aCBhY2V0eWxlbmUsIGV0aGVyLCB0dXJwZW50aW5lLCBhbW1vbmlhLCBoeWRyb2dlbiwgYW5kIGZpbmVseSBkaXZpZGVkIG1ldGFsczwvbGk+CjwvdWw+Cg==PGgyIGlkPSJwcm9kdWN0aW9uLWFuZC1tYW51ZmFjdHVyaW5nLWluZHVzdHJpYWwtcHJvZHVjdGlvbi1tZXRob2RzIj5Qcm9kdWN0aW9uIGFuZCBNYW51ZmFjdHVyaW5nOiBJbmR1c3RyaWFsIFByb2R1Y3Rpb24gTWV0aG9kczwvaDI+CjxwPgogIE1vc3QgY2hsb3JpbmUgaXMgbWFudWZhY3R1cmVkIHRocm91Z2ggZWxlY3Ryb2x5dGljIHByb2Nlc3NlcyB1c2luZyB0aHJlZSBwcmltYXJ5IHRlY2hub2xvZ2llczoKPC9wPgoKPGgzIGlkPSJtZW1icmFuZS1jZWxsLXRlY2hub2xvZ3kiPk1lbWJyYW5lIENlbGwgVGVjaG5vbG9neTwvaDM+CjxwPgogIFRoZSBtZW1icmFuZSBjZWxsIHByb2Nlc3MgdXNlcyBwZXJmbHVvcmluYXRlZCBwb2x5bWVyIGlvbiBleGNoYW5nZSBtZW1icmFuZXMgdG8gc2VwYXJhdGUgYW5vZGVzIGFuZCBjYXRob2Rlcy4gCiAgVGhpcyB0ZWNobm9sb2d5IGlzIG1vc3Qgd2lkZWx5IHVzZWQgaW4gRXVyb3BlICg4NSUgb2YgaW5zdGFsbGVkIGNhcGFjaXR5KSBhbmQgaXMgY29uc2lkZXJlZCB0aGUgbW9zdCBlbmVyZ3ktZWZmaWNpZW50IG1ldGhvZC4KPC9wPgoKPGgzIGlkPSJkaWFwaHJhZ20tY2VsbC10ZWNobm9sb2d5Ij5EaWFwaHJhZ20gQ2VsbCBUZWNobm9sb2d5PC9oMz4KPHA+CiAgQ3VycmVudGx5IGRvbWluYW50IGluIE5vcnRoIEFtZXJpY2EsIGRpYXBocmFnbSBjZWxscyB1c2UgcG9yb3VzIHNlcGFyYXRvcnMgYmV0d2VlbiBlbGVjdHJvZGVzLiBUaGUgcHJvY2VzcyBwcm9kdWNlcyBjaGxvcmluZSBnYXMsIAogIGh5ZHJvZ2VuIGdhcywgYW5kIGNlbGwgbGlxdW9yIGNvbnRhaW5pbmcgc29kaXVtIGh5ZHJveGlkZSBhbmQgc29kaXVtIGNobG9yaWRlLgo8L3A+Cgo8aDMgaWQ9Im1lcmN1cnktY2VsbC10ZWNobm9sb2d5Ij5NZXJjdXJ5IENlbGwgVGVjaG5vbG9neTwvaDM+CjxwPgogIE5vdyBiZWluZyBwaGFzZWQgb3V0IGR1ZSB0byBlbnZpcm9ubWVudGFsIGNvbmNlcm5zLCB0aGlzIGhpc3RvcmljYWwgbWV0aG9kIGludm9sdmVzIG1lcmN1cnkgY2F0aG9kZXMgCiAgYW5kIGhhcyBiZWVuIGxhcmdlbHkgcmVwbGFjZWQgYnkgY2xlYW5lciBhbHRlcm5hdGl2ZXMuCjwvcD4KCjxoMyBpZD0icHJvZHVjdGlvbi1jaGVtaXN0cnkiPlByb2R1Y3Rpb24gQ2hlbWlzdHJ5PC9oMz4KPHA+CiAgVGhlIGZ1bmRhbWVudGFsIGVsZWN0cm9seXNpcyByZWFjdGlvbiBmb3IgY2hsb3JpbmUgcHJvZHVjdGlvbiBpczoKPC9wPgo8dWw+CiAgPGxpPjxzdHJvbmc+T3ZlcmFsbCByZWFjdGlvbjo8L3N0cm9uZz4gMiBOYUNsICsgMiBI4oKCTyDihpIgQ2zigoIgKyBI4oKCICsgMiBOYU9IPC9saT4KICA8bGk+PHN0cm9uZz5BdCB0aGUgYW5vZGU6PC9zdHJvbmc+IDIgQ2zigbsg4oaSIENs4oKCICsgMmXigbs8L2xpPgogIDxsaT48c3Ryb25nPkF0IHRoZSBjYXRob2RlOjwvc3Ryb25nPiAyIEjigoJPICsgMmXigbsg4oaSIDIgT0jigbsgKyBI4oKCPC9saT4KPC91bD4KPHA+CiAgVGhpcyBwcm9jZXNzIHJlcXVpcmVzIGFwcHJveGltYXRlbHkgPHN0cm9uZz4xNjU0IGtXaCBvZiBlbmVyZ3k8L3N0cm9uZz4gdG8gcHJvZHVjZSBvbmUgdG9uIG9mIGNobG9yaW5lIAogIGFsb25nIHdpdGggPHN0cm9uZz4xLjEzIHRvbnMgb2Ygc29kaXVtIGh5ZHJveGlkZTwvc3Ryb25nPiBhbmQgPHN0cm9uZz4yOC40IGtnIG9mIGh5ZHJvZ2VuPC9zdHJvbmc+Lgo8L3A+Cg==PGgyIGlkPSJtYWpvci11c2VzLWFuZC1hcHBsaWNhdGlvbnMtaW5kdXN0cmlhbC1hcHBsaWNhdGlvbnMiPk1ham9yIFVzZXMgYW5kIEFwcGxpY2F0aW9uczogSW5kdXN0cmlhbCBBcHBsaWNhdGlvbnM8L2gyPgoKPGgzIGlkPSJjaGVtaWNhbC1tYW51ZmFjdHVyaW5nIj5DaGVtaWNhbCBNYW51ZmFjdHVyaW5nPC9oMz4KPHA+CiAgQ2hsb3JpbmUgc2VydmVzIGFzIGEgZmVlZHN0b2NrIGZvciBudW1lcm91cyBpbmR1c3RyaWFsIHByb2Nlc3NlczoKPC9wPgo8dWw+CiAgPGxpPjxzdHJvbmc+UGxhc3RpY3MgcHJvZHVjdGlvbjo8L3N0cm9uZz4gRXNzZW50aWFsIGZvciBtYW51ZmFjdHVyaW5nIFBWQyAocG9seXZpbnlsIGNobG9yaWRlKSwgb25lIG9mIHRoZSB3b3JsZCdzIG1vc3QgdmVyc2F0aWxlIHBsYXN0aWNzPC9saT4KICA8bGk+PHN0cm9uZz5Tb2x2ZW50czo8L3N0cm9uZz4gUHJvZHVjdGlvbiBvZiBjaGxvcmluYXRlZCBzb2x2ZW50cyBmb3IgY2xlYW5pbmcgYW5kIGRlZ3JlYXNpbmcgYXBwbGljYXRpb25zPC9saT4KICA8bGk+PHN0cm9uZz5QaGFybWFjZXV0aWNhbHM6PC9zdHJvbmc+IFN5bnRoZXNpcyBvZiBpbnRlcm1lZGlhdGVzIGFuZCBhY3RpdmUgaW5ncmVkaWVudHMgaW4gbWVkaWNhdGlvbnM8L2xpPgo8L3VsPgoKPGgzIGlkPSJzcGVjaWFsaXplZC1pbmR1c3RyaWVzIj5TcGVjaWFsaXplZCBJbmR1c3RyaWVzPC9oMz4KPHA+CiAgQ2hsb3JpbmUgcGxheXMgYW4gaW1wb3J0YW50IHJvbGUgaW4gdmFyaW91cyBzcGVjaWFsaXplZCBpbmR1c3RyaWVzOgo8L3A+Cjx1bD4KICA8bGk+PHN0cm9uZz5Hb2xkIG1pbmluZzo8L3N0cm9uZz4gQ2hsb3JpbmUgZ2FzIGZhY2lsaXRhdGVzIGdvbGQgZXh0cmFjdGlvbiBmcm9tIGNvbXBvdW5kczwvbGk+CiAgPGxpPjxzdHJvbmc+QWx1bWludW0gcmVmaW5pbmc6PC9zdHJvbmc+IFZhcmlvdXMgcHJvY2Vzc2VzIGJlbmVmaXQgZnJvbSBjaGxvcmluYXRpb24gc3lzdGVtczwvbGk+CiAgPGxpPjxzdHJvbmc+UGFwZXIgYW5kIHRleHRpbGVzOjwvc3Ryb25nPiBCbGVhY2hpbmcgYXBwbGljYXRpb25zIGZvciBhY2hpZXZpbmcgaGlnaCB3aGl0ZW5lc3MgYW5kIHF1YWxpdHk8L2xpPgogIDxsaT48c3Ryb25nPkVuZXJneSBwcm9kdWN0aW9uOjwvc3Ryb25nPiBDcml0aWNhbCBjb21wb25lbnQgaW4gc29sYXIgcGFuZWwgbWFudWZhY3R1cmluZyB0aHJvdWdoIHNpbGljb24gdGV0cmFjaGxvcmlkZTwvbGk+CjwvdWw+Cgo8aDMgaWQ9ImFncmljdWx0dXJhbC1hcHBsaWNhdGlvbnMiPkFncmljdWx0dXJhbCBBcHBsaWNhdGlvbnM8L2gzPgo8cD4KICBDaGxvcmluZS1iYXNlZCBjb21wb3VuZHMgcGxheSB2aXRhbCByb2xlcyBpbiBhZ3JpY3VsdHVyZSB0aHJvdWdoOgo8L3A+Cjx1bD4KICA8bGk+UGVzdGljaWRlcyBhbmQgaGVyYmljaWRlcyBmb3IgY3JvcCBwcm90ZWN0aW9uPC9saT4KICA8bGk+U29pbCB0cmVhdG1lbnQgYW5kIHN0ZXJpbGl6YXRpb248L2xpPgogIDxsaT5Qb3N0LWhhcnZlc3QgZm9vZCBwcm9jZXNzaW5nIGFuZCBwcmVzZXJ2YXRpb248L2xpPgo8L3VsPgoKPGgzIGlkPSJ3YXRlci10cmVhdG1lbnQtYW5kLWRpc2luZmVjdGlvbiI+V2F0ZXIgVHJlYXRtZW50IGFuZCBEaXNpbmZlY3Rpb248L2gzPgo8cD4KICBDaGxvcmluZSdzIG1vc3QgY3JpdGljYWwgYXBwbGljYXRpb24gbGllcyBpbiB3YXRlciB0cmVhdG1lbnQsIHdoZXJlIGl0IHNlcnZlcyBhcyB0aGUgcHJpbWFyeSBkaXNpbmZlY3RhbnQgZm9yIGRyaW5raW5nIHdhdGVyIGFuZCB3YXN0ZXdhdGVyIHN5c3RlbXMgZ2xvYmFsbHkuIEl0cyBlZmZlY3RpdmVuZXNzIHN0ZW1zIGZyb20gaXRzIGFiaWxpdHkgdG86CjwvcD4KPHVsPgogIDxsaT5EZXN0cm95IGJhY3RlcmlhLCB2aXJ1c2VzLCBhbmQgb3RoZXIgcGF0aG9nZW5zPC9saT4KICA8bGk+RWxpbWluYXRlIGJpb2ZpbG1zIGluIGRpc3RyaWJ1dGlvbiBzeXN0ZW1zPC9saT4KICA8bGk+UHJvdmlkZSByZXNpZHVhbCBwcm90ZWN0aW9uIGR1cmluZyB3YXRlciBzdG9yYWdlIGFuZCBkaXN0cmlidXRpb248L2xpPgo8L3VsPgo8cD4KICBUaGUgV29ybGQgSGVhbHRoIE9yZ2FuaXphdGlvbiByZWNvZ25pemVzIGNobG9yaW5hdGlvbiBhcyA8ZW0+Im9uZSBvZiB0aGUgZ3JlYXRlc3QgcHVibGljIGhlYWx0aCBhZHZhbmNlcyBpbiBoaXN0b3J5LCI8L2VtPiBoZWxwaW5nIHRvIHZpcnR1YWxseSBlbGltaW5hdGUgd2F0ZXJib3JuZSBkaXNlYXNlcyBsaWtlIGNob2xlcmEsIHR5cGhvaWQsIGFuZCBkeXNlbnRlcnkgd2hlcmUgd2lkZWx5IGltcGxlbWVudGVkLgo8L3A+Cg==PGgyIGlkPSJoZWFsdGgtaGF6YXJkcy1hbmQtdG94aWNvbG9naWNhbC1lZmZlY3RzIj5IZWFsdGggSGF6YXJkcyBhbmQgVG94aWNvbG9naWNhbCBFZmZlY3RzPC9oMj4KCgo8aDMgaWQ9ImFjdXRlLWhlYWx0aC1lZmZlY3RzIj4xLiBBY3V0ZSBIZWFsdGggRWZmZWN0czwvaDM+CjxwPgogIENobG9yaW5lIGV4cG9zdXJlIHByb2R1Y2VzIGltbWVkaWF0ZSBhbmQgcG90ZW50aWFsbHkgc2V2ZXJlIGhlYWx0aCBjb25zZXF1ZW5jZXMgdGhhdCB2YXJ5IHdpdGggY29uY2VudHJhdGlvbiBhbmQgZHVyYXRpb246CjwvcD4KCjxoND5SZXNwaXJhdG9yeSBTeXN0ZW0gRWZmZWN0czwvaDQ+Cjx1bD4KICA8bGk+PHN0cm9uZz5Mb3cgY29uY2VudHJhdGlvbnMgKDHigJMzIHBwbSk6PC9zdHJvbmc+IE1pbGQgbXVjb3VzIG1lbWJyYW5lIGlycml0YXRpb24sIGJ1cm5pbmcgc2Vuc2F0aW9uIGluIG5vc2UgYW5kIHRocm9hdDwvbGk+CiAgPGxpPjxzdHJvbmc+TW9kZXJhdGUgY29uY2VudHJhdGlvbnMgKDXigJMxNSBwcG0pOjwvc3Ryb25nPiBNb2RlcmF0ZSByZXNwaXJhdG9yeSB0cmFjdCBpcnJpdGF0aW9uLCBjb3VnaGluZywgd2hlZXppbmc8L2xpPgogIDxsaT48c3Ryb25nPkhpZ2ggY29uY2VudHJhdGlvbnMgKDMwKyBwcG0pOjwvc3Ryb25nPiBJbnRlbnNlIGNvdWdoaW5nIGZpdHMsIHB1bG1vbmFyeSBlZGVtYSwgcG90ZW50aWFsIGZhdGFsaXR5PC9saT4KPC91bD4KCjxoND5Ta2luIGFuZCBFeWUgRWZmZWN0czwvaDQ+Cjx1bD4KICA8bGk+PHN0cm9uZz5Ta2luIGNvbnRhY3Q6PC9zdHJvbmc+IFNldmVyZSBpcnJpdGF0aW9uLCBjaGVtaWNhbCBidXJucywgYW5kIGJsaXN0ZXJpbmc8L2xpPgogIDxsaT48c3Ryb25nPkxpcXVpZCBjaGxvcmluZSBjb250YWN0Ojwvc3Ryb25nPiBGcm9zdGJpdGUgZHVlIHRvIHJhcGlkIGV2YXBvcmF0aW9uPC9saT4KICA8bGk+PHN0cm9uZz5FeWUgZXhwb3N1cmU6PC9zdHJvbmc+IFNldmVyZSBidXJucywgcGVybWFuZW50IGRhbWFnZSBpZiBub3QgdHJlYXRlZCBpbW1lZGlhdGVseTwvbGk+CjwvdWw+Cgo8aDMgaWQ9Im9jY3VwYXRpb25hbC1leHBvc3VyZS1saW1pdHMiPjIuIE9jY3VwYXRpb25hbCBFeHBvc3VyZSBMaW1pdHMgZm9yIENobG9yaW5lPC9oMz4KPHA+CiAgVGhlIDxzdHJvbmc+SW1tZWRpYXRlbHkgRGFuZ2Vyb3VzIHRvIExpZmUgYW5kIEhlYWx0aCAoSURMSCk8L3N0cm9uZz4gY29uY2VudHJhdGlvbiBpcyBzZXQgYXQgPHN0cm9uZz4xMCBwcG08L3N0cm9uZz4sIHJlcHJlc2VudGluZyBleHBvc3VyZSBsZXZlbHMgdGhhdCBjb3VsZCBjYXVzZSBkZWF0aCBvciBpbW1lZGlhdGUgcGVybWFuZW50IGFkdmVyc2UgaGVhbHRoIGVmZmVjdHMuCjwvcD4KCjxoMyBpZD0iY2hyb25pYy1oZWFsdGgtZWZmZWN0cyI+My4gQ2hyb25pYyBIZWFsdGggRWZmZWN0czwvaDM+CjxwPgogIExvbmctdGVybSBleHBvc3VyZSB0byBjaGxvcmluZSBjYW4gcmVzdWx0IGluOgo8L3A+Cjx1bD4KICA8bGk+Q2hyb25pYyByZXNwaXJhdG9yeSBpbmZsYW1tYXRpb24gYW5kIGltcGFpcmVkIGx1bmcgZnVuY3Rpb248L2xpPgogIDxsaT5EZW50YWwgZXJvc2lvbiBmcm9tIHByb2xvbmdlZCBleHBvc3VyZTwvbGk+CiAgPGxpPkluY3JlYXNlZCBzdXNjZXB0aWJpbGl0eSB0byByZXNwaXJhdG9yeSBpbmZlY3Rpb25zPC9saT4KICA8bGk+UG90ZW50aWFsIGluY3JlYXNlZCBjYW5jZXIgcmlzaywgdGhvdWdoIGV2aWRlbmNlIHJlbWFpbnMgaW5jb25jbHVzaXZlPC9saT4KPC91bD4KPGgyIGlkPSJzYWZldHktcHJvdG9jb2xzLWFuZC1wZXJzb25hbC1wcm90ZWN0aXZlLWVxdWlwbWVudCI+U2FmZXR5IFByb3RvY29scyBhbmQgUGVyc29uYWwgUHJvdGVjdGl2ZSBFcXVpcG1lbnQ8L2gyPgoKCjxoMyBpZD0icGVyc29uYWwtcHJvdGVjdGl2ZS1lcXVpcG1lbnQtcmVxdWlyZW1lbnRzIj5QZXJzb25hbCBQcm90ZWN0aXZlIEVxdWlwbWVudCBSZXF1aXJlbWVudHM8L2gzPgo8cD4KICBQcm9wZXIgUFBFIGlzIGVzc2VudGlhbCBmb3Igc2FmZSBjaGxvcmluZSBoYW5kbGluZyBhbmQgdmFyaWVzIGJhc2VkIG9uIGV4cG9zdXJlIHJpc2s6CjwvcD4KCjxoND5SZXNwaXJhdG9yeSBQcm90ZWN0aW9uPC9oND4KPHVsPgogIDxsaT48c3Ryb25nPkxvdy1yaXNrIGVudmlyb25tZW50czo8L3N0cm9uZz4gQ2hlbWljYWwgY2FydHJpZGdlIHJlc3BpcmF0b3JzIHdpdGggY2hsb3JpbmUtc3BlY2lmaWMgZmlsdGVyczwvbGk+CiAgPGxpPjxzdHJvbmc+TW9kZXJhdGUtcmlzayBzaXR1YXRpb25zOjwvc3Ryb25nPiBGdWxsLWZhY2VwaWVjZSBhaXItcHVyaWZ5aW5nIHJlc3BpcmF0b3JzPC9saT4KICA8bGk+PHN0cm9uZz5IaWdoLXJpc2svZW1lcmdlbmN5IGNvbmRpdGlvbnM6PC9zdHJvbmc+IFNlbGYtY29udGFpbmVkIGJyZWF0aGluZyBhcHBhcmF0dXMgKFNDQkEpIHdpdGggZnVsbCBmYWNlcGllY2U8L2xpPgo8L3VsPgoKPGg0PlNraW4gYW5kIEV5ZSBQcm90ZWN0aW9uPC9oND4KPHVsPgogIDxsaT48c3Ryb25nPkNoZW1pY2FsLXJlc2lzdGFudCBzdWl0czo8L3N0cm9uZz4gQXBwcm9wcmlhdGUgZm9yIGNobG9yaW5lIGNvbmNlbnRyYXRpb24gbGV2ZWxzPC9saT4KICA8bGk+PHN0cm9uZz5XYXRlcnByb29mIGFwcm9ucyBhbmQgYm9vdHM6PC9zdHJvbmc+IEltcGVydmlvdXMgdG8gY2hsb3JpbmUgc29sdXRpb25zPC9saT4KICA8bGk+PHN0cm9uZz5TYWZldHkgZ29nZ2xlczo8L3N0cm9uZz4gQ2hlbWljYWwgc3BsYXNoIHByb3RlY3Rpb24gd2l0aCBpbmRpcmVjdCB2ZW50aWxhdGlvbjwvbGk+CiAgPGxpPjxzdHJvbmc+RW1lcmdlbmN5IGV5ZXdhc2ggc3RhdGlvbnM6PC9zdHJvbmc+IE11c3QgYmUgYXZhaWxhYmxlIHdpdGhpbiBpbW1lZGlhdGUgcmVhY2g8L2xpPgo8L3VsPgo=PGgzIGlkPSJzYWZlLWhhbmRsaW5nLXByb2NlZHVyZXMiPlNhZmUgSGFuZGxpbmcgUHJvY2VkdXJlczwvaDM+Cgo8aDQgaWQ9InN0b3JhZ2UtcmVxdWlyZW1lbnRzIj4xLiBTdG9yYWdlIFJlcXVpcmVtZW50czwvaDQ+CjxwPlByb3BlciBjaGxvcmluZSBzdG9yYWdlIGlzIGNyaXRpY2FsIGZvciBwcmV2ZW50aW5nIGFjY2lkZW50czo8L3A+Cjx1bD4KICA8bGk+PHN0cm9uZz5Mb2NhdGlvbjo8L3N0cm9uZz4gQWJvdmUgZ3JvdW5kLCBsZXZlbCBhcmVhcyB3aXRoIGFkZXF1YXRlIGNsZWFyYW5jZSBmcm9tIG90aGVyIGVxdWlwbWVudDwvbGk+CiAgPGxpPjxzdHJvbmc+VmVudGlsYXRpb246PC9zdHJvbmc+IFdlbGwtdmVudGlsYXRlZCBhcmVhcyB3aXRoIGV4aGF1c3Qgc3lzdGVtczwvbGk+CiAgPGxpPjxzdHJvbmc+VGVtcGVyYXR1cmUgY29udHJvbDo8L3N0cm9uZz4gUHJvdGVjdGlvbiBmcm9tIGhlYXQgc291cmNlczsgZnVzaWJsZSBwbHVncyBtZWx0IGF0IDE1OOKAkzE2NcKwRjwvbGk+CiAgPGxpPjxzdHJvbmc+Q29udGFpbmVyIHBvc2l0aW9uaW5nOjwvc3Ryb25nPiBDeWxpbmRlcnMgc3RvcmVkIHVwcmlnaHQgYW5kIHNlY3VyZWQ7IHRvbiBjb250YWluZXJzIG1heSBiZSBob3Jpem9udGFsPC9saT4KICA8bGk+PHN0cm9uZz5TZXBhcmF0aW9uOjwvc3Ryb25nPiBBd2F5IGZyb20gZmxhbW1hYmxlIG1hdGVyaWFscywgY29tYnVzdGlibGVzLCBhbmQgaW5jb21wYXRpYmxlIGNoZW1pY2FsczwvbGk+CjwvdWw+Cgo8aDQgaWQ9Im9wZXJhdGlvbmFsLXNhZmV0eS1tZWFzdXJlcyI+Mi4gT3BlcmF0aW9uYWwgU2FmZXR5IE1lYXN1cmVzPC9oND4KPHVsPgogIDxsaT48c3Ryb25nPlR3by1wZXJzb24gcnVsZTo8L3N0cm9uZz4gTmV2ZXIgaGFuZGxlIGNobG9yaW5lIGFsb25lOyBpbXBsZW1lbnQgYnVkZHkgc3lzdGVtPC9saT4KICA8bGk+PHN0cm9uZz5MZWFrIGRldGVjdGlvbjo8L3N0cm9uZz4gSW5zdGFsbCBtb25pdG9yaW5nIHN5c3RlbXMgd2l0aCBhcHByb3ByaWF0ZSBhbGFybSB0aHJlc2hvbGRzPC9saT4KICA8bGk+PHN0cm9uZz5FbWVyZ2VuY3kgZXF1aXBtZW50Ojwvc3Ryb25nPiBNYWludGFpbiByZWFkaWx5IGFjY2Vzc2libGUgc2FmZXR5IHNob3dlcnMsIGV5ZXdhc2ggc3RhdGlvbnMsIGFuZCBzcGlsbCByZXNwb25zZSBtYXRlcmlhbHM8L2xpPgogIDxsaT48c3Ryb25nPlRyYWluaW5nIHJlcXVpcmVtZW50czo8L3N0cm9uZz4gQWxsIHBlcnNvbm5lbCBtdXN0IHJlY2VpdmUgY29tcHJlaGVuc2l2ZSBjaGxvcmluZSBzYWZldHkgdHJhaW5pbmc8L2xpPgo8L3VsPgoKPGgzIGlkPSJpbW1lZGlhdGUtcmVzcG9uc2UtcHJvY2VkdXJlcyI+My4gSW1tZWRpYXRlIFJlc3BvbnNlIFByb2NlZHVyZXM8L2gzPgoKPGg0IGlkPSJpbmhhbGF0aW9uLWV4cG9zdXJlIj5hLiBJbmhhbGF0aW9uIEV4cG9zdXJlPC9oND4KPHA+RW1lcmdlbmN5IHJlc3BvbnNlIGZvciBjaGxvcmluZSBpbmhhbGF0aW9uIHJlcXVpcmVzIGltbWVkaWF0ZSBhY3Rpb246PC9wPgo8dWw+CiAgPGxpPlJlbW92ZSB2aWN0aW0gZnJvbSBjb250YW1pbmF0ZWQgYXJlYSB0byBmcmVzaCBhaXIgaW1tZWRpYXRlbHk8L2xpPgogIDxsaT5LZWVwIHZpY3RpbSB3YXJtIGFuZCBhdCByZXN0IGluIHNlbWktcmVjbGluZWQgcG9zaXRpb24gd2l0aCBoZWFkIGVsZXZhdGVkPC9saT4KICA8bGk+QWRtaW5pc3RlciBveHlnZW4gYXMgc29vbiBhcyBhdmFpbGFibGU8L2xpPgogIDxsaT5Nb25pdG9yIGZvciBwdWxtb25hcnkgZWRlbWEgYW5kIHByb3ZpZGUgcmVzcGlyYXRvcnkgc3VwcG9ydCBhcyBuZWVkZWQ8L2xpPgogIDxsaT5TZWVrIGltbWVkaWF0ZSBtZWRpY2FsIGF0dGVudGlvbiDigJMgY2FsbCBwb2lzb24gY29udHJvbCBvciBlbWVyZ2VuY3kgc2VydmljZXM8L2xpPgo8L3VsPgoKPGg0IGlkPSJza2luLWNvbnRhY3QiPmIuIFNraW4gQ29udGFjdDwvaDQ+CjxwPkZvciBjaGxvcmluZSBjb250YWN0IHdpdGggc2tpbjo8L3A+Cjx1bD4KICA8bGk+UmVtb3ZlIGNvbnRhbWluYXRlZCBjbG90aGluZyBpbW1lZGlhdGVseTwvbGk+CiAgPGxpPkZsdXNoIGFmZmVjdGVkIGFyZWEgd2l0aCBjb3Bpb3VzIGFtb3VudHMgb2Ygd2F0ZXIgZm9yIGF0IGxlYXN0IDE1IG1pbnV0ZXM8L2xpPgogIDxsaT5EbyBub3QgdXNlIG5ldXRyYWxpemluZyBjaGVtaWNhbHMgYXMgdGhleSBtYXkgY2F1c2UgdGhlcm1hbCBidXJuczwvbGk+CiAgPGxpPlNlZWsgbWVkaWNhbCBhdHRlbnRpb24gaW1tZWRpYXRlbHkgZm9yIGNoZW1pY2FsIGJ1cm5zPC9saT4KPC91bD4KCjxoNCBpZD0iZXllLWV4cG9zdXJlIj5jLiBFeWUgRXhwb3N1cmU8L2g0Pgo8cD5FeWUgY29udGFjdCByZXF1aXJlcyB1cmdlbnQgaW50ZXJ2ZW50aW9uOjwvcD4KPHVsPgogIDxsaT5SZW1vdmUgY29udGFjdCBsZW5zZXMgaWYgcHJlc2VudCBhbmQgZWFzaWx5IHJlbW92YWJsZTwvbGk+CiAgPGxpPklycmlnYXRlIGV5ZXMgd2l0aCBjbGVhbiB3YXRlciBvciBzYWxpbmUgZm9yIG1pbmltdW0gMTUgbWludXRlczwvbGk+CiAgPGxpPkhvbGQgZXllbGlkcyBhcGFydCBkdXJpbmcgaXJyaWdhdGlvbiB0byBlbnN1cmUgdGhvcm91Z2ggZmx1c2hpbmc8L2xpPgogIDxsaT5TZWVrIGltbWVkaWF0ZSBvcGh0aGFsbW9sb2dpYyBjYXJlIGZvciBhbnkgY2hsb3JpbmUgZXllIGV4cG9zdXJlPC9saT4KPC91bD4KPGgyIGlkPSJkZXRlY3Rpb24tYW5kLW1vbml0b3Jpbmctc3lzdGVtcyI+RGV0ZWN0aW9uIGFuZCBNb25pdG9yaW5nIFN5c3RlbXM8L2gyPgoKPGgzIGlkPSJnYXMtZGV0ZWN0aW9uLXRlY2hub2xvZ2llcyI+MS4gR2FzIERldGVjdGlvbiBUZWNobm9sb2dpZXM8L2gzPgo8cD4KICBNb2Rlcm4gY2hsb3JpbmUgZGV0ZWN0aW9uIHJlbGllcyBvbiBzZXZlcmFsIHRlY2hub2xvZ2llczoKPC9wPgoKPGg0IGlkPSJlbGVjdHJvY2hlbWljYWwtc2Vuc29ycyI+YS4gRWxlY3Ryb2NoZW1pY2FsIFNlbnNvcnM8L2g0Pgo8dWw+CiAgPGxpPjxzdHJvbmc+UHJpbmNpcGxlOjwvc3Ryb25nPiBBbXBlcm9tZXRyaWMgZnVlbCBjZWxsIHRlY2hub2xvZ3kgbWVhc3VyaW5nIGN1cnJlbnQgcHJvcG9ydGlvbmFsIHRvIGNobG9yaW5lIGNvbmNlbnRyYXRpb248L2xpPgogIDxsaT48c3Ryb25nPkFkdmFudGFnZXM6PC9zdHJvbmc+IEhpZ2ggYWNjdXJhY3ksIHJlYWwtdGltZSBtb25pdG9yaW5nLCBsb25nIHNlcnZpY2UgbGlmZSAoMTgsMDAwKyBob3Vycyk8L2xpPgogIDxsaT48c3Ryb25nPkFwcGxpY2F0aW9uczo8L3N0cm9uZz4gQ29udGludW91cyBhcmVhIG1vbml0b3JpbmcsIHBlcnNvbmFsIHByb3RlY3Rpb24gZGV2aWNlczwvbGk+CjwvdWw+Cgo8aDQgaWQ9ImNvbG9yaW1ldHJpYy1kZXRlY3Rpb24iPmIuIENvbG9yaW1ldHJpYyBEZXRlY3Rpb248L2g0Pgo8dWw+CiAgPGxpPjxzdHJvbmc+TWV0aG9kOjwvc3Ryb25nPiBEUEQgKE4sIE4tZGlldGh5bC1wLXBoZW55bGVuZWRpYW1pbmUpIGNoZW1pc3RyeSBmb3Igd2F0ZXIgYW5hbHlzaXM8L2xpPgogIDxsaT48c3Ryb25nPlJhbmdlOjwvc3Ryb25nPiBTdWl0YWJsZSBmb3IgZnJlZSBhbmQgdG90YWwgY2hsb3JpbmUgbWVhc3VyZW1lbnQ8L2xpPgogIDxsaT48c3Ryb25nPkFjY3VyYWN5Ojwvc3Ryb25nPiDCsTM1JSBmb3IgY29uY2VudHJhdGlvbnMgZG93biB0byBoYWxmIHRoZSBleHBvc3VyZSBsaW1pdDwvbGk+CjwvdWw+Cgo8aDMgaWQ9ImZpeGVkLW1vbml0b3Jpbmctc3lzdGVtcyI+Mi4gRml4ZWQgTW9uaXRvcmluZyBTeXN0ZW1zPC9oMz4KPHA+CiAgSW5kdXN0cmlhbCBmYWNpbGl0aWVzIGVtcGxveSBjb21wcmVoZW5zaXZlIG1vbml0b3JpbmcgbmV0d29ya3MgaW5jbHVkaW5nOgo8L3A+Cjx1bD4KICA8bGk+PHN0cm9uZz5BcmVhIG1vbml0b3JzOjwvc3Ryb25nPiBDb250aW51b3VzIGFtYmllbnQgYWlyIG1vbml0b3Jpbmc8L2xpPgogIDxsaT48c3Ryb25nPlN0YWNrIG1vbml0b3Jpbmc6PC9zdHJvbmc+IEVtaXNzaW9uIGNvbnRyb2wgdmVyaWZpY2F0aW9uPC9saT4KICA8bGk+PHN0cm9uZz5XYXRlciBxdWFsaXR5IGFuYWx5emVyczo8L3N0cm9uZz4gUHJvY2VzcyBjb250cm9sIGFuZCBjb21wbGlhbmNlIG1vbml0b3Jpbmc8L2xpPgo8L3VsPgo=PGgyIGlkPSJlbnZpcm9ubWVudGFsLWltcGFjdC1tYW5hZ2VtZW50Ij5FbnZpcm9ubWVudGFsIEltcGFjdCBNYW5hZ2VtZW50PC9oMj4KCgo8aDMgaWQ9ImVtaXNzaW9uLWNvbnRyb2wiPjEuIEVtaXNzaW9uIENvbnRyb2w8L2gzPgo8cD5JbmR1c3RyaWFsIGZhY2lsaXRpZXMgaW1wbGVtZW50IG11bHRpcGxlIHN0cmF0ZWdpZXM6PC9wPgo8dWw+CiAgPGxpPjxzdHJvbmc+QWJzb3JwdGlvbiBzeXN0ZW1zOjwvc3Ryb25nPiBDYXVzdGljIHNjcnViYmluZyBmb3IgY2hsb3JpbmUgZ2FzIHJlbGVhc2VzPC9saT4KICA8bGk+PHN0cm9uZz5MZWFrIGRldGVjdGlvbjo8L3N0cm9uZz4gQ29udGludW91cyBtb25pdG9yaW5nIHRvIG1pbmltaXplIGZ1Z2l0aXZlIGVtaXNzaW9uczwvbGk+CiAgPGxpPjxzdHJvbmc+UHJvY2VzcyBvcHRpbWl6YXRpb246PC9zdHJvbmc+IFJlZHVjaW5nIGNobG9yaW5lIGNvbnN1bXB0aW9uIHRocm91Z2ggaW1wcm92ZWQgZWZmaWNpZW5jeTwvbGk+CjwvdWw+Cgo8aDMgaWQ9Indhc3RlLW1hbmFnZW1lbnQiPjIuIFdhc3RlIE1hbmFnZW1lbnQ8L2gzPgo8cD5DaGxvcmluZS1jb250YWluaW5nIHdhc3RlcyByZXF1aXJlIHNwZWNpYWxpemVkIGhhbmRsaW5nIHVuZGVyIGhhemFyZG91cyB3YXN0ZSByZWd1bGF0aW9uczo8L3A+Cjx1bD4KICA8bGk+PHN0cm9uZz5DaGFyYWN0ZXJpemF0aW9uOjwvc3Ryb25nPiBQcm9wZXIgaWRlbnRpZmljYXRpb24gYW5kIGNsYXNzaWZpY2F0aW9uIG9mIGNobG9yaW5lIHdhc3RlczwvbGk+CiAgPGxpPjxzdHJvbmc+VHJlYXRtZW50Ojwvc3Ryb25nPiBOZXV0cmFsaXphdGlvbiBhbmQgc2FmZSBkaXNwb3NhbCBtZXRob2RzPC9saT4KICA8bGk+PHN0cm9uZz5SZXBvcnRpbmc6PC9zdHJvbmc+IENvbXBsaWFuY2Ugd2l0aCByZWxlYXNlIHJlcG9ydGluZyByZXF1aXJlbWVudHM8L2xpPgo8L3VsPgoKPGgzIGlkPSJzdXN0YWluYWJsZS1hbHRlcm5hdGl2ZXMiPjMuIFN1c3RhaW5hYmxlIEFsdGVybmF0aXZlczwvaDM+CjxwPkluZHVzdHJpZXMgYXJlIGV4cGxvcmluZyBhbHRlcm5hdGl2ZXMgdG8gcmVkdWNlIGNobG9yaW5lIGRlcGVuZGVuY3k6PC9wPgo8dWw+CiAgPGxpPjxzdHJvbmc+T24tc2l0ZSBnZW5lcmF0aW9uOjwvc3Ryb25nPiBFbGVjdHJvbHl0aWMgcHJvZHVjdGlvbiByZWR1Y2luZyB0cmFuc3BvcnRhdGlvbiByaXNrczwvbGk+CiAgPGxpPjxzdHJvbmc+QWx0ZXJuYXRpdmUgZGlzaW5mZWN0YW50czo8L3N0cm9uZz4gVVYsIG96b25lLCBhbmQgY2hsb3JpbmUgZGlveGlkZSBmb3Igc3BlY2lmaWMgYXBwbGljYXRpb25zPC9saT4KICA8bGk+PHN0cm9uZz5Qcm9jZXNzIG1vZGlmaWNhdGlvbnM6PC9zdHJvbmc+IENobG9yaW5lLWZyZWUgYmxlYWNoaW5nIGFuZCBtYW51ZmFjdHVyaW5nIHByb2Nlc3NlczwvbGk+CjwvdWw+Cg==PGgyIGlkPSJjb25jbHVzaW9uIj5Db25jbHVzaW9uPC9oMj4KCjxwPgogIFRoZSBrZXkgdG8gc2FmZSBjaGxvcmluZSB1c2UgbGllcyBpbiB1bmRlcnN0YW5kaW5nIGl0cyBwcm9wZXJ0aWVzLCBpbXBsZW1lbnRpbmcgY29tcHJlaGVuc2l2ZSBzYWZldHkgbWVhc3VyZXMsIG1haW50YWluaW5nIHByb3BlciBlcXVpcG1lbnQsCiAgYW5kIGZvc3RlcmluZyBhIGN1bHR1cmUgb2Ygc2FmZXR5IGF3YXJlbmVzcy4gV2hpbGUgYWx0ZXJuYXRpdmVzIGNvbnRpbnVlIHRvIGRldmVsb3AsIGNobG9yaW5lJ3MgZWZmZWN0aXZlbmVzcywgcmVsaWFiaWxpdHksIGFuZCBjb3N0LWVmZmljaWVuY3kKICBlbnN1cmUgaXRzIGNvbnRpbnVlZCBpbXBvcnRhbmNlIGluIHdhdGVyIHRyZWF0bWVudCBhbmQgaW5kdXN0cmlhbCBhcHBsaWNhdGlvbnMuCjwvcD4KCjxwPgogIFN1Y2Nlc3MgaW4gY2hsb3JpbmUgbWFuYWdlbWVudCByZXF1aXJlcyBiYWxhbmNpbmcgaXRzIHRyZW1lbmRvdXMgYmVuZWZpdHMgd2l0aCByaWdvcm91cyByaXNrIG1hbmFnZW1lbnQuIFRocm91Z2ggcHJvcGVyIGVkdWNhdGlvbiwgZXF1aXBtZW50LAogIHByb2NlZHVyZXMsIGFuZCByZWd1bGF0b3J5IG92ZXJzaWdodCwgaW5kdXN0cmllcyBjYW4gaGFybmVzcyBjaGxvcmluZSBjYXBhYmlsaXRpZXMgd2hpbGUgcHJvdGVjdGluZyBodW1hbiBoZWFsdGggYW5kIHRoZSBlbnZpcm9ubWVudC4gQXMgdGVjaG5vbG9neQogIGFkdmFuY2VzIGFuZCByZWd1bGF0aW9ucyBldm9sdmUsIHRoZSBjaGxvcmluZSBpbmR1c3RyeSBtdXN0IGFkYXB0IHdoaWxlIG1haW50YWluaW5nIGl0cyBmdW5kYW1lbnRhbCBjb21taXRtZW50IHRvIHNhZmV0eSBhbmQgcmVzcG9uc2libGUgc3Rld2FyZHNoaXAuCjwvcD4KCjxwPgogIFRoZSBjb21wcmVoZW5zaXZlIGFwcHJvYWNoIG91dGxpbmVkIGluIHRoaXMgZ3VpZGXigJRlbmNvbXBhc3NpbmcgaGF6YXJkIHJlY29nbml0aW9uLCBzYWZldHkgcHJvdG9jb2xzLCBlbWVyZ2VuY3kgcHJlcGFyZWRuZXNzLCBhbmQgcmVndWxhdG9yeSBjb21wbGlhbmNl4oCUCiAgcHJvdmlkZXMgdGhlIGZvdW5kYXRpb24gZm9yIHNhZmUgYW5kIGVmZmVjdGl2ZSBjaGxvcmluZSB1c2UgYWNyb3NzIGFsbCBhcHBsaWNhdGlvbnMuIEJ5IGFkaGVyaW5nIHRvIHRoZXNlIHByaW5jaXBsZXMgYW5kIHJlbWFpbmluZyB2aWdpbGFudCBhYm91dCBlbWVyZ2luZwogIHJpc2tzIGFuZCB0ZWNobm9sb2dpZXMsIG9yZ2FuaXphdGlvbnMgY2FuIGNvbnRpbnVlIHRvIGJlbmVmaXQgZnJvbSBjaGxvcmluZSBjYXBhYmlsaXRpZXMgd2hpbGUgc2FmZWd1YXJkaW5nIGFsbCBzdGFrZWhvbGRlcnMuCjwvcD4K
