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