A bracket sequence is a string, containing only characters "(", ")", "[" and "]".

A correct bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()[]", "([])" are correct (the resulting expressions are: "(1)+[1]", "([1+1]+1)"), and "](" and "[" are not. The empty string is a correct bracket sequence by definition.

A substring s[l... r] (1 ≤ l ≤ r ≤ |s|) of string s = s1s2... s|s| (where |s| is the length of string s) is the string slsl + 1... sr. The empty string is a substring of any string by definition.

You are given a bracket sequence, not necessarily correct. Find its substring which is a correct bracket sequence and contains as many opening square brackets «[» as possible.

Input

The first and the only line contains the bracket sequence as a string, consisting only of characters "(", ")", "[" and "]". It is guaranteed that the string is non-empty and its length doesn't exceed 105 characters.

Output

In the first line print a single integer — the number of brackets «[» in the required bracket sequence. In the second line print the optimal sequence. If there are more than one optimal solutions print any of them.

Examples

Input

([])


Output

1
([])


Input

(((


Output

0
import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class temp {
	int[] prev;

	void ret(char[] a, int[] b, int pos) {
		if (b[pos] == 0) {
			return;
		}
		ret(a, b, prev[pos - 1] - 1);
		for (int i = prev[pos - 1]; i <= pos; i++) {
			out.print(a[i - 1]);
		}
	}

	void count() throws IOException {
		char[] a = nextToken().toCharArray();
		int n = a.length;
		prev = new int[n];
		int[] add = new int[n];
		Stack<Integer> st = new Stack<Integer>();
		for (int i = 0; i < n; i++) {
			if (a[i] == '[' || a[i] == '(') {
				st.add(i);
			} else {
				if (st.size() == 0) {
					continue;
				}
				int k = st.pop();
				if (a[i] == ']' && a[k] == '[') {
					prev[i] = k + 1;
					add[k] = 1;
				} else if (a[i] == ')' && a[k] == '(') {
					prev[i] = k + 1;
				} else {
					st = new Stack<Integer>();
				}
			}
		}
		int[] part = new int[n + 1];
		for (int i = 1; i <= n; i++) {
			part[i] = part[i - 1] + add[i - 1];
		}
		int[] res = new int[n + 1];
		for (int i = 0; i < n; i++) {
			if (prev[i] != 0) {
				res[i + 1] = part[i + 1] - part[prev[i] - 1] + res[prev[i] - 1];
			}
		}
		int opt = 0;
		for (int i = 1; i <= n; i++) {
			if (res[i] > res[opt]) {
				opt = i;
			}
		}
		out.println(res[opt]);
		ret(a, res, opt);
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer str;
	String readline;

	String nextToken() throws IOException {
		while (str == null || !str.hasMoreTokens()) {
			readline = in.readLine();
			if (readline == null) {
				return null;
			} else {
				str = new StringTokenizer(readline);
			}
		}
		return str.nextToken();
	}

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

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

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

	void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		count();
		out.close();
	}

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