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