#include<bits/stdc++.h>
using namespace std;

//1点更新,区間最小
class SegmentTree {
public:
    SegmentTree(int64_t n, int64_t value) {
        n_ = (int64_t)pow(2, ceil(log2(n)));
        nodes_.resize(2 * n_ - 1, make_pair(value, INT_MIN));
    }

    void update(int64_t x, int64_t v) {
        nodes_[x + n_ - 1].first  = v;
        nodes_[x + n_ - 1].second = x;
        if (x + n_ - 1 == 0) {
            return;
        }
        for (int64_t i = (x + n_ - 2) / 2; ; i = (i - 1) / 2) {
            nodes_[i] = max(nodes_[2 * i + 1], nodes_[2 * i + 2]);
            if (i == 0) {
                break;
            }
        }
    }

    pair<int64_t, int64_t> getMax(int64_t a, int64_t b, int64_t k = 0, int64_t l = 0, int64_t r = -1) {
        if (r < 0) {
            r = n_;
        }
        if (r <= a || b <= l) {
            return { INT_MIN, -1 };
        }
        if (a <= l && r <= b) {
            return nodes_[k];
        }
        pair<int64_t, int64_t> lv = getMax(a, b, 2 * k + 1, l, (l + r) / 2);
        pair<int64_t, int64_t> rv = getMax(a, b, 2 * k + 2, (l + r) / 2, r);
        return max(lv, rv);
    }

private:
    //2のべき乗
    int64_t n_;
    vector<pair<int64_t, int64_t>> nodes_;
};

int main() {
    int64_t N;
    cin >> N;
    vector<string> S(N);
    for (string& s : S) {
        cin >> s;
    }

    //各文字列は((..((( or ))..))) or ))..))((..(( という形に変換できる
    //左カッコだけのものの左カッコの数、右カッコだけのものの右カッコの数について総和を取る
    int64_t left_sum = 0, right_sum = 0;

    //両方混ざっているものは以下のvectorに集める
    struct Brace {
        Brace(int64_t l, int64_t r) : left(l), right(r) {}
        int64_t left, right;
    };
    vector<Brace> braces;

    for (int64_t i = 0; i < N; i++) {
        int64_t l = 0, r = 0;
        for (char c : S[i]) {
            if (c == '(') {
                l++;
            } else {
                if (l > 0) {
                    l--;
                } else {
                    r++;
                }
            }
        }

        if (l == 0) {
            //右だけ
            right_sum += r;
        } else if (r == 0) {
            //左だけ
            left_sum += l;
        } else {
            braces.emplace_back(l, r);
        }
    }

    if (!braces.empty()) {
        //右カッコの数でソート
        sort(braces.begin(), braces.end(), [&](Brace& lhs, Brace& rhs) {
            return lhs.right < rhs.right;
        });

        //[0, r)での最大増加量を取得するために利用
        SegmentTree st(braces.size(), INT_MIN);

        //許容量みたいなイメージ
        vector<int64_t> right_num;

        //許容量と増加量の設定
        for (uint64_t i = 0; i < braces.size(); i++) {
            right_num.push_back(braces[i].right);
            st.update(i, braces[i].left - braces[i].right);
        }

        for (uint64_t i = 0; i < braces.size(); i++) {
            //今の許容量
            auto itr = upper_bound(right_num.begin(), right_num.end(), left_sum);

            //右端を求める
            int64_t r = (itr - right_num.begin());

            //取れるものがなかったら終わり
            if (r == 0) {
                cout << "No" << endl;
                return 0;
            }

            //[0, r)での最大値を取得
            pair<int64_t, int64_t> max_element = st.getMax(0, r);

            if (max_element.first == INT_MIN) {
                cout << "No" << endl;
                return 0;
            }

            //足す
            left_sum += max_element.first;
            st.update(max_element.second, INT_MIN);
        }
    }

    cout << (left_sum == right_sum ? "Yes" : "No") << endl;
}

Measured memory_bytes: 34384