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