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