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