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