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