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