R8O8bmzDvGsgSGFiZXJsZXIgfCBCVEMsIEFCRCBWYWRlbGkgxLDFn2xlbWxlcmkgaWxlIEtvcmVsYXN5b24gWcO8a3NlbGRpa8OnZSAxMCBHw7xuw7xuIEVuIETDvMWfw7xrIFNldml5ZXNpbmkgS8SxcmTEsSwgw4dpbiBSYWhhdGxhdMSxY8SxIEthcmFudGluYXnEsSBEw7zFn8O8bsO8eW9y

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