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PHNlY3Rpb24gaWQ9IndoeS1oYW5kbGluZy1oYXphcmRvdXMtbWF0ZXJpYWxzLWlzLWEtdG9wLWIyYi1wcmlvcml0eSI+CiAgPGgyPldoeSBIYW5kbGluZyBIYXphcmRvdXMgTWF0ZXJpYWxzIGlzIGEgVG9wIEIyQiBQcmlvcml0eTwvaDI+CiAgPHA+CiAgICBJbiBCMkIgc2V0dGluZ3MsIGVzcGVjaWFsbHkgaW4gbWFudWZhY3R1cmluZywgd2FyZWhvdXNpbmcsIGxvZ2lzdGljcywgYW5kIGhlYWx0aGNhcmUsIHRoZSByaXNrIHNjYWxlcyB3aXRoIHZvbHVtZS4gQSBzbWFsbCBtaXNoYXAgY2FuIGxlYWQgdG86CiAgPC9wPgogIDx1bD4KICAgIDxsaT5Xb3JrcGxhY2UgaW5qdXJpZXMgb3IgZmF0YWxpdGllczwvbGk+CiAgICA8bGk+UmVndWxhdG9yeSBmaW5lcyAoT1NIQSwgRVBBLCBET1QsIGxvY2FsIGFnZW5jaWVzKTwvbGk+CiAgICA8bGk+UHJvZHVjdGlvbiBkb3dudGltZTwvbGk+CiAgICA8bGk+QnJhbmQgZGFtYWdlIGFuZCBsYXdzdWl0czwvbGk+CiAgICA8bGk+RW52aXJvbm1lbnRhbCBjb250YW1pbmF0aW9uPC9saT4KICA8L3VsPgogIDxwPgogICAgQnV5ZXJzLCBmYWNpbGl0eSBtYW5hZ2VycywgRUhTIG9mZmljZXJzLCBhbmQgc2FmZXR5IGRlY2lzaW9uLW1ha2VycyBtdXN0IGFsaWduIG9uIHN0YW5kYXJkaXplZCBzYWZldHkgcHJvdG9jb2xzLCBiYWNrZWQgYnkgZGF0YSwgdHJhaW5pbmcsIGFuZCBtb2Rlcm4gdG9vbHMuCiAgPC9wPgo8L3NlY3Rpb24+Cg==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PHNlY3Rpb24gaWQ9ImNvbW1vbi1oYXptYXQtZXJyb3JzIj4KICA8aDI+Q29tbW9uIEhhem1hdCBFcnJvcnMgdG8gQXZvaWQgaW4gV29ya3BsYWNlIEVudmlyb25tZW50czwvaDI+CiAgPHA+CiAgICBDb3N0bHkgbWlzdGFrZXMgYXJlIG1hZGUgYnkgZXZlbiBleHBlcmllbmNlZCB0ZWFtcy4gS2VlcCBhbiBleWUgb3V0IGZvcjoKICA8L3A+CiAgPHVsPgogICAgPGxpPk1pc3Npbmcgb3Igb3V0ZGF0ZWQgU0RTcy48L2xpPgogICAgPGxpPkluYWNjdXJhdGUgbGFiZWxpbmcgb2Ygc2Vjb25kYXJ5IGNvbnRhaW5lcnMuPC9saT4KICAgIDxsaT5LZWVwaW5nIHN1YnN0YW5jZXMgdGhhdCBhcmUgaW5jb21wYXRpYmxlIHRvZ2V0aGVyLjwvbGk+CiAgICA8bGk+Tm90IHByb3ZpZGluZyB0cmFpbmluZyB0byB0ZW1wb3JhcnkgZW1wbG95ZWVzIG9yIG5ldyBoaXJlcy48L2xpPgogICAgPGxpPlBvb3IgdmVudGlsYXRpb24gb3IgaW1wcm9wZXIgdXNlIG9mIHBlcnNvbmFsIHByb3RlY3RpdmUgZXF1aXBtZW50LjwvbGk+CiAgICA8bGk+SGF6YXJkb3VzIHdhc3RlIGltcHJvcGVybHkgZGlzcG9zZWQgb2YuPC9saT4KICA8L3VsPgogIDxwPgogICAgQW55IG9mIHRoZXNlIGNvdWxkIGxlYWQgdG8gYWN0dWFsIHNhZmV0eSByZXBlcmN1c3Npb25zLCBsZWdhbCBhY3Rpb24sIGFuZCByZWd1bGF0b3J5IGF1ZGl0cy4KICA8L3A+Cjwvc2VjdGlvbj4KPHNlY3Rpb24gaWQ9ImVocy1zb2Z0d2FyZS1iZW5lZml0cyI+CiAgPGgyPkhvdyBFSFMgU29mdHdhcmUgU2ltcGxpZmllcyBIYXptYXQgTWFuYWdlbWVudDwvaDI+CiAgPHA+CiAgICBTcHJlYWRzaGVldHMgYW5kIG1hbnVhbCB0cmFja2luZyBhcmUgbm8gbG9uZ2VyIHN1ZmZpY2llbnQuIE9yZ2FuaXphdGlvbnMgYmVuZWZpdCBmcm9tIGRpZ2l0YWwgRUhTIHBsYXRmb3JtczoKICA8L3A+CiAgPHVsPgogICAgPGxpPktlZXAgeW91ciBTRFMgZGF0YWJhc2VzIGN1cnJlbnQuPC9saT4KICAgIDxsaT5UcmFjayBjaGVtaWNhbCBpbnZlbnRvcmllcyBhdXRvbWF0aWNhbGx5LjwvbGk+CiAgICA8bGk+Q3JlYXRlIGNvbXBsaWFuY2UgcmVwb3J0cyBpbnN0YW50bHkuPC9saT4KICAgIDxsaT5TZXQgcmVhY3Rpdml0eSBhbmQgc2hlbGYtbGlmZSBhbGVydHMuPC9saT4KICAgIDxsaT5Bc3NpZ24gcmVtZWRpYWwgbWVhc3VyZXMgYW5kIHRyYWNrIHRoZWlyIGNvbXBsZXRpb24uPC9saT4KICA8L3VsPgogIDxwPgogICAgRUhTIG1hbmFnZXJzIGNhbiBjb25jZW50cmF0ZSBvbiBzdHJhdGVnaWMgcmlzayByZWR1Y3Rpb24gdGhhbmtzIHRvIHRoZXNlIHN5c3RlbXMsIHdoaWNoIGFsc28gaW1wcm92ZSB0cmFuc3BhcmVuY3kgYW5kIGRlY3JlYXNlIGh1bWFuIGVycm9yLgogIDwvcD4KPC9zZWN0aW9uPgo=PHNlY3Rpb24gaWQ9ImVzZy1hbmQtc3VzdGFpbmFiaWxpdHkiPgogIDxoMj5FU0cgYW5kIFN1c3RhaW5hYmlsaXR5OiBIYXptYXQgU2FmZXR5IFdvcmtzIGFzIGEgRGlmZmVyZW50aWF0b3I8L2gyPgogIDxwPgogICAgRW52aXJvbm1lbnRhbCwgc29jaWFsLCBhbmQgZ292ZXJuYW5jZSAoRVNHKSBwZXJmb3JtYW5jZSBpcyBhIG11c3QgZm9yIHRvZGF5J3MgYnVzaW5lc3MtdG8tYnVzaW5lc3MgKEIyQikgYnV5ZXJzIGFuZCBzdGFrZWhvbGRlcnMuIAogICAgU2FmZSBoYW5kbGluZyBvZiBoYXphcmRvdXMgbWF0ZXJpYWxzOgogIDwvcD4KICA8dWw+CiAgICA8bGk+TG93ZXJzIHRoZSByaXNrIHRvIHRoZSBlbnZpcm9ubWVudC48L2xpPgogICAgPGxpPlByZXNlcnZlcyB0aGUgd2VsbGJlaW5nIG9mIGVtcGxveWVlcy48L2xpPgogICAgPGxpPkV4aGliaXRzIHByb2FjdGl2ZSBhZGhlcmVuY2UgdG8gc3Rha2Vob2xkZXJzIGFuZCBhdWRpdHMuPC9saT4KICAgIDxsaT5Cb29zdHMgY29uc3VtZXIgdHJ1c3QgYW5kIGJyYW5kIHJlcHV0YXRpb24uPC9saT4KICA8L3VsPgogIDxwPgogICAgU2FmZXR5IHByb2NlZHVyZXMgY2FuIG1ha2Ugb3IgYnJlYWsgYSBkZWFsIGluIFJGUXMsIFJGUHMsIGFuZCBzdXBwbGllciBhdWRpdHMuCiAgPC9wPgo8L3NlY3Rpb24+Cg==PHNlY3Rpb24gaWQ9ImZpbmFsLXRob3VnaHRzIj4KICA8aDI+RmluYWwgVGhvdWdodHM8L2gyPgogIDxwPgogICAgRUhTIGRlcGFydG1lbnRzIGFyZSBub3Qgc29sZWx5IHJlc3BvbnNpYmxlIGZvciB0aGUgc2FmZXR5IG9mIGhhemFyZG91cyBtYXRlcmlhbHMuIAogICAgSXQgbmVlZHMgdG8gYmUgaW50ZWdyYXRlZCBpbnRvIGxlYWRlcnNoaXAsIHB1cmNoYXNpbmcsIGludmVudG9yeSwgYW5kIG9wZXJhdGlvbnMuIAogICAgQjJCIGNvbXBhbmllcyB0aGF0IGFkb3B0IGEgcHJvYWN0aXZlLCB0ZWNobm9sb2dpY2FsbHkgYWR2YW5jZWQsIGFuZCB0cmFpbmluZy1yaWNoIHN0cmF0ZWd5IAogICAgd2lsbCBzdXJwYXNzIHJpdmFscyBpbiBhZGRpdGlvbiB0byByZW1haW5pbmcgY29tcGxpYW50LgogIDwvcD4KPC9zZWN0aW9uPgo=
