R2F0ZS5pbyBBTUEgbWV0IE5pZ2h0VmVyc2UgR2FtZSAtIE9tZGF0IGRlIHJlYWxpdGVpdCBub29pdCBnZW5vZWcgaXM=

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