R2F0ZS5pbyBBTUEgbWV0IERlZmkgTGFuZC1EZUZpLCBHYW1pbmcsIE5GVCdzIGVuIE1ldGF2ZXJzZSBvcG5pZXV3IHVpdGdldm9uZGVuIGluIGVlbiBuaWV1dyBlbiBhbGxlcy1pbi3DqcOpbiBzcGVs

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