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