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