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