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