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