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