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