A two dimensional array is called a bracket array if each grid contains one of the two possible brackets — "(" or ")". A path through the two dimensional array cells is called monotonous if any two consecutive cells in the path are side-adjacent and each cell of the path is located below or to the right from the previous one. 

A two dimensional array whose size equals n × m is called a correct bracket array, if any string formed by writing out the brackets on some monotonous way from cell (1, 1) to cell (n, m) forms a correct bracket sequence. 

Let's define the operation of comparing two correct bracket arrays of equal size (a and b) like that. Let's consider a given two dimensional array of priorities (c) — a two dimensional array of same size, containing different integers from 1 to nm. Let's find such position (i, j) in the two dimensional array, that ai, j ≠ bi, j. If there are several such positions, let's choose the one where number ci, j is minimum. If ai, j = "(", then a < b, otherwise a > b. If the position (i, j) is not found, then the arrays are considered equal.

Your task is to find a k-th two dimensional correct bracket array. It is guaranteed that for the given sizes of n and m there will be no less than k two dimensional correct bracket arrays.

Input

The first line contains integers n, m and k — the sizes of the array and the number of the sought correct bracket array (1 ≤ n, m ≤ 100, 1 ≤ k ≤ 1018). Then an array of priorities is given, n lines each containing m numbers, number pi, j shows the priority of character j in line i (1 ≤ pi, j ≤ nm, all pi, j are different).

Please do not use the %lld specificator to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specificator.

Output

Print the k-th two dimensional correct bracket array.

Examples

Input

1 2 1
1 2


Output

()


Input

2 3 1
1 2 3
4 5 6


Output

(()
())


Input

3 2 2
3 6
1 4
2 5


Output

()
)(
()

Note

In the first sample exists only one correct two-dimensional bracket array.

In the second and in the third samples two arrays exist.

A bracket sequence is called regular if it is possible to obtain correct arithmetic expression by inserting characters «+» and «1» into this sequence. For example, sequences «(())()», «()» and «(()(()))» are regular, while «)(», «(()» and «(()))(» are not.
import java.io.*;
import java.math.*;
import java.util.*;
/*public class TaskC {

}
 */
public class TaskC implements Runnable {
	// based on Petr's template
	long K;
	char[] res;
	long[][] dp;
	private void solve() throws IOException {
		int n = this.nextInt();
		int m = this.nextInt();
		K = this.nextLong();
		
		int[] x = new int[ n * m ];
		int[] y = new int[ n * m ];
		for ( int i = 0; i < n; i ++ )
			for ( int j = 0; j < m; j ++ ){
				int p = this.nextInt();
				x[ p - 1 ] = i;
				y[ p - 1 ] = j;
			}
		res = new char[ n + m - 1 ];
		Arrays.fill( res, ' ' );
		dp = new long[n+m][n+m];
		for ( int loop = 0; loop < n * m; loop ++ ){
			int i = x[loop];
			int j = y[loop];
			if ( res[ i + j ] != ' ' )
				continue;
			res[ i + j ] = '(';
			for ( int k = 0; k < n + m; k ++ )
				Arrays.fill( dp[k], -1 );
			for ( int k = 0; k < n + m; k ++ )
				dp[n+m-1][k] = 0;
			dp[n+m-1][0] = 1;
			if ( work( 0, 0 ) < K ){
				K -= work( 0, 0 );
				res[ i + j ] = ')';
			}
		}
		for ( int i = 0; i < n; i ++ ){
			for ( int j = 0; j < m; j ++ )
				writer.print( res[i+j] );
			writer.println();
		}
	}

	private long work(int n, int L) {
		// TODO Auto-generated method stub
		if ( L < 0 )
			return 0;
		if ( dp[n][L] != -1 )
			return dp[n][L];
		long ret = 0;
		if ( res[n] == '(' || res[n] == ' ' )
			ret += work( n + 1, L + 1 );
		if ( res[n] == ')' || res[n] == ' ' )
			ret += work( n + 1, L - 1 );
		if ( ret >= K )
			ret = K;
		return dp[n][L] = ret;
	}

	public static void main(String[] args) {
		new TaskC().run();
	}

	BufferedReader reader;
	StringTokenizer tokenizer;
	PrintWriter writer;

	public void run() {
		try {
			reader = new BufferedReader(new InputStreamReader(System.in));
			writer = new PrintWriter(new OutputStreamWriter(System.out));
			tokenizer = null;
			solve();
			reader.close();
			writer.close();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(1);
		}
	}

	boolean hasNext() throws IOException {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			String nextLine = reader.readLine();
			if (nextLine == null)
				return false;
			tokenizer = new StringTokenizer(nextLine);
		}

		return true;
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	String nextLine() throws IOException {
		return reader.readLine();
	}

	String nextToken() throws IOException {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}

		return tokenizer.nextToken();
	}

	BigInteger nextBigInteger() throws IOException {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}

		return new BigInteger(tokenizer.nextToken());
	}
}