description: A bow adorned with nameless flowers that bears the earnest hopes of an equally nameless person.
  
  You have obtained the elegant bow known as the Windblume Ode. Inscribed in the weapon is an array of n (n ≥ 3) positive distinct integers (i.e. different, no duplicates are allowed).
  
  Find the largest subset (i.e. having the maximum number of elements) of this array such that its sum is a composite number. A positive integer x is called composite if there exists a positive integer y such that 1 < y < x and x is divisible by y.
  
  If there are multiple subsets with this largest size with the composite sum, you can output any of them. It can be proven that under the constraints of the problem such a non-empty subset always exists.
  
  Input
  
  Each test consists of multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
  
  The first line of each test case contains an integer n (3 ≤ n ≤ 100) — the length of the array.
  
  The second line of each test case contains n distinct integers a_{1},a_{2},...,a_{n} (1 ≤ a_{i} ≤ 200) — the elements of the array.
  
  Output
  
  Each test case should have two lines of output.
  
  The first line should contain a single integer x: the size of the largest subset with composite sum. The next line should contain x space separated integers representing the indices of the subset of the initial array.
  
  Example
  
  Input
  
  
  4
  3
  8 1 2
  4
  6 9 4 2
  9
  1 2 3 4 5 6 7 8 9
  3
  200 199 198
  
  
  Output
  
  
  2
  2 1
  4
  2 1 4 3
  9
  6 9 1 2 3 4 5 7 8
  3
  1 2 3 
  
  Note
  
  In the first test case, the subset \\{a_2, a_1\} has a sum of 9, which is a composite number. The only subset of size 3 has a prime sum equal to 11. Note that you could also have selected the subset \\{a_1, a_3\} with sum 8 + 2 = 10, which is composite as it's divisible by 2.
  
  In the second test case, the sum of all elements equals to 21, which is a composite number. Here we simply take the whole array as our subset.
