// #pragma once // huu khanh chy
#include <bits/stdc++.h>
 
// #pragma GCC optimize("Ofast")
// #pragma GCC optimize("O3")
// #pragma GCC optimize("unroll-loops")
// #pragma GCC target("avx,avx2")
// #pragma GCC target("bmi,bmi2")
// #pragma GCC target("popcnt,lzcnt")
 
// #pragma GCC optimize("Os")
// #pragma GCC optimize("O2")
// #pragma GCC optimize("inline")
// #pragma GCC optimize("fast-math")
// #pragma GCC target("fma")
// #pragma GCC target("sse,sse2")
// #pragma GCC target("sse3,ssse3")
// #pragma GCC target("sse4.1,sse4.2")
 
#define FOR(i, n) for(long long (i) = 0; (i) < (n); ++(i))
#define forr(i, l, r, k) for (long long i = (l); i <= (r); i += (k))
#define rfor(i, r, l, k) for (long long i = (r); i >= (l); i -= (k))
#define SORT(a) sort((a).begin(), (a).end())
#define RSORT(a) sort((a).begin(), (a).end(), greater<long long>())
#define sortt(a, type) sort((a).begin(), (a).end(), type)
#define for_Cout(a, char) for (auto c : (a)) cout << c << char;
#define REV(s) reverse((s).begin(), (s).end())
#define mset(a, valueptr) memset(a, valueptr, sizeof a)
#define biton(x, i) ((x) >> (i) & 1)
#define MASK(i) (1ll << (i))
#define TIME cerr << "Time: " << 1.0 * clock() / CLOCKS_PER_SEC << "s\n"
#define int long long
#define nn "\n"
#define fi first
#define se second
#define pb push_back
#define ins insert
#define All(x) (x).begin(), (x).end()
#define pii pair<int, int>
#define pli pair<long long, int>
#define pll pair<long long, long long>
#define vll vector<long long>
#define vit vector<int>
#define vbl vector<bool>
#define vstr vector<string>
#define v(datatype) vector<datatype>
#define vvll vector<vector<long long>>
#define TASK "name"
 
template<typename... value> void inall(value&... valueofvalue) { ((std::cin >> valueofvalue), ...); }
template<typename... value> void outall(char valueofchar, const value&... valueofvalue) { ((std::cout << valueofvalue << valueofchar), ...); std::cout << valueofchar; }
template<class X, class Y> bool maximize(X& x, const Y& y) { if (x < y) { x = y; return true; } return false; }
template<class X, class Y> bool minimize(X& x, const Y& y) { if (x > y) { x = y; return true; } return false; }
 
using namespace std;
 
inline void fastIO() noexcept(true) { ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); }
inline long long ucln(long long a, long long b) { while (a != 0) { long long uc = a; a = b % a ; b = uc; } return b; }
inline long long bcnn(long long a, long long b) { long long res = (a * b) / ucln(a, b); return res; }
inline long long luythua(long long a, long long b) { long long res = 1; while (b) { if (b & 1) { res *= a; } a = a * a; b >>= 1; } return res; }
inline long long giathua(long long num) { unsigned long long res = 1; for (unsigned long long i = 2; i <= num; ++i) res *= i; return res; }
inline long long luythualaydu (long long a, long long b, long long mod) { long long res = 1; a = a % mod; while (b > 0) { if (b & 1) { res = (res * a) % mod; } a = (a * a) % mod; b >>= 1; } return res; }
inline long long giathualaydu (long long num, long long mod) { unsigned long long res = 1; for (unsigned long long i = 2; i <= num; ++i) res = (res * i) % mod; return res; }
 
typedef char cr;
typedef string str;
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef bool bl;
typedef long double ldb;
 
constexpr long long MOD1 = 1000000007LL;
constexpr long long MOD2 = 1000000009LL;
constexpr long long MOD3 = 2147483647LL;
constexpr long long INF = 1000000000000000000LL;
constexpr int base1= 310;
constexpr int base2 = 256;
constexpr long long N = 1e4 + 5;
 
