A binary string is a string that consists of characters 0 and 1.

Let \operatorname{MEX} of a binary string be the smallest digit among 0, 1, or 2 that does not occur in the string. For example, \operatorname{MEX} of 001011 is 2, because 0 and 1 occur in the string at least once, \operatorname{MEX} of 1111 is 0, because 0 and 2 do not occur in the string and 0 < 2.

A binary string s is given. You should cut it into any number of substrings such that each character is in exactly one substring. It is possible to cut the string into a single substring — the whole string.

A string a is a substring of a string b if a can be obtained from b by deletion of several (possibly, zero or all) characters from the beginning and several (possibly, zero or all) characters from the end.

What is the minimal sum of \operatorname{MEX} of all substrings pieces can be?

Input

The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases. Description of the test cases follows.

Each test case contains a single binary string s (1 ≤ |s| ≤ 10^5).

It's guaranteed that the sum of lengths of s over all test cases does not exceed 10^5.

Output

For each test case print a single integer — the minimal sum of \operatorname{MEX} of all substrings that it is possible to get by cutting s optimally.

Example

Input


6
01
1111
01100
101
0000
01010


Output


1
0
2
1
1
2

Note

In the first test case the minimal sum is \operatorname{MEX}(0) + \operatorname{MEX}(1) = 1 + 0 = 1.

In the second test case the minimal sum is \operatorname{MEX}(1111) = 0.

In the third test case the minimal sum is \operatorname{MEX}(01100) = 2.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;
public class Solution{
static FastScanner sc = new FastScanner();
public static void solve() {
    String s=sc.next();
    int i=0,ans=0;
    while (i<s.length()) {
      if (s.charAt(i)=='1') {
        i++;
        continue;
      }else{
        ans++;
        while(i<s.length() && s.charAt(i)=='0')  {
          i++;
        }
      }
    }
    System.out.println(Math.min(ans,2));
  

  }

public static void main(String[] args) {
  int t = sc.nextInt();
  outer: for (int tt = 0; tt < t; tt++) {
    solve();
  }
}

////////////////////////////////////////////////////////////////////////////////////
////////////////////DO NOT READ AFTER THIS LINE //////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////

static boolean isPalindrom(char[] arr, int i, int j) {
  boolean ok = true;
  while (i <= j) {
    if (arr[i] != arr[j]) {
      ok = false;
      break;
    }
    i++;
    j--;
  }
  return ok;
}

static int max(int a, int b) {
  return Math.max(a, b);
}

static int min(int a, int b) {
  return Math.min(a, b);
}

static long max(long a, long b) {
  return Math.max(a, b);
}

static long min(long a, long b) {
  return Math.min(a, b);
}

static int abs(int a) {
  return Math.abs(a);
}

static long abs(long a) {
  return Math.abs(a);
}

static void swap(long arr[], int i, int j) {
  long temp = arr[i];
  arr[i] = arr[j];
  arr[j] = temp;
}

static void swap(int arr[], int i, int j) {
  int temp = arr[i];
  arr[i] = arr[j];
  arr[j] = temp;
}

static int maxArr(int arr[]) {
  int maxi = Integer.MIN_VALUE;
  for (int x : arr)
    maxi = max(maxi, x);
  return maxi;
}

static int minArr(int arr[]) {
  int mini = Integer.MAX_VALUE;
  for (int x : arr)
    mini = min(mini, x);
  return mini;
}

static long maxArr(long arr[]) {
  long maxi = Long.MIN_VALUE;
  for (long x : arr)
    maxi = max(maxi, x);
  return maxi;
}

static long minArr(long arr[]) {
  long mini = Long.MAX_VALUE;
  for (long x : arr)
    mini = min(mini, x);
  return mini;
}

static int gcd(int a, int b) {
  if (b == 0)
    return a;
  return gcd(b, a % b);
}

static long gcd(long a, long b) {
  if (b == 0)
    return a;
  return gcd(b, a % b);
}

static void ruffleSort(int[] a) {
  int n = a.length;
  Random r = new Random();
  for (int i = 0; i < a.length; i++) {
    int oi = r.nextInt(n);
    int temp = a[i];
    a[i] = a[oi];
    a[oi] = temp;
  }
  Arrays.sort(a);
}

public static int binarySearch(int a[], int target) {
  int left = 0;
  int right = a.length - 1;
  int mid = (left + right) / 2;
  int i = 0;
  while (left <= right) {
    if (a[mid] <= target) {
      i = mid + 1;
      left = mid + 1;
    } else {
      right = mid - 1;
    }
    mid = (left + right) / 2;
  }
  return i;
}

static class FastScanner {
  BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  StringTokenizer st = new StringTokenizer("");

  String next() {
    while (!st.hasMoreTokens())
      try {
        st = new StringTokenizer(br.readLine());
      } catch (IOException e) {
        e.printStackTrace();
      }
    return st.nextToken();
  }

  int nextInt() {
    return Integer.parseInt(next());
  }

  int[] readArray(int n) {
    int[] a = new int[n];
    for (int i = 0; i < n; i++)
      a[i] = nextInt();
    return a;
  }

  long[] readLongArray(int n) {
    long[] a = new long[n];
    for (int i = 0; i < n; i++)
      a[i] = nextLong();
    return a;
  }

  int[][] read2dArray(int n, int m) {
    int arr[][] = new int[n][m];
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        arr[i][j] = nextInt();
      }
    }
    return arr;
  }

  ArrayList<Integer> readArrayList(int n) {
    ArrayList<Integer> arr = new ArrayList<Integer>();
    for (int i = 0; i < n; i++) {
      int a = nextInt();
      arr.add(a);
    }
    return arr;
  }

  long nextLong() {
    return Long.parseLong(next());
  }
}

static class pair {
  int fr, sc;

  pair(int fr, int sc) {
    this.fr = fr;
    this.sc = sc;
  }
}

////////////////////////////////////////////////////////////////////////////////////  

}