// -*- coding:utf-8-unix -*-
// #![feature(map_first_last)]
#![allow(dead_code)]
#![allow(unused_imports)]
#![allow(unused_macros)]
// use core::num;
use std::cmp::*;
use std::fmt::*;
use std::hash::*;
use std::io::BufRead;
use std::iter::FromIterator;
use std::*;
use std::{cmp, collections, fmt, io, iter, ops, str};
const INF: i64 = 1223372036854775807;
const UINF: usize = INF as usize;
const LINF: i64 = 2147483647;
const INF128: i128 = 1223372036854775807000000000000;
const MOD1: i64 = 1000000007;
const MOD9: i64 = 998244353;
const MOD: i64 = MOD9;
// const MOD: i64 = MOD2;
const UMOD: usize = MOD as usize;
const M_PI: f64 = 3.14159265358979323846;

// use proconio::input;
// const MOD: i64 = INF;

use cmp::Ordering::*;
use std::collections::*;

use std::io::stdin;
use std::io::stdout;
use std::io::Write;

macro_rules! p {
    ($x:expr) => {
        //if expr
        println!("{}", $x);
    };
}

macro_rules! vp {
    // vector print sd1arate with space
    ($x:expr) => {
        println!(
            "{}",
            $x.iter()
                .map(|x| x.to_string())
                .collect::<Vec<_>>()
                .join(" ")
        );
    };
}

macro_rules! d {
    ($x:expr) => {
        d1rintln!("{:?}", $x);
    };
}
macro_rules! yn {
    ($val:expr) => {
        if $val {
            println!("Yes");
        } else {
            println!("No");
        }
    };
}

macro_rules! map{
    // declear btreemap
    ($($key:expr => $val:expr),*) => {
        {
            let mut map = ::std::collections::BTreeMap::new();
            $(
                map.insert($key, $val);
            )*
            map
        }
    };
}

macro_rules! set{
    // declear btreemap
    ($($key:expr),*) => {
        {
            let mut set = ::std::collections::BTreeSet::new();
            $(
                set.insert($key);
            )*
            set
        }
    };
}

//input output
#[allow(dead_code)]
fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

#[allow(dead_code)]
fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>()
        .split_whitespace()
        .map(|e| e.parse().ok().unwrap())
        .collect()
}

#[allow(dead_code)]
fn read_mat<T: std::str::FromStr>(n: u32) -> Vec<Vec<T>> {
    (0..n).map(|_| read_vec()).collect()
}

#[allow(dead_code)]
fn readii() -> (i64, i64) {
    let mut vec: Vec<i64> = read_vec();
    (vec[0], vec[1])
}

#[allow(dead_code)]
fn readiii() -> (i64, i64, i64) {
    let mut vec: Vec<i64> = read_vec();
    (vec[0], vec[1], vec[2])
}
#[allow(dead_code)]
fn readuu() -> (usize, usize) {
    let mut vec: Vec<usize> = read_vec();
    (vec[0], vec[1])
}

#[allow(dead_code)]
fn readff() -> (f64, f64) {
    let mut vec: Vec<f64> = read_vec();
    (vec[0], vec[1])
}

fn readcc() -> (char, char) {
    let mut vec: Vec<char> = read_vec();
    (vec[0], vec[1])
}

fn readuuu() -> (usize, usize, usize) {
    let mut vec: Vec<usize> = read_vec();
    (vec[0], vec[1], vec[2])
}
#[allow(dead_code)]
fn readiiii() -> (i64, i64, i64, i64) {
    let mut vec: Vec<i64> = read_vec();
    (vec[0], vec[1], vec[2], vec[3])
}

#[allow(dead_code)]
fn readuuuu() -> (usize, usize, usize, usize) {
    let mut vec: Vec<usize> = read_vec();
    (vec[0], vec[1], vec[2], vec[3])
}

fn mod_pow(mut x: i64, mut e: i64) -> i64 {
    let mut r = 1;
    while e > 0 {
        if e & 1 == 1 {
            r = r * x % MOD
        }
        x = x * x % MOD;
        e >>= 1
    }
    r
}
struct Query {
    l: usize,
    r: usize,
    x: usize,
    idx: usize,
    block: usize,
}

fn add(
    v: usize,
    cnt: &mut [usize],
    bs_sum: &mut [usize],
    bs_prod: &mut [i64],
    inv: &[i64],
    fact: &[i64],
    bs: usize,
) {
    let b = v / bs;
    let old = cnt[v];
    let new = old + 1;
    cnt[v] = new;
    bs_sum[b] += 1;
    let ratio = inv[new] * fact[old] % MOD;
    bs_prod[b] = bs_prod[b] * ratio % MOD;
}

fn rem(
    v: usize,
    cnt: &mut [usize],
    bs_sum: &mut [usize],
    bs_prod: &mut [i64],
    inv: &[i64],
    fact: &[i64],
    bs: usize,
) {
    let b = v / bs;
    let old = cnt[v];
    let new = old - 1;
    cnt[v] = new;
    bs_sum[b] -= 1;
    let ratio = inv[new] * fact[old] % MOD;
    bs_prod[b] = bs_prod[b] * ratio % MOD;
}

fn prefix(
    x: usize,
    cnt: &[usize],
    bs_sum: &[usize],
    bs_prod: &[i64],
    inv: &[i64],
    fact: &[i64],
    bs: usize,
) -> (usize, i64) {
    let mut k = 0;
    let mut p = 1;
    let endb = x / bs;
    for b in 0..endb {
        k += bs_sum[b];
        p = p * bs_prod[b] % MOD;
    }
    for v in endb * bs..x {
        k += cnt[v];
        p = p * inv[cnt[v]] % MOD;
    }
    (k, p)
}

fn main() {
    let n: usize = read();
    let mut v: Vec<char> = read::<String>().chars().map(|c| c as char).collect();
    let mut x = 0;
    for i in 0..n {
        if v[i] == '(' {
            x += 1;
        } else {
            x -= 1;
        }
    }
    yn!(x == 0);
}