struct node {
    int u, v, w;
};
// int n, m, h[MAXn], dp[MAXn][17], nhim[MAXn], nguyet[MAXn];
// ll ans = 0; v(pii) a[MAXn]; v(node) tmp;
// void input() noexcept(true) {
//     inall(n, m);
//     forr(i, 1, m, 1) {
//         int u, v, w; inall(u, v, w);
//         a[u].pub({v, w});
//         a[v].pub({u, w});
//         tmp.pub({u, v, w});
//     }
//     TIME;
// }
// void dfs(int u, int fu, int hei) noexcept(true) {
//     dp[u][0] = fu; h[u] = hei;
//     for (int i = 1; i < 17; ++i) {
//         dp[u][i] = dp[dp[u][i - 1]][i - 1];
//     }
//     for (auto [v, w] : a[u]) {
//         if (v != fu) dfs(v, u, hei + 1);
//     }
// }
// int lca(int u, int v) {
//     if (h[u] < h[v]) swap(u, v);
//     int d = h[u] - h[v];
//     for (int i = 0; i < 17; ++i) {
//         if (biton(d, i)) u = dp[u][i];
//     }
//     if (u == v) return u;
//     for (int i = 16; i >= 0; --i) {
//         if (dp[u][i] != dp[v][i]) {
//             u = dp[u][i]; v = dp[v][i];
//         }
//     }
//     return dp[u][0];
// }
// void dfs2(int u, int fu) noexcept(true) {
//     for (auto [v, w] : a[u]) {
//         if (v == fu) continue;
//         dfs2(v, u);
//         if (nhim[v] >= w) ans += 1LL * (nhim[v] - w);
//         nhim[u] = max(nhim[u], nhim[v]);
//     }
//     if (nhim[u] <= nguyet[u]) nhim[u] = 0;
// }
// void output() noexcept(true) {
//     dfs(1, 1, 0);
//     for (int i = 0; i < m; ++i) {
//         node k = tmp[i];
//         int l = lca(k.u, k.v);
//         nguyet[l] = max(nguyet[l], k.w);
//         nhim[k.u] = max(nhim[k.u], k.w);
//         nhim[k.v] = max(nhim[k.v], k.w);
//     }
//     dfs2(1, 1);
//     cout << ans;
//     TIME;
// }
// struct node {
//     int u, v, w;
// };
// int n, m, h[MAXn], dp[MAXn][17], nhim[MAXn], nguyet[MAXn];
// int par[MAXn], par_w[MAXn], order_arr[MAXn], ord_cnt;
// ll ans = 0; v(pii) a[MAXn]; v(node) tmp;
//
// void input() noexcept(true) {
//     inall(n, m);
//     forr(i, 1, m, 1) {
//         int u, v, w; inall(u, v, w);
//         a[u].pub({v, w});
//         a[v].pub({u, w});
//         tmp.pub({u, v, w});
//     }
//     TIME;
// }
//
// void bfs() noexcept(true) {
//     queue<int> q;
//     v(bool) vis(n + 1, false);
//     par[1] = 1; par_w[1] = 0; h[1] = 0;
//     vis[1] = true; q.push(1);
//     while (!q.empty()) {
//         int u = q.front(); q.pop();
//         order_arr[ord_cnt++] = u;
//         dp[u][0] = par[u];
//         for (int i = 1; i < 17; ++i)
//             dp[u][i] = dp[dp[u][i-1]][i-1];
//         for (auto [v, w] : a[u]) {
//             if (!vis[v]) {
//                 vis[v] = true;
//                 par[v]   = u;
//                 par_w[v] = w;
//                 h[v]     = h[u] + 1;
//                 q.push(v);
//             }
//         }
//     }
// }
//
// int lca(int u, int v) {
//     if (h[u] < h[v]) swap(u, v);
//     int d = h[u] - h[v];
//     for (int i = 0; i < 17; ++i) {
//         if (biton(d, i)) u = dp[u][i];
//     }
//     if (u == v) return u;
//     for (int i = 16; i >= 0; --i) {
//         if (dp[u][i] != dp[v][i]) {
//             u = dp[u][i]; v = dp[v][i];
//         }
//     }
//     return dp[u][0];
// }
//
// void solve() noexcept(true) {
//     for (int i = ord_cnt - 1; i >= 1; --i) {
//         int v = order_arr[i];
//
//         if (nhim[v] <= nguyet[v]) nhim[v] = 0;
//
//         int u = par[v];
//         int w = par_w[v];
//
//         if (nhim[v] > w) ans += 1LL * (nhim[v] - w);
//         nhim[u] = max(nhim[u], nhim[v]);
//     }
// }
//
// void output() noexcept(true) {
//     bfs();
//     for (int i = 0; i < m; ++i) {
//         node k = tmp[i];
//         int l = lca(k.u, k.v);
//         nguyet[l] = max(nguyet[l], k.w);
//         nhim[k.u] = max(nhim[k.u], k.w);
//         nhim[k.v] = max(nhim[k.v], k.w);
//     }
//     solve();
//     cout << ans;
//     TIME;
// }
 
