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.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.StringTokenizer;
public class cf224c {
  public static void main(String[] args) {
    FastScanner in = new FastScanner(System.in);
    PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    String x = in.next().trim();
    char[] v = x.toCharArray();
    int n = v.length;
    int[] pair = new int[n];
    Arrays.fill(pair,-1);
    ArrayDeque<Integer> stk = new ArrayDeque<Integer>();
    for(int i=0; i<n; i++) {
      if(v[i] == '(' || v[i] == '[') stk.push(i);
      else if(stk.size() > 0){
        if(v[i] == ']' && v[stk.peek()] == '[' ||
            v[i] == ')' && v[stk.peek()] == '(') {
          int other = stk.pop();
          pair[other] = i;
          pair[i] = other;
        }
        else {
          stk.clear();
        }
      }
    }
    int[] sum = new int[n+1];
    for(int i=0; i<n; i++)
      sum[i+1] = sum[i] + (v[i]=='['?1:0);
    int bestS = 0, bestE = 0;
    int cur = 0, last = 0;
    while(cur < n) {
      if(pair[cur] != -1)
        cur = pair[cur]+1;
      else {
        last = ++cur;
      }
      if(sum[cur] - sum[last] > sum[bestE] - sum[bestS]) {
        bestE = cur;
        bestS = last;
      }
    }
    int ans = sum[bestE] - sum[bestS];
    out.println(ans);
    out.println(x.substring(bestS, bestE));
    out.close();
  }
  static class FastScanner {
    BufferedReader br;
    StringTokenizer st;
    
    public FastScanner(InputStream in) {
      br = new BufferedReader(new InputStreamReader(in));
      scanLine();
    }
    public void scanLine() {
      try {
        st = new StringTokenizer(br.readLine().trim());
      } catch(Exception e) {
        throw new RuntimeException(e.getMessage());
      }
    }
    public int numTokens() {
      if(!st.hasMoreTokens()) {
        scanLine();
        return numTokens();
      }
      return st.countTokens();
    }
    public String next() {
      if(!st.hasMoreTokens()) {
        scanLine();
        return next();
      }
      return st.nextToken();
    }
    public double nextDouble() {
      return Double.parseDouble(next());
    }
    public long nextLong() {
      return Long.parseLong(next());
    }
    public int nextInt() {
      return Integer.parseInt(next());
    }
  }
}
