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