
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
eyJjb29yZGluYXRlcyI6eyJsZWZ0IjozMC44LCJ0b3AiOjY5LjYzfSwiZGVmaW5pdGlvbnMiOnsidGl0bGUiOiJPZmZpY2VzIiwibWVzc2FnZSI6Ijx1bD48bGk+RW1wbG95ZWVzIG5hdmlnYXRlIGxhcmdlIGNhbXB1c2VzIHdpdGggaW5kb29yIG1hcHMgYW5kIHJlYWwtdGltZSBkaXJlY3Rpb25zLjwvbGk+PGxpPkdlb2ZlbmNpbmcgc3VwcG9ydHMgZHluYW1pYyBkZXNrIGJvb2tpbmcgYW5kIG1lZXRpbmcgcm9vbSBhY2Nlc3MuPC9saT48bGk+T2NjdXBhbmN5IGFuYWx5dGljcyBvcHRpbWl6ZSBoZWF0aW5nLCB2ZW50aWxhdGlvbiwgYWlyIGNvbmRpdGlvbmluZywgYW5kIGxpZ2h0aW5nIGZvciBzdXN0YWluYWJpbGl0eS48L2xpPjxsaT5Mb2NhdGlvbi1iYXNlZCBhbGVydHMgYXNzaXN0IGluIGVtZXJnZW5jeSBldmFjdWF0aW9ucyBhbmQgY29tcGxpYW5jZSB0cmFja2luZy48L2xpPjwvdWw+IiwibGluayI6IiIsImNvbG9yIjoiQmx1ZSIsIm1lZGlhSHRtbE1hcmt1cHMiOlsiPGltZyAgY2xhc3M9J2xhenlsb2FkICAnIGRhdGEtc3JjPSdodHRwczovL21lZGlhYmFuay5lcmljc3Nvbi5uZXQvZGVwbG95ZWRGaWxlcy9lcmljc3Nvbi5jb20vU21hbGwlMjBjZWxsJTIwT2ZmaWNlJTIwc3BhY2VfMTk1NDY5JTIwKDUpLmpwZycgZGF0YS1zcmNzZXQ9XCJodHRwczovL21lZGlhYmFuay5lcmljc3Nvbi5uZXQvY2RuLWNnaS9pbWFnZS9mb3JtYXQ9YXV0byxmaXQ9c2NhbGUtZG93bix3aWR0aD0zNzUvZGVwbG95ZWRGaWxlcy9lcmljc3Nvbi5jb20vU21hbGwlMjBjZWxsJTIwT2ZmaWNlJTIwc3BhY2VfMTk1NDY5JTIwKDUpLmpwZyAzNzV3LCBodHRwczovL21lZGlhYmFuay5lcmljc3Nvbi5uZXQvY2RuLWNnaS9pbWFnZS9mb3JtYXQ9YXV0byxmaXQ9c2NhbGUtZG93bix3aWR0aD03MDAvZGVwbG95ZWRGaWxlcy9lcmljc3Nvbi5jb20vU21hbGwlMjBjZWxsJTIwT2ZmaWNlJTIwc3BhY2VfMTk1NDY5JTIwKDUpLmpwZyA3MDB3LCBodHRwczovL21lZGlhYmFuay5lcmljc3Nvbi5uZXQvY2RuLWNnaS9pbWFnZS9mb3JtYXQ9YXV0byxmaXQ9c2NhbGUtZG93bix3aWR0aD05MDAvZGVwbG95ZWRGaWxlcy9lcmljc3Nvbi5jb20vU21hbGwlMjBjZWxsJTIwT2ZmaWNlJTIwc3BhY2VfMTk1NDY5JTIwKDUpLmpwZyA5MDB3LCBodHRwczovL21lZGlhYmFuay5lcmljc3Nvbi5uZXQvY2RuLWNnaS9pbWFnZS9mb3JtYXQ9YXV0byxmaXQ9c2NhbGUtZG93bix3aWR0aD0xMjAwL2RlcGxveWVkRmlsZXMvZXJpY3Nzb24uY29tL1NtYWxsJTIwY2VsbCUyME9mZmljZSUyMHNwYWNlXzE5NTQ2OSUyMCg1KS5qcGcgMTIwMHcsIGh0dHBzOi8vbWVkaWFiYW5rLmVyaWNzc29uLm5ldC9jZG4tY2dpL2ltYWdlL2Zvcm1hdD1hdXRvLGZpdD1zY2FsZS1kb3duLHdpZHRoPTE0NDAvZGVwbG95ZWRGaWxlcy9lcmljc3Nvbi5jb20vU21hbGwlMjBjZWxsJTIwT2ZmaWNlJTIwc3BhY2VfMTk1NDY5JTIwKDUpLmpwZyAxNDQwdywgaHR0cHM6Ly9tZWRpYWJhbmsuZXJpY3Nzb24ubmV0L2Nkbi1jZ2kvaW1hZ2UvZm9ybWF0PWF1dG8sZml0PXNjYWxlLWRvd24sd2lkdGg9MTkyMC9kZXBsb3llZEZpbGVzL2VyaWNzc29uLmNvbS9TbWFsbCUyMGNlbGwlMjBPZmZpY2UlMjBzcGFjZV8xOTU0NjklMjAoNSkuanBnIDE5MjB3LCBodHRwczovL21lZGlhYmFuay5lcmljc3Nvbi5uZXQvY2RuLWNnaS9pbWFnZS9mb3JtYXQ9YXV0byxmaXQ9c2NhbGUtZG93bix3aWR0aD0zODQwL2RlcGxveWVkRmlsZXMvZXJpY3Nzb24uY29tL1NtYWxsJTIwY2VsbCUyME9mZmljZSUyMHNwYWNlXzE5NTQ2OSUyMCg1KS5qcGcgMzg0MHdcIiBzaXplcz1cIihtYXgtd2lkdGg6IDQ3OXB4KSAxMDB2dywgKG1pbi13aWR0aDogNDgwcHgpIGFuZCAobWF4LXdpZHRoOiAxMTk5cHgpIDUwdncsIChtaW4td2lkdGg6IDEyMDBweCkgYW5kIChtYXgtd2lkdGg6IDE5MTlweCkgMjJ2dywgKG1pbi13aWR0aDogMTkyMHB4KSBhbmQgKG1heC13aWR0aDogMjU1OXB4KSAyNXZ3LCAobWluLXdpZHRoOiAyNTYwcHgpIDE4dndcIiBhbHQ9XCJPZmZpY2VzXCIgdGl0bGU9XCJPZmZpY2VzXCIgICBkYXRhLWltYWdlLXR5cGUtbmFtZT0naW1hZ2UtbGlzdC1wYWdlJyAgIGRhdGEtZ2lmLWltYWdlPVwiRmFsc2VcIiBzcmM9XCJkYXRhOmltYWdlL3N2Zyt4bWwsJTNDc3ZnIHhtbG5zPSdodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Zycgdmlld0JveD0nMCAwIDE2IDknJTNFJTNDL3N2ZyUzRVwiIHdpZHRoPScxNicgaGVpZ2h0PSc5JyAgLz4iXSwib3JnYW5pemF0aW9uIjpbXSwiYWx0VGV4dCI6Ik9mZmljZXMiLCJ2aWRlb0RhdGEiOm51bGx9LCJyZWFkYWJsZVR5cGUiOiJwb2ludCJ9
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