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