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