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