PG5hdiBhcmlhLWxhYmVsPSJUYWJsZSBvZiBjb250ZW50cyI+CiAgPHVsPgogICAgPGxpPjxhIGhyZWY9IiNpbnRyb2R1Y3Rpb24iPkludHJvZHVjdGlvbjwvYT48L2xpPgogICAgPGxpPjxhIGhyZWY9IiN1bmRlcnN0YW5kaW5nLWhhemFyZG91cy1jaGVtaWNhbC1leHBvc3VyZSI+VW5kZXJzdGFuZGluZyBIYXphcmRvdXMgQ2hlbWljYWwgRXhwb3N1cmU8L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjYmFzaWMtcnVsZXMtZm9yLXNhZmVseS1oYW5kbGluZy1oYXphcmRvdXMtbWF0ZXJpYWxzIj5CYXNpYyBSdWxlcyBmb3IgU2FmZWx5IEhhbmRsaW5nIEhhemFyZG91cyBNYXRlcmlhbHM8L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjaGF6YXJkLWFzc2Vzc21lbnQtYW5kLWNvbnRyb2wtc3RyYXRlZ3kiPkhhemFyZCBBc3Nlc3NtZW50IGFuZCBDb250cm9sIFN0cmF0ZWd5PC9hPjwvbGk+CiAgICA8bGk+PGEgaHJlZj0iI3BlcnNvbmFsLXByb3RlY3RpdmUtZXF1aXBtZW50LXBwZS1iZXN0LXByYWN0aWNlcyI+UGVyc29uYWwgUHJvdGVjdGl2ZSBFcXVpcG1lbnQgKFBQRSkgQmVzdCBQcmFjdGljZXM8L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjZW5naW5lZXJpbmctYW5kLXdvcmtwbGFjZS1jb250cm9scyI+RW5naW5lZXJpbmcgYW5kIFdvcmtwbGFjZSBDb250cm9sczwvYT48L2xpPgogICAgPGxpPjxhIGhyZWY9IiNhZG1pbmlzdHJhdGl2ZS1tZWFzdXJlcy1hbmQtdHJhaW5pbmciPkFkbWluaXN0cmF0aXZlIE1lYXN1cmVzIGFuZCBUcmFpbmluZzwvYT48L2xpPgogICAgPGxpPjxhIGhyZWY9IiNlbWVyZ2VuY3ktcHJlcGFyZWRuZXNzLWFuZC1yZXNwb25zZSI+RW1lcmdlbmN5IFByZXBhcmVkbmVzcyBhbmQgUmVzcG9uc2U8L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjc2FmZS1zdG9yYWdlLWFuZC13YXN0ZS1kaXNwb3NhbCI+U2FmZSBTdG9yYWdlIGFuZCBXYXN0ZSBEaXNwb3NhbDwvYT48L2xpPgogICAgPGxpPjxhIGhyZWY9IiNvbmdvaW5nLWltcHJvdmVtZW50LWFuZC1hdWRpdCI+T25nb2luZyBJbXByb3ZlbWVudCBhbmQgQXVkaXQ8L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjY29uY2x1c2lvbiI+Q29uY2x1c2lvbjwvYT48L2xpPgogIDwvdWw+CjwvbmF2Pgo=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PHNlY3Rpb24gaWQ9ImNvbmNsdXNpb24iPgogIDxoMj5Db25jbHVzaW9uPC9oMj4KICA8cD4KICAgIFByZXZlbnRpbmcgYW5kIG1hbmFnaW5nIGV4cG9zdXJlIHRvIGhhemFyZG91cyBjaGVtaWNhbHMgZGVtYW5kcyBhIGhvbGlzdGljIHN0cmF0ZWd5IGVuY29tcGFzc2luZyByaWdvcm91cyBoYXphcmQgYXNzZXNzbWVudCwgYXBwbGljYXRpb24gb2YgdGhlIGhpZXJhcmNoeSBvZiBjb250cm9scywgZGlsaWdlbnQgdXNlIG9mIFBQRSwgcm9idXN0IGFkbWluaXN0cmF0aXZlIHBvbGljaWVzLCBhbmQgY29tcHJlaGVuc2l2ZSBlbWVyZ2VuY3kgcGxhbm5pbmcuIEJ5IGVtYmVkZGluZyB0aGVzZSBzYWZldHkgbWVhc3VyZXMgaW50byBldmVyeWRheSBvcGVyYXRpb25zIGFuZCBmb3N0ZXJpbmcgYSBjdWx0dXJlIG9mIGNvbnRpbnVvdXMgaW1wcm92ZW1lbnQsIG9yZ2FuaXphdGlvbnMgY2FuIHNpZ25pZmljYW50bHkgcmVkdWNlIGhlYWx0aCByaXNrcyBhbmQgZW5zdXJlIGEgc2FmZXIgd29ya3BsYWNlLgogIDwvcD4KPC9zZWN0aW9uPgo=
