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