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