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.*;

/**
 * _223A
 * θ(|s|) time
 * θ(|s|) space
 *
 * @author artyom
 */
public class _223A implements Runnable {
    private BufferedReader in;
    private StringTokenizer tok;

    private Object solve() throws IOException {
        String s = nextToken();
        int n = s.length();
        int[] z = new int[n];
        Arrays.fill(z, -1);
        Deque<Character> stack = new LinkedList<>();
        Deque<Integer> pos = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            char ch = s.charAt(i);
            if (ch == '(' || ch == '[') {
                stack.push(ch);
                pos.push(i);
            } else if (!stack.isEmpty()) {
                int p = pos.pop();
                char x = stack.pop(), match = ch == ')' ? '(' : '[';
                if (x == match) {
                    z[i] = p > 0 && z[p - 1] >= 0 ? z[p - 1] : p;
                } else {
                    stack.clear();
                    pos.clear();
                }
            }
        }
        int max = 0, maxIndex = -1;
        for (int i = z.length - 1; i >= 0; i--) {
            if (z[i] >= 0) {
                int c = 0;
                for (int j = z[i]; j <= i; j++) {
                    if (s.charAt(j) == '[') {
                        c++;
                    }
                }
                if (c > max) {
                    max = c;
                    maxIndex = i;
                }
                i = z[i];
            }
        }
        return max + "\n" + (maxIndex >= 0 ? s.substring(z[maxIndex], maxIndex + 1) : "");
    }

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

    @Override
    public void run() {
        try {
            in = new BufferedReader(new InputStreamReader(System.in));
            tok = null;
            PrintStream out = System.out;
            out.print(solve());
            in.close();
        } catch (IOException e) {
            System.exit(0);
        }
    }

    private String nextToken() throws IOException {
        while (tok == null || !tok.hasMoreTokens()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

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

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