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