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