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