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