// struct node {
//     int u, v, w;
// };
// int n, m, h[MAXn], dp[MAXn][17], nhim[MAXn], nguyet[MAXn];
// int par[MAXn], par_w[MAXn], order_arr[MAXn], ord_cnt;
// int dsu[MAXn];
// ll ans = 0;
// v(pii) a[MAXn];   // chỉ chứa cạnh MST
// v(node) tmp;      // tất cả cạnh gốc
//
// // ─── DSU ─────────────────────────────────────────────
// int find(int x) { return dsu[x] == x ? x : dsu[x] = find(dsu[x]); }
// bool unite(int x, int y) {
//     x = find(x); y = find(y);
//     if (x == y) return false;
//     dsu[x] = y; return true;
// }
//
// void input() noexcept(true) {
//     inall(n, m);
//     forr(i, 1, m, 1) {
//         int u, v, w; inall(u, v, w);
//         tmp.pub({u, v, w});   // KHÔNG add vào a[] ở đây
//     }
//     TIME;
// }
//
// // ─── Kruskal MAX spanning tree → add vào a[] ─────────
// void build_mst() noexcept(true) {
//     forr(i, 1, n, 1) dsu[i] = i;
//     sort(tmp.begin(), tmp.end(), [](const node& x, const node& y){
//         return x.w > y.w;   // giảm dần → MAX spanning tree
//     });
//     for (auto& k : tmp) {
//         if (unite(k.u, k.v)) {
//             a[k.u].pub({k.v, k.w});
//             a[k.v].pub({k.u, k.w});
//         }
//     }
// }
//
// // ─── BFS thay dfs ────────────────────────────────────
// void bfs() noexcept(true) {
//     queue<int> q;
//     v(bool) vis(n + 1, false);
//     par[1] = 1; par_w[1] = 0; h[1] = 0;
//     vis[1] = true; q.push(1);
//     while (!q.empty()) {
//         int u = q.front(); q.pop();
//         order_arr[ord_cnt++] = u;
//         dp[u][0] = par[u];
//         for (int i = 1; i < 17; ++i)
//             dp[u][i] = dp[dp[u][i-1]][i-1];
//         for (auto [v, w] : a[u]) {
//             if (!vis[v]) {
//                 vis[v] = true;
//                 par[v]   = u;
//                 par_w[v] = w;
//                 h[v]     = h[u] + 1;
//                 q.push(v);
//             }
//         }
//     }
// }
//
// int lca(int u, int v) {
//     if (h[u] < h[v]) swap(u, v);
//     int d = h[u] - h[v];
//     for (int i = 0; i < 17; ++i) {
//         if (biton(d, i)) u = dp[u][i];
//     }
//     if (u == v) return u;
//     for (int i = 16; i >= 0; --i) {
//         if (dp[u][i] != dp[v][i]) {
//             u = dp[u][i]; v = dp[v][i];
//         }
//     }
//     return dp[u][0];
// }
//
// // ─── Solve thay dfs2 ─────────────────────────────────
// void solve() noexcept(true) {
//     for (int i = ord_cnt - 1; i >= 1; --i) {
//         int v = order_arr[i];
//
//         if (nhim[v] <= nguyet[v]) nhim[v] = 0;
//
//         int u = par[v];
//         int w = par_w[v];
//
//         if (nhim[v] > w) ans += 1LL * (nhim[v] - w);
//         nhim[u] = max(nhim[u], nhim[v]);
//     }
// }
//
// void output() noexcept(true) {
//     build_mst();   // build MST trước
//     bfs();         // BFS trên MST
//
//     // dùng TẤT CẢ m cạnh gốc (tmp đã sort nhưng không ảnh hưởng)
//     for (auto& k : tmp) {
//         int l = lca(k.u, k.v);
//         nguyet[l] = max(nguyet[l], k.w);
//         nhim[k.u] = max(nhim[k.u], k.w);
//         nhim[k.v] = max(nhim[k.v], k.w);
//     }
//     solve();
//     cout << ans;
//     TIME;
// }
// int n, m, h[MAXn];
// int dp[MAXn][17];     // binary lifting cha
// int mn[MAXn][17];     // min edge trên path lên 2^i bước
// int par[MAXn], par_w[MAXn], order_arr[MAXn], ord_cnt;
// int dsu[MAXn];
// ll ans = 0;
// v(pii) a[MAXn];       // chỉ cạnh MST
// v(node) tmp;
 
