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