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