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
#include <bits/stdc++.h>
using namespace std;
const int INF = 999999999;
const double EPSILON = 0.00000001;
const long long MOD = 1000000007;
int cnt[100005], depth1[100005], depth2[100005];
int main() {
  string seq;
  cin >> seq;
  int n = seq.length();
  memset(cnt, 0, sizeof(cnt));
  memset(depth2, 0, sizeof(depth2));
  for (int i = 0; i < n; i++) {
    cnt[i + 1] = cnt[i];
    depth1[i + 1] = depth1[i];
    depth2[i + 1] = depth2[i];
    if (seq[i] == '[') {
      cnt[i + 1]++;
      depth2[i + 1]++;
    } else if (seq[i] == ']')
      depth2[i + 1]--;
    else if (seq[i] == '(')
      depth1[i + 1]++;
    else if (seq[i] == ')')
      depth1[i + 1]--;
  }
  stack<int> round, square, empty, lefts;
  int left = 0;
  int ans = 0, len = 0, best = 0;
  for (int i = 0; i < n; i++) {
    if (seq[i] == '(')
      round.push(i);
    else if (seq[i] == '[')
      square.push(i);
    else if (seq[i] == ')') {
      if (round.empty()) {
        left = i + 1;
        round = square = lefts = empty;
      } else {
        int l = round.top();
        round.pop();
        if (depth2[i + 1] - depth2[l] != 0) {
          left = i + 1;
          round = square = lefts = empty;
          continue;
        }
        bool ok = true;
        while (not lefts.empty()) {
          int pre = lefts.top();
          lefts.pop();
          if (pre > l and depth2[i + 1] - depth2[pre] != 0) {
            ok = false;
            lefts = empty;
            break;
          } else if (pre < l) {
            if (depth2[i + 1] - depth2[pre] == 0 and
                depth1[i + 1] - depth1[pre] == 0)
              l = pre;
            else {
              lefts.push(pre);
              break;
            }
          }
        }
        if (not ok) continue;
        lefts.push(l);
        if (l >= left and cnt[i + 1] - cnt[l] > best) {
          best = cnt[i + 1] - cnt[l];
          ans = l;
          len = i - l + 1;
        }
      }
    } else if (seq[i] == ']') {
      if (square.empty()) {
        left = i + 1;
        round = square = lefts = empty;
      } else {
        int l = square.top();
        square.pop();
        if (depth1[i + 1] - depth1[l] != 0) {
          left = i + 1;
          round = square = lefts = empty;
          continue;
        }
        bool ok = true;
        while (not lefts.empty()) {
          int pre = lefts.top();
          lefts.pop();
          if (pre > l and depth1[i + 1] - depth1[pre] != 0) {
            ok = false;
            lefts = empty;
            break;
          } else if (pre < l) {
            if (depth1[i + 1] - depth1[pre] == 0 and
                depth2[i + 1] - depth2[pre] == 0)
              l = pre;
            else {
              lefts.push(pre);
              break;
            }
          }
        }
        if (not ok) continue;
        lefts.push(l);
        if (l >= left and cnt[i + 1] - cnt[l] > best) {
          best = cnt[i + 1] - cnt[l];
          ans = l;
          len = i - l + 1;
        }
      }
    }
  }
  cout << best << endl;
  cout << seq.substr(ans, len) << endl;
  return 0;
}
