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