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PHNlY3Rpb24gaWQ9IndoeS1zYWZldHktaW1wb3J0YW50Ij4KICA8aDI+V2h5IElzIFdvcmtwbGFjZSBTYWZldHkgSW1wb3J0YW50PzwvaDI+CiAgPHA+CiAgICBXb3JrcGxhY2UgYWNjaWRlbnRzIGFyZSBub3Qgb25seSB0cmFnZWRpZXMgZm9yIGh1bWFuczsgdGhleSBhbHNvIGhhdmUgcHJvZm91bmQgZWNvbm9taWMgYW5kIG9wZXJhdGlvbmFsIGNvbnNlcXVlbmNlczoKICA8L3A+CiAgPHVsPgogICAgPGxpPkluY3JlYXNlZCBhYnNlbnRlZWlzbSBkdWUgdG8gaWxsbmVzcyBvciBpbmp1cnk8L2xpPgogICAgPGxpPkRlY2xpbmluZyBwcm9kdWN0aXZpdHkgYW5kIG1vcmFsZTwvbGk+CiAgICA8bGk+SW5jcmVhc2VkIGluc3VyYW5jZSByYXRlcyBhbmQgd29ya2VycycgY29tcGVuc2F0aW9uIGNvc3RzPC9saT4KICAgIDxsaT5MZWdhbCBwZW5hbHRpZXMgYW5kIHJlZ3VsYXRvcnkgZmluZXM8L2xpPgogICAgPGxpPkRhbWFnZSB0byBjb21wYW55IHJlcHV0YXRpb24gYW5kIGVtcGxveWVlIGNvbmZpZGVuY2U8L2xpPgogIDwvdWw+Cjwvc2VjdGlvbj4=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PHNlY3Rpb24gaWQ9ImNvbmNsdXNpb24iPgogIDxoMj5Db25jbHVzaW9uPC9oMj4KICA8cD4KICAgIEludmVzdGluZyBpbiBzYWZldHkgbm90IG9ubHkga2VlcHMgd29ya2VycyBzYWZlIGJ1dCBhbHNvIGVuc3VyZXMgbG9uZy10ZXJtIHN1Y2Nlc3MgYW5kIHByb3RlY3RzIHRoZSBjb21wYW55J3MgcmVwdXRhdGlvbi4gT2NjdXBhdGlvbmFsIHNhZmV0eSBpc3N1ZXMgYXJlIGEgc2VyaW91cyBjaGFsbGVuZ2UgYnV0IGNhbiBiZSBlZmZlY3RpdmVseSBjb250cm9sbGVkIHdpdGggYSB3ZWxsLXN0cnVjdHVyZWQsIGFkZXF1YXRlbHkgcmVzb3VyY2VkLCBhbmQgcGVvcGxlLWZvY3VzZWQgYXBwcm9hY2guCiAgPC9wPgoKICA8cD4KICAgIENvbXBhbmllcyBzaG91bGQgZm9jdXMgb246CiAgPC9wPgogIDx1bD4KICAgIDxsaT5IYXphcmQgcmVjb2duaXRpb248L2xpPgogICAgPGxpPkNsZWFyIHBvbGljaWVzPC9saT4KICAgIDxsaT5Db21wcmVoZW5zaXZlIHRyYWluaW5nPC9saT4KICAgIDxsaT5BbiBlZmZlY3RpdmUgc2FmZXR5IGN1bHR1cmU8L2xpPgogIDwvdWw+CgogIDxwPgogICAgQnkgZG9pbmcgdGhpcywgb3JnYW5pemF0aW9ucyBjYW46CiAgPC9wPgogIDx1bD4KICAgIDxsaT5NaW5pbWl6ZSByaXNrcyBvZiBpbmp1cnk8L2xpPgogICAgPGxpPkVuaGFuY2UgbW9yYWxlPC9saT4KICAgIDxsaT5VcGdyYWRlIG9wZXJhdGlvbmFsIGVmZmljaWVuY3k8L2xpPgogIDwvdWw+CgogIDxwPgogICAgT25nb2luZyBhd2FyZW5lc3MsIGlubm92YXRpb24sIGFuZCB3b3JrZXIgZW5nYWdlbWVudCBhcmUgdGhlIGJ1aWxkaW5nIGJsb2NrcyB0byBjcmVhdGUgYSBzYWZlIGFuZCBoZWFsdGh5IHdvcmsgZW52aXJvbm1lbnQgZm9yIGV2ZXJ5b25lLgogIDwvcD4KPC9zZWN0aW9uPg==
