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 java.math.*;
import static java.lang.Math.*;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Double.parseDouble;
import static java.lang.String.*;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder out = new StringBuilder();
        StringTokenizer tk;
    
        String str = in.readLine();
        int [] f = new int[str.length()];
        f[0] = (str.charAt(0)=='[' ? 1 : 0);
        for(int i=1; i<str.length(); i++) 
            f[i] = f[i-1] + (str.charAt(i)=='[' ? 1 : 0);
        
        int [] other = new int[str.length()];
        Stack<brace> stk = new Stack<brace>();
        
        for(int i=0; i<str.length(); i++) {
            char c = str.charAt(i);
            
            if(c=='[' || c=='(') stk.push(new brace(i,c));
            else if((c==']' && !stk.isEmpty() && stk.peek().type=='[') || (c==')' && !stk.isEmpty() && stk.peek().type=='(')) {
                other[i] = stk.peek().ind;
                other[stk.peek().ind] = i;
                stk.pop();
            } else {
                other[i] = -1;
                while(!stk.isEmpty()) {
                    other[stk.peek().ind] = -1;
                    stk.pop();
                }
            }
        }
        
        while(!stk.isEmpty()) {
            other[stk.peek().ind] = -1;
            stk.pop();
        }
        
        int ans = 0;
        String at = "";
        
        int cur_len=0,i=0;
        String cur_str = "";
        
        while(i < str.length()) {
            if(other[i]==-1) {
                cur_len=0;
                cur_str="";
                i++;
            } else {
                cur_len += f[other[i]]-(i==0 ? 0 : f[i-1]);
                cur_str += str.substring(i,other[i]+1);
                
                if(cur_len > ans) {
                    ans = cur_len;
                    at = cur_str;
                }
                i = other[i]+1;
            }
        }
        
        System.out.println(ans);
        System.out.println(at);
    }
}

class brace {
    int ind;
    char type;
    
    public brace(int i,char t) {
        this.ind = i;
        this.type = t;
    }
}