solution: //package codechef;
  
  import java.io.*;
  import java.util.*;
  
  
  
  
  
  
  
  
  public class cp_2 {
  	static int mod=(int)1e9+7;
  	
  		static  Reader sc=new Reader();
  //	   static FastReader sc=new FastReader(System.in);
  	 static int[] sp;
  	static int size=(int)1e6;
  	public static void main(String[] args) throws IOException {
  		// TODO Auto-generated method stub
  		//FastReader sc=new FastReader();
  			long tc=sc.nextLong();
  //		Scanner sc=new Scanner(System.in);
  //		int tc=1;
  			int cases=0;
  //			primeSet=new HashSet<>();
  //			sieveOfEratosthenes((int)1e5);
  			sp=new int[(int)1e6];
  			pr=new ArrayList<>();
  			make_seive();
  			while(tc-->0)
  			{
  				int n=sc.nextInt();
  				int arr[]=new int[n];
  				for(int i=0;i<n;i++)
  				{
  				arr[i]=sc.nextInt();
  				// System.out.println(i+" "+sp[i]);
  				}
  				int sum=0;
  				for(int i=0;i<n;i++)
  				sum+=arr[i];
  				if(sp[sum]!=sum)
  				{
  				out.println(n);
  				for(int i=1;i<=n;i++)
  				out.print(i+" ");
  				out.println();
  				}
  				else
  				{
  				int pos=-1;
  				for(int i=0;i<n;i++)
  				if(sp[sum-arr[i]]!=sum-arr[i])
  				{
  				pos=i;
  				break;
  				}
  				out.println(n-1);
  				for(int i=1;i<=n;i++)
  				if(i!=pos+1)
  				out.print(i+" ");
  				out.println();
  				}
  
  				
  			}
  				
  				
  			
  			
  			out.flush();
  			out.close();
  			System.gc();
  	
  	}
  	
  	
  	
  
  
  	/*
  	   ...SOLUTION ENDS HERE...........SOLUTION ENDS HERE...
   */
  
  	static ArrayList<Integer> pr;
  	
  	static void make_seive()
  	{
  	sp=new int[size];
  	pr=new ArrayList<Integer>();
  	for (int i=2; i<size; ++i) {
  	   if (sp[i] == 0) {
  	       sp[i] = i;
  	       pr.add(i);
  	   }
  	   for (int j=0; j<(int)pr.size() && pr.get(j)<=sp[i] && i*pr.get(j)<size; ++j)
  	       sp[i * pr.get(j)] = pr.get(j);
  	}
  	}
  	
  	static boolean check(int k,int[] arr)
  	{
  		
  		int[] temp=new int[arr.length];
  		for (int i = 0; i < temp.length; i++) {
  			if(arr[i]>=0)
  			temp[i]=(arr[i])%k;
  			else {
  				int q=arr[i]/k;
  				temp[i]=(arr[i]+k*(q+1))%k;
  			}
  			
  		}
  		Map<Integer, Integer> freq=new HashMap<>();
  		for (int i = 0; i < temp.length; i++) {
  			freq.put(temp[i], freq.getOrDefault(temp[i], 0)+1);
  		}
  		for(Integer each:freq.keySet())
  		{
  			if(freq.get(each)>=arr.length/2)
  				return true;
  		}
  		
  		return false;
  	}
  	
  	
  static class Node
  {
  	int vertex;
  	HashSet<Node> adj;
  	boolean rem;
  	Node(int ver)
  	{
  		vertex=ver;
  		rem=false;
  		adj=new HashSet<Node>();
  	}
  	@Override
  	public String toString()
  	{
  		return vertex+" ";
  	}
  }
  
  
  
  static HashSet<Integer> findFactors(int n)
  {
  	HashSet<Integer> ans=new HashSet<Integer>();
  	if(n%2==0)
  	{
  		ans.add(2);
  		while((n&1)==0)
  			n=n>>1;
  	}
  	for(int i=3;i*i<=n;i+=2)
  	{
  		if(n%i==0)
  		{
  			ans.add(i);
  			while(n%i==0)
  				n=n/i;
  		}
  	}
  	if(n!=1)
  		ans.add(n);
  	return ans;
  }
  
  
  
  
  	
  	static Pair primeFactors(int n)
      {
  		Pair ans=new Pair(0, 0);
          // Print the number of 2s that divide n
          while (n%2==0)
          {
              ans.x++;
              n /= 2;
          }
   
          // n must be odd at this point.  So we can
          // skip one element (Note i = i +2)
          for (int i = 3; i <= Math.sqrt(n); i+= 2)
          {
              // While i divides n, print i and divide n
              while (n%i == 0)
              {
                  ans.y++;
                  n /= i;
              }
          }
   
          // This condition is to handle the case when
          // n is a prime number greater than 2
          if (n > 2 && n%2==0)
          {
          	ans.x++;
          }
          else {
  			ans.y++;
  		}
             
          return ans;
      }
  	
  	
  	static class fwt
  	{
  		int n;
  		long BITree[];
  		fwt(int n)
  		{
  			this.n=n;
  			BITree=new long[n+1];
  		}
  		
  		fwt(int arr[], int n)
  		{
  			this.n=n;
  			BITree=new long[n+1];
  			for(int i = 0; i < n; i++)
  			updateBIT(n, i, arr[i]);
  		 }
  		
  		   long getSum(int index)
  		   {
  		       long sum = 0;
  		       index = index + 1;
  		       while(index>0)
  		       {
  		           sum += BITree[index];
  		           index -= index & (-index);
  		       }
  		       return sum;
  		   }
  		   void updateBIT(int n, int index,int val)
  		   {
  		       index = index + 1;
  		       while(index <= n)
  		       {
  		       BITree[index] += val;
  		       index += index & (-index);
  		       }
  		   }
  		   void print()
  		   {
  			    for(int i=0;i<n;i++)
  			    out.print(getSum(i)+" ");
  			    out.println();
  		   }
  	}
  
  	
  	
  	
  	
  	
  	
  	static int setBitNumber(long n)
      {
          if (n == 0)
              return 0;
   
          int msb = 0;
          n = n / 2;
   
          while (n != 0) {
              n = n / 2;
              msb++;
          }
   
          return msb;
      }
   
  	
  	
  	static int getFirstSetBitPos(long n)
      {
          return (int)((Math.log10(n & -n)) / Math.log10(2)) + 1;
      }
  	
  	
  	static ArrayList<Integer> primes;
  	static HashSet<Integer> primeSet;
  	static boolean prime[];
  	static void sieveOfEratosthenes(int n)
      {
          // Create a boolean array
          // "prime[0..n]" and
          // initialize all entries
          // it as true. A value in
          // prime[i] will finally be
          // false if i is Not a
          // prime, else true.
         prime= new boolean[n + 1];
          for (int i = 2; i <= n; i++)
              prime[i] = true;
          
          for (int p = 2; p * p <= n; p++)
          {
              // If prime[p] is not changed, then it is a
              // prime
              if (prime[p] == true)
              {
                  // Update all multiples of p
                  for (int i = p * p; i <= n; i += p)
                      prime[i] = false;
              }
          }
   
          // Print all prime numbers
          for (int i = 2; i <= n; i++)
          {
              if (prime[i] == true)
                 primeSet.add(i);
          }
      }
  	
  	
  	
  	static long mod(long a, long b) {
  		  long c = a % b;
  		  return (c < 0) ? c + b : c;
  		}
  	
  	static void swap(long arr[],int i,int j)
  	{
  		long temp=arr[i];
  		arr[i]=arr[j];
  		arr[j]=temp;
  	}
  
  	
  	
  	static boolean util(int a,int b,int c)
  	{
  		if(b>a)util(b, a, c);
  		
  		while(c>=a)
  		{
  			c-=a;
  			if(c%b==0)
  				return true;
  		}
  		
  		
  		return (c%b==0);
  	}
  	
  	static boolean check(char arr[][], int i,int j)
  	{
  		int cnt=0;
  		for(int k=i;k<i+2;k++)
  		{
  			for(int l=j;l<j+2;l++)
  			{
  				if(arr[k][l]=='#')
  					cnt++;
  			}
  		}
  		
  		if(cnt!=2)
  			return true;
  		return false;
  		
  		
  	}
  	
  	static void flag(boolean flag)
  	   {
  	       out.println(flag ? "YES" : "NO");
  	       out.flush();
  	   }
  	   
  	static ArrayList<Long> luckNums;
  	static void luckyNum(long x,long p10)
  	{
  		luckNums.add(x);
  		if(x>(long)1e10)
  			return;
  		luckyNum(x+4*p10, p10*10);
  		luckyNum(x+7*p10, p10*10);
  		
  	}
  	
  	 /*                     
  	    Map<Long,Long> map=new HashMap<>();
  	             for(int i=0;i<n;i++)
  	               {
  	                  if(!map.containsKey(a[i]))
  	                   map.put(a[i],1);
  	                 else
  	                   map.replace(a[i],map.get(a[i])+1);
  	               }
  	     
  	    Set<Map.Entry<Long,Long>> hmap=map.entrySet();
  	             for(Map.Entry<Long,Long> data : hmap)
  	               {
  	          
  	               }
  	       
  	   Iterator<Integer> it = set.iterator();
  	          while(it.hasNext()) 
  	           { 
  	            int x=it.next();
  	           }
  	   */
  
  
  	
  	
  	static void print(int a[])
  	  {
  	     int n=a.length;
  	     for(int i=0;i<n;i++)
  	       {
  	          out.print(a[i]+" ");
  	       }
  	     out.println();
  	     out.flush();
  	  }
  	static void print(long a[])
  	  {
  	     int n=a.length;
  	     for(int i=0;i<n;i++)
  	       {
  	          out.print(a[i]+" ");
  	       }
  	     out.println();
  	     out.flush();
  	  } 
  	static void print_int(ArrayList<Integer> al)
  	  {
  	     int si=al.size();
  	     for(int i=0;i<si;i++)
  	       {
  	          out.print(al.get(i)+" ");
  	       }
  	     out.println();
  	     out.flush();
  	  }
  	static void print_long(ArrayList<Long> al)
  	  {
  	     int si=al.size();
  	     for(int i=0;i<si;i++)
  	       {
  	          out.print(al.get(i)+" ");
  	       }
  	     out.println();
  	     out.flush();
  	  }
  	  
  	static void printYesNo(boolean condition)
  	{
  		if (condition) {
  			out.println("YES");
  		}
  		else {
  			out.println("NO");
  		}
  	}
  	
  	
  	static int LowerBound(int a[], int x) 
  	 { // x is the target value or key
  	  int l=-1,r=a.length;
  	  while(l+1<r) {
  	    int m=(l+r)>>>1;
  	    if(a[m]>=x) r=m;
  	    else l=m;
  	  }
  	  return r;
  	}
  	
  	
  	static int lowerIndex(int arr[], int n, int x)
      {
          int l = 0, h = n - 1;
          while (l <= h)
          {
              int mid = (l + h) / 2;
              if (arr[mid] >= x)
                  h = mid - 1;
              else
                  l = mid + 1;
          }
          return l;
      }
  	
  	
  	    // function to find last index <= y
      static int upperIndex(int arr[], int n, int y)
      {
          int l = 0, h = n - 1;
          while (l <= h)
          {
              int mid = (l + h) / 2;
              if (arr[mid] <= y)
                  l = mid + 1;
              else
                  h = mid - 1;
          }
          return h;
      }
      static int upperIndex(long arr[], int n, long y)
      {
      	int l = 0, h = n - 1;
      	while (l <= h)
      	{
      		int mid = (l + h) / 2;
      		if (arr[mid] <= y)
      			l = mid + 1;
      		else
      			h = mid - 1;
      	}
      	return h;
      }
       
  	
  	 static int UpperBound(int a[], int x)
  	  {// x is the key or target value
  	    int l=-1,r=a.length;
  	    while(l+1<r) {
  	       int m=(l+r)>>>1;
  	       if(a[m]<=x) l=m;
  	       else r=m;
  	    }
  	    return l+1;
  	 }
  	 static int UpperBound(long a[], long x)
  	 {// x is the key or target value
  		 int l=-1,r=a.length;
  		 while(l+1<r) {
  			 int m=(l+r)>>>1;
  	       if(a[m]<=x) l=m;
  	       else r=m;
  		 }
  		 return l+1;
  	 }
  	 
  	 
  	 
  	 static class DisjointUnionSets
  	 {
  	    int[] rank, parent;
  	    int n;
  	    // Constructor
  	    public DisjointUnionSets(int n)
  	    {
  	        rank = new int[n];
  	        parent = new int[n];
  	        this.n = n;
  	        makeSet();
  	    }
  	    // Creates n sets with single item in each
  	    void makeSet()
  	    {
  	        for (int i = 0; i < n; i++)
  	            parent[i] = i;
  	    }
  	    int find(int x)
  	    {
  	        if (parent[x] != x) {
  	            parent[x] = find(parent[x]);
  	        }
  	        return parent[x];
  	    }
  	    // Unites the set that includes x and the set
  	    // that includes x
  	    void union(int x, int y)
  	    {
  	        int xRoot = find(x), yRoot = find(y);
  	        if (xRoot == yRoot)
  	            return;
  	        if (rank[xRoot] < rank[yRoot])
  	            parent[xRoot] = yRoot;
  	        else if (rank[yRoot] < rank[xRoot])
  	         parent[yRoot] = xRoot;
  	        else // if ranks are the same
  	        {
  	         parent[yRoot] = xRoot;
  	            rank[xRoot] = rank[xRoot] + 1;
  	        }
  	        
  //	        if(xRoot!=yRoot)
  //	        	parent[y]=x;
  	    }
  	    
  	    int connectedComponents()
  	    {
  	    	int cnt=0;
  	    	for(int i=0;i<n;i++)
  	    	{
  	    		if(parent[i]==i)
  	    			cnt++;
  	    	}
  	    	return cnt;
  	    }
  	 }
  
  	 
  //	static class countClass{
  //		int cnt;
  //		public countClass() {
  //			this.cnt=0;
  //			// TODO Auto-generated constructor stub
  //		}
  //	}
  
  	 
  	 
  	static class Graph
  	  {
  	        int v;
  	        ArrayList<Integer> list[];
  	        Graph(int v)
  	        {
  	            this.v=v;
  	            list=new ArrayList[v+1];
  	            for(int i=1;i<=v;i++)
  	                list[i]=new ArrayList<Integer>();
  	        }
  	        void addEdge(int a, int b)
  	        {
  	            this.list[a].add(b);
  	        }
  	    }
  	
  //	static class GraphMap{
  //		Map<String,ArrayList<String>> graph;
  //		GraphMap() {
  //			// TODO Auto-generated constructor stub
  //			graph=new HashMap<String,ArrayList<String>>();
  //			
  //		}
  //		void addEdge(String a,String b)
  //		{
  //			if(graph.containsKey(a))
  //			this.graph.get(a).add(b);
  //			else {
  //				this.graph.put(a, new ArrayList<>());
  //				this.graph.get(a).add(b);
  //			}
  //		}
  //	}
  //	static void dfsMap(GraphMap g,HashSet<String> vis,String src,int ok)
  //	{
  //		vis.add(src);
  //		
  //		if(g.graph.get(src)!=null)
  //		{
  //			for(String each:g.graph.get(src))
  //			{
  //				if(!vis.contains(each))
  //				{
  //					dfsMap(g, vis, each, ok+1);
  //				}
  //			}
  //		}
  //		
  //		cnt=Math.max(cnt, ok);
  //	}
  	static double sum[];
  	static long cnt;
  	static void DFS(Graph g, boolean[] visited, int u)
  		{
  	        visited[u]=true;
  	        
  	        for(int i=0;i<g.list[u].size();i++)
  	        {
  	            int v=g.list[u].get(i);
  	            
  	            if(!visited[v])
  	            {
  	            	cnt=cnt*2;
  	            	DFS(g, visited, v);
  	            
  	            }
  	            
  	        }
  	       
  
  	  } 
  	
  	
  	  
  	 static class Pair implements Comparable<Pair>
  	    {
  	       int x,y;
  	       Pair(int x,int y)
  	        {
  	           this.x=x;
  	           this.y=y;
  	        }
  		@Override
  		public int compareTo(Pair o) {
  			// TODO Auto-generated method stub
  			return this.x-o.x;
  		}
  	       
  	       
  	       
  	    }
  	   
  	static long sum_array(int a[])
  	 {
  	    int n=a.length;
  	    long sum=0;
  	    for(int i=0;i<n;i++)
  	     sum+=a[i];
  	    return sum;
  	 }
  	static long sum_array(long a[])
  	 {
  	    int n=a.length;
  	    long sum=0;
  	    for(int i=0;i<n;i++)
  	     sum+=a[i];
  	    return sum;
  	 }
  
  	 static void sort(int[] a) 
  	   {
  			ArrayList<Integer> l=new ArrayList<>();
  			for (int i:a) l.add(i);
  			Collections.sort(l);
  			for (int i=0; i<a.length; i++) a[i]=l.get(i);
  		}
  	static void sort(long[] a) 
  	   {
  			ArrayList<Long> l=new ArrayList<>();
  			for (long i:a) l.add(i);
  			Collections.sort(l);
  			for (int i=0; i<a.length; i++) a[i]=l.get(i);
  		}
  
  	static void reverse_array(int a[])
  	 {
  	    int n=a.length;
  	    int i,t; 
  	    for (i = 0; i < n / 2; i++) { 
  	            t = a[i]; 
  	            a[i] = a[n - i - 1]; 
  	            a[n - i - 1] = t; 
  	        } 
  	 }
  	static void reverse_array(long a[])
  	 {
  	    int n=a.length;
  	    int i; long t; 
  	    for (i = 0; i < n / 2; i++) { 
  	            t = a[i]; 
  	            a[i] = a[n - i - 1]; 
  	            a[n - i - 1] = t; 
  	        } 
  	 }
  //	 static long modInverse(long a, long m)
  //		    {
  //		        long g = gcd(a, m);
  //		       
  //		          return   power(a, m - 2, m);
  //		        
  //		    }
  	static long power(long x, long y)
  	 {
  	   long res = 1;
  	   x = x % mod;
  	   if (x == 0)
  	     return 0;
  	   while (y > 0)
  	   {
  	    if ((y & 1) != 0)
  	    res = (res * x) % mod;
  	   
  	    y = y >> 1; // y = y/2
  	    x = (x * x) % mod;
  	   }
  	   return res;
  	 }
  	static long gcd(long a, long b) 
  	    { 
  			
  	        if (a == 0) 
  	            return b; 
  	         //cnt+=a/b;
  	        return gcd(b%a,a); 
  	    } 
  	static int gcd(int a, int b) 
  	    { 
  	        if (a == 0) 
  	            return b; 
  	          
  	        return gcd(b%a, a); 
  	    } 
  
  	   static class FastReader{
  	 
  	        byte[] buf = new byte[2048];
  	        int index, total;
  	        InputStream in;
  	 
  	        FastReader(InputStream is) {
  	            in = is;
  	        }
  	 
  	        int scan() throws IOException {
  	            if (index >= total) {
  	                index = 0;
  	                total = in.read(buf);
  	                if (total <= 0) {
  	                    return -1;
  	                }
  	            }
  	            return buf[index++];
  	        }
  	 
  	        String next() throws IOException {
  	            int c;
  	            for (c = scan(); c <= 32; c = scan());
  	            StringBuilder sb = new StringBuilder();
  	            for (; c > 32; c = scan()) {
  	                sb.append((char) c);
  	            }
  	            return sb.toString();
  	        }
  	 
  	        int nextInt() throws IOException {
  	            int c, val = 0;
  	            for (c = scan(); c <= 32; c = scan());
  	            boolean neg = c == '-';
  	            if (c == '-' || c == '+') {
  	                c = scan();
  	            }
  	            for (; c >= '0' && c <= '9'; c = scan()) {
  	                val = (val << 3) + (val << 1) + (c & 15);
  	            }
  	            return neg ? -val : val;
  	        }
  	 
  	        long nextLong() throws IOException {
  	            int c;
  	            long val = 0;
  	            for (c = scan(); c <= 32; c = scan());
  	            boolean neg = c == '-';
  	            if (c == '-' || c == '+') {
  	                c = scan();
  	            }
  	            for (; c >= '0' && c <= '9'; c = scan()) {
  	                val = (val << 3) + (val << 1) + (c & 15);
  	            }
  	            return neg ? -val : val;
  	        }
  	    }
  	   
  	    static class Reader 
  	    { 
  	        final private int BUFFER_SIZE = 1 << 16; 
  	        private DataInputStream din; 
  	        private byte[] buffer; 
  	        private int bufferPointer, bytesRead; 
  	  
  	        public Reader() 
  	        { 
  	            din = new DataInputStream(System.in); 
  	            buffer = new byte[BUFFER_SIZE]; 
  	            bufferPointer = bytesRead = 0; 
  	        } 
  	  
  	        public Reader(String file_name) throws IOException 
  	        { 
  	            din = new DataInputStream(new FileInputStream(file_name)); 
  	            buffer = new byte[BUFFER_SIZE]; 
  	            bufferPointer = bytesRead = 0; 
  	        } 
  	  
  	        public String readLine() throws IOException 
  	        { 
  	            byte[] buf = new byte[64]; // line length 
  	            int cnt = 0, c; 
  	            while ((c = read()) != -1) 
  	            { 
  	                if (c == '\n') 
  	                    break; 
  	                buf[cnt++] = (byte) c; 
  	            } 
  	            return new String(buf, 0, cnt); 
  	        } 
  	  
  	        public int nextInt() throws IOException 
  	        { 
  	            int ret = 0; 
  	            byte c = read(); 
  	            while (c <= ' ') 
  	                c = read(); 
  	            boolean neg = (c == '-'); 
  	            if (neg) 
  	                c = read(); 
  	            do
  	            { 
  	                ret = ret * 10 + c - '0'; 
  	            }  while ((c = read()) >= '0' && c <= '9'); 
  	  
  	            if (neg) 
  	                return -ret; 
  	            return ret; 
  	        } 
  	  
  	        public long nextLong() throws IOException 
  	        { 
  	            long ret = 0; 
  	            byte c = read(); 
  	            while (c <= ' ') 
  	                c = read(); 
  	            boolean neg = (c == '-'); 
  	            if (neg) 
  	                c = read(); 
  	            do { 
  	                ret = ret * 10 + c - '0'; 
  	            } 
  	            while ((c = read()) >= '0' && c <= '9'); 
  	            if (neg) 
  	                return -ret; 
  	            return ret; 
  	        } 
  	  
  	        public double nextDouble() throws IOException 
  	        { 
  	            double ret = 0, div = 1; 
  	            byte c = read(); 
  	            while (c <= ' ') 
  	                c = read(); 
  	            boolean neg = (c == '-'); 
  	            if (neg) 
  	                c = read(); 
  	  
  	            do { 
  	                ret = ret * 10 + c - '0'; 
  	            } 
  	            while ((c = read()) >= '0' && c <= '9'); 
  	  
  	            if (c == '.') 
  	            { 
  	                while ((c = read()) >= '0' && c <= '9') 
  	                { 
  	                    ret += (c - '0') / (div *= 10); 
  	                } 
  	            } 
  	  
  	            if (neg) 
  	                return -ret; 
  	            return ret; 
  	        } 
  	  
  	        private void fillBuffer() throws IOException 
  	        { 
  	            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE); 
  	            if (bytesRead == -1) 
  	                buffer[0] = -1; 
  	        } 
  	  
  	        private byte read() throws IOException 
  	        { 
  	            if (bufferPointer == bytesRead) 
  	                fillBuffer(); 
  	            return buffer[bufferPointer++]; 
  	        } 
  	  
  	        public void close() throws IOException 
  	        { 
  	            if (din == null) 
  	                return; 
  	            din.close(); 
  	        } 
  	    }
  	  static  PrintWriter out=new PrintWriter(System.out);
  	  static int int_max=Integer.MAX_VALUE;
  	  static int int_min=Integer.MIN_VALUE;
  	  static long long_max=Long.MAX_VALUE;
  	  static long long_min=Long.MIN_VALUE;
  
  }
  
  
  
  
  