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