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