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