R2F0ZS5pbyBBTUEgY29uIE5pbWlxLVRvIFBvdGVuemlhIHR1dHRpIGdsaSBlc3NlcmkgdW1hbmkgY29uIHBhZ2FtZW50aSBkZWNlbnRyYWxpenphdGkgbWEgZmFjaWxp
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