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