description: 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.
solution: 
  
  import java.util.*;
  import java.io.*;
  
  public class Main {
    static StringBuilder sb;
    static dsu dsu;
    static long fact[];
    static int mod = (int) (1e9 + 7);
  
    static void solve() {
  String s=s();
  
  int zc=0;
  for(int i=0;i<s.length();i++){
      char ch=s.charAt(i);
      if(ch=='0'){
          zc++;
          
      }
      
  }
  if(zc==0){
      sb.append(0+"\n");
      return;
  }
  if(zc==1){
      sb.append(1+"\n");
      return;
  }
  int last=-1;
  boolean b=false;
  for(int i=0;i<s.length();i++){
      char ch=s.charAt(i);
     if(ch=='0'){
       if(last!=-1&&b==true){
            sb.append(2+"\n");
           return;
           
       } 
       else if(last==-1){
          last=i;
       }
     }
     if(ch=='1'&&last!=-1){
        b=true;
     }
      
  }
  
  sb.append(1+"\n");
  
  
    }
  
    public static void main(String[] args) {
      sb = new StringBuilder();
      int test = i();
      while (test-- > 0) {
        solve();
      }
      System.out.println(sb);
  
    }
  
    /*
     * fact=new long[(int)1e6+10]; fact[0]=fact[1]=1; for(int i=2;i<fact.length;i++)
     * { fact[i]=((long)(i%mod)1L(long)(fact[i-1]%mod))%mod; }
     */
  //**************NCR%P******************
    static long ncr(int n, int r) {
      if (r > n)
        return (long) 0;
  
      long res = fact[n] % mod;
      // System.out.println(res);
      res = ((long) (res % mod) * (long) (p(fact[r], mod - 2) % mod)) % mod;
      res = ((long) (res % mod) * (long) (p(fact[n - r], mod - 2) % mod)) % mod;
      // System.out.println(res);
      return res;
  
    }
  
    static long p(long x, long y)// POWER FXN //
    {
      if (y == 0)
        return 1;
  
      long res = 1;
      while (y > 0) {
        if (y % 2 == 1) {
          res = (res * x) % mod;
          y--;
        }
  
        x = (x * x) % mod;
        y = y / 2;
  
      }
      return res;
    }
  
  //**************END******************
  
    // *************Disjoint set
    // union*********//
    static class dsu {
      int parent[];
  
      dsu(int n) {
        parent = new int[n];
        for (int i = 0; i < n; i++)
          parent[i] = -1;
      }
  
      int find(int a) {
        if (parent[a] < 0)
          return a;
        else {
          int x = find(parent[a]);
          parent[a] = x;
          return x;
        }
      }
  
      void merge(int a, int b) {
        a = find(a);
        b = find(b);
        if (a == b)
          return;
        parent[b] = a;
      }
    }
  
  //**************PRIME FACTORIZE **********************************//
    static TreeMap<Integer, Integer> prime(long n) {
      TreeMap<Integer, Integer> h = new TreeMap<>();
      long num = n;
      for (int i = 2; i <= Math.sqrt(num); i++) {
        if (n % i == 0) {
          int nt = 0;
          while (n % i == 0) {
            n = n / i;
            nt++;
          }
          h.put(i, nt);
        }
      }
      if (n != 1)
        h.put((int) n, 1);
      return h;
  
    }
  
  //****CLASS PAIR ************************************************
    static class Pair implements Comparable<Pair> {
      int x;
      long y;
  
      Pair(int x, long y) {
        this.x = x;
        this.y = y;
      }
  
      public int compareTo(Pair o) {
        return (int) (this.y - o.y);
  
      }
  
    }
  //****CLASS PAIR **************************************************
  
    static class InputReader {
      private InputStream stream;
      private byte[] buf = new byte[1024];
      private int curChar;
      private int numChars;
      private SpaceCharFilter filter;
  
      public InputReader(InputStream stream) {
        this.stream = stream;
      }
  
      public int read() {
        if (numChars == -1)
          throw new InputMismatchException();
        if (curChar >= numChars) {
          curChar = 0;
          try {
            numChars = stream.read(buf);
          } catch (IOException e) {
            throw new InputMismatchException();
          }
          if (numChars <= 0)
            return -1;
        }
        return buf[curChar++];
      }
  
      public int Int() {
        int c = read();
        while (isSpaceChar(c))
          c = read();
        int sgn = 1;
        if (c == '-') {
          sgn = -1;
          c = read();
        }
        int res = 0;
        do {
          if (c < '0' || c > '9')
            throw new InputMismatchException();
          res *= 10;
          res += c - '0';
          c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
      }
  
      public String String() {
        int c = read();
        while (isSpaceChar(c))
          c = read();
        StringBuilder res = new StringBuilder();
        do {
          res.appendCodePoint(c);
          c = read();
        } while (!isSpaceChar(c));
        return res.toString();
      }
  
      public boolean isSpaceChar(int c) {
        if (filter != null)
          return filter.isSpaceChar(c);
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
      }
  
      public String next() {
        return String();
      }
  
      public interface SpaceCharFilter {
        public boolean isSpaceChar(int ch);
      }
    }
  
    static class OutputWriter {
      private final PrintWriter writer;
  
      public OutputWriter(OutputStream outputStream) {
        writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
      }
  
      public OutputWriter(Writer writer) {
        this.writer = new PrintWriter(writer);
      }
  
      public void print(Object... objects) {
        for (int i = 0; i < objects.length; i++) {
          if (i != 0)
            writer.print(' ');
          writer.print(objects[i]);
        }
      }
  
      public void printLine(Object... objects) {
        print(objects);
        writer.println();
      }
  
      public void close() {
        writer.close();
      }
  
      public void flush() {
        writer.flush();
      }
    }
  
    static InputReader in = new InputReader(System.in);
    static OutputWriter out = new OutputWriter(System.out);
  
    public static long[] sort(long[] a2) {
      int n = a2.length;
      ArrayList<Long> l = new ArrayList<>();
      for (long i : a2)
        l.add(i);
      Collections.sort(l);
      for (int i = 0; i < l.size(); i++)
        a2[i] = l.get(i);
      return a2;
    }
  
    public static char[] sort(char[] a2) {
      int n = a2.length;
      ArrayList<Character> l = new ArrayList<>();
      for (char i : a2)
        l.add(i);
      Collections.sort(l);
      for (int i = 0; i < l.size(); i++)
        a2[i] = l.get(i);
      return a2;
    }
  
    public static long pow(long x, long y) {
      long res = 1;
      while (y > 0) {
        if (y % 2 != 0) {
          res = (res * x);// % modulus;
          y--;
  
        }
        x = (x * x);// % modulus;
        y = y / 2;
      }
      return res;
    }
  
  //GCD___+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    public static long gcd(long x, long y) {
      if (x == 0)
        return y;
      else
        return gcd(y % x, x);
    }
    // ******LOWEST COMMON MULTIPLE
    // *********************************************
  
    public static long lcm(long x, long y) {
      return (x * (y / gcd(x, y)));
    }
  
  //INPUT PATTERN********************************************************
    public static int i() {
      return in.Int();
    }
  
    public static long l() {
      String s = in.String();
      return Long.parseLong(s);
    }
  
    public static String s() {
      return in.String();
    }
  
    public static int[] readArrayi(int n) {
      int A[] = new int[n];
      for (int i = 0; i < n; i++) {
        A[i] = i();
      }
      return A;
    }
  
    public static long[] readArray(long n) {
      long A[] = new long[(int) n];
      for (int i = 0; i < n; i++) {
        A[i] = l();
      }
      return A;
    }
  
  }