// // DSU
// int find(int x) { return dsu[x] == x ? x : dsu[x] = find(dsu[x]); }
// bool unite(int x, int y) {
    // x = find(x); y = find(y);
    // if (x == y) return false;
    // dsu[x] = y; return true;
// }
 
 
// Kruskal MAX spanning tree → build a[]
// void build_mst() noexcept(true) {
    // forr(i, 1, n, 1) dsu[i] = i;
    // sort(tmp.begin(), tmp.end(), [](const node& x, const node& y){
        // return x.w > y.w;
    // });
    // for (auto& k : tmp)
        // if (unite(k.u, k.v)) {
            // a[k.u].pub({k.v, k.w});
            // a[k.v].pub({k.u, k.w});
        // }
// }
//  
// // BFS build LCA + min-edge sparse table
// void bfs() noexcept(true) {
    // queue<int> q;
    // v(bool) vis(n + 1, false);
    // par[1] = 1; par_w[1] = 0; h[1] = 0;
    // vis[1] = true; q.push(1);
    // while (!q.empty()) {
        // int u = q.front(); q.pop();
        // order_arr[ord_cnt++] = u;
        // dp[u][0] = par[u];
        // mn[u][0] = par_w[u];   // cạnh u -> cha
        // for (int i = 1; i < 17; ++i) {
            // dp[u][i] = dp[dp[u][i-1]][i-1];
            // mn[u][i] = min(mn[u][i-1], mn[dp[u][i-1]][i-1]);
        // }
        // for (auto [v, w] : a[u])
            // if (!vis[v]) {
                // vis[v] = true;
                // par[v] = u; par_w[v] = w;
                // h[v] = h[u] + 1;
                // q.push(v);
            // }
    // }
// }
//  
// int lca_query(int u, int v) {
    // int res = INT_MAX;
    // if (h[u] < h[v]) swap(u, v);
    // int d = h[u] - h[v];
    // for (int i = 0; i < 17; ++i)
        // if (biton(d, i)) { res = min(res, mn[u][i]); u = dp[u][i]; }
    // if (u == v) return res;
    // for (int i = 16; i >= 0; --i)
        // if (dp[u][i] != dp[v][i]) {
            // res = min(res, mn[u][i]);
            // res = min(res, mn[v][i]);
            // u = dp[u][i]; v = dp[v][i];
        // }
    // res = min(res, mn[u][0]);
    // res = min(res, mn[v][0]);
    // return res;
// }
int n;
int a[N];
char c[4 * N];
void input() noexcept(true) {
    cin >> n;
	for(int i = 1; i <= n; i++){
		cin >> a[i];
	}
} 
 
void output() noexcept(true) {
    int j = 1;
	for(int i = 1; i <= 2 * n; i++){
		if(c[i] == 0){
			c[i] = '(';
			c[i + a[j] + 1] = ')';
			j++;
		}
	}
	for(int i = 1; i <= 2 * n; i++){
		cout << c[i];
	}
}
signed main() {
    fastIO();
    if (fopen(TASK".INP", "r")) {
        freopen(TASK".INP", "r", stdin);
        freopen(TASK".OUT", "w", stdout);
    }
 
    input(), output();
    return 0;
}