2
2 6 8 1 3 1
2 1 3 8 6 7
 2
1 8 9 1 1 0
2 3 4 5 6 7
 2
0 2 9 8 1 7
6 7 4 3 2 5
 3
9 4 6 2 7 0
3 7 1 9 6 4
6 1 0 8 7 2
 3
2 7 4 0 7 1
5 5 4 9 1 4
2 1 7 5 1 7
 3
5 1 2 9 6 4
9 0 6 4 2 8
4 6 2 8 3 7
 3
1 1 1 0 2 3
4 5 6 7 8 9
0 0 0 0 0 0
 1
1 9 8 3 7 8
 3
2 6 3 7 1 0
9 1 2 4 7 6
1 4 8 7 6 2
 1
4 6 9 8 2 7
 2
1 7 6 9 2 5
1 6 7 0 9 2
 3
4 1 0 8 0 2
1 5 3 5 0 7
7 7 2 7 2 2
 1
7 6 5 8 9 0
 3
3 8 3 5 5 5
3 0 1 6 6 3
0 4 3 7 2 4
 1
8 1 9 2 9 7
 2
2 0 5 7 0 8
4 5 1 5 4 9
 3
1 1 1 1 1 1
0 2 3 4 5 6
7 8 9 2 3 4
 3
0 1 1 2 2 3
4 5 6 7 8 9
3 4 5 6 7 1
 1
0 8 7 1 3 2
 2
9 3 3 6 7 2
6 2 9 1 5 9
 1
8 2 7 4 1 0
 2
3 6 8 9 5 0
6 7 0 8 2 3
 1
0 1 2 3 4 5
 3
3 4 5 6 8 9
1 1 1 1 1 1
1 2 4 5 7 0
 2
2 3 5 1 9 6
1 6 8 7 3 9
 2
0 9 5 7 6 2
8 6 2 7 1 4
 2
4 3 8 6 0 1
4 7 1 8 9 0
 1
6 2 8 4 5 1
 1
4 0 9 6 3 1
 2
6 0 1 7 2 9
1 3 4 6 7 0
 3
5 0 7 6 2 1
2 7 4 6 1 9
0 2 6 1 7 5
 3
0 1 1 2 2 3
4 5 6 7 8 9
3 4 5 6 7 8
 3
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
 2
2 4 0 3 7 6
3 2 8 7 1 5
 1
7 3 6 9 8 1
 3
1 1 2 3 4 5
6 7 8 9 0 2
3 4 5 6 7 8
 3
9 4 3 0 2 6
7 0 5 3 3 9
1 0 7 4 6 7
 1
3 7 7 6 4 2
 3
2 5 7 4 2 7
1 5 5 9 0 3
8 2 0 1 5 1
 2
1 7 8 6 0 9
3 2 1 7 4 9
 2
0 8 6 2 1 3
5 2 7 1 0 9
 2
5 3 2 9 8 2
0 7 4 8 1 8
 3
3 8 5 1 5 5
1 5 7 2 6 9
4 3 4 8 8 9
 2
5 1 2 3 0 8
3 6 7 4 9 2
 2
0 1 2 3 4 5
6 7 8 9 1 2
 1
5 3 8 0 2 6
 1
0 7 6 3 2 4
 2
8 0 6 5 1 4
7 1 0 8 3 4
 2
7 8 6 1 4 5
8 6 4 3 2 5
 2
0 1 2 3 4 5
6 6 6 7 8 9
 3
9 3 1 8 4 6
6 9 1 2 0 7
8 9 1 5 0 3
 3
0 6 2 9 5 4
3 8 0 1 6 9
6 9 0 1 5 2
 3
0 1 2 2 4 5
6 7 8 9 0 1
3 3 4 5 6 7
 1
1 4 5 7 0 5
 2
8 6 4 1 2 0
7 8 5 3 2 1
 3
5 6 2 9 3 5
5 4 1 5 9 8
4 4 2 0 3 5
 1
9 8 1 6 5 7
 3
7 2 1 3 6 9
0 3 8 4 7 6
1 4 5 8 7 0
 3
9 4 3 3 9 3
1 0 3 4 5 3
2 9 6 2 4 1
 3
1 2 3 7 8 9
9 8 7 1 2 3
7 9 2 3 1 8
 3
8 1 8 2 7 1
9 1 9 9 4 7
0 0 9 0 4 0
 1
2 5 9 6 7 9
 3
4 6 0 3 9 2
8 6 9 0 7 2
6 9 3 2 5 7
 3
8 6 0 5 4 9
1 8 5 3 9 7
7 4 5 1 6 8
 1
8 6 0 9 4 2
 1
7 9 2 5 0 4
 1
6 0 7 5 4 8
 2
5 8 4 7 1 2
0 8 6 2 4 9
 1
5 2 2 5 6 7
 2
6 5 2 7 1 3
3 7 8 1 0 9
 1
8 3 5 4 2 9
 3
0 1 2 3 4 5
6 7 8 9 1 2
3 4 5 6 7 8
 2
6 6 4 7 9 0
2 1 2 8 6 4
 3
2 3 4 5 6 7
3 4 5 6 7 8
9 1 2 3 4 5
 2
0 1 2 3 4 5
4 5 6 7 8 9
 3
2 7 3 6 4 5
0 2 1 9 4 8
8 6 9 5 4 0
 2
0 1 2 3 4 5
6 7 8 9 6 6
 2
1 7 2 0 4 3
5 2 3 6 1 0
 1
6 2 8 5 1 3
 3
5 4 8 1 6 7
0 9 3 5 8 6
2 4 7 8 1 3
 1
6 3 1 9 4 9
 3
0 1 9 1 0 8
9 9 3 5 6 2
9 3 9 9 7 3
 3
8 1 6 8 6 8
7 0 2 5 8 4
5 2 0 3 1 9
 3
2 0 1 3 4 5
6 7 8 9 1 1
3 4 5 6 6 7
 3
4 4 5 0 6 6
7 1 6 9 5 4
5 0 4 0 3 9
 2
0 1 2 3 4 5
9 8 7 6 5 4
 2
0 2 9 1 8 5
0 7 4 3 2 5
 2
2 3 9 1 6 7
2 5 4 3 0 6
 2
5 7 4 2 1 9
2 2 7 1 1 8
 1
3 9 1 7 4 5
 3
7 7 2 5 3 2
3 0 0 6 4 4
1 2 1 1 9 1
 1
7 9 5 0 4 6
 3
7 1 3 0 2 4
2 4 3 0 9 5
1 9 8 0 6 5
 1
4 3 8 9 2 3

3
 9
 9
 4
 2
 10
 10
 1
 4
 0
 2
 5
 0
 8
 2
 2
 10
 19
 3
 3
 2
 0
 5
 19
 3
 2
 1
 2
 1
 4
 2
 9
 5
 8
 1
 10
 7
 0
 5
 4
 3
 5
 9
 9
 29
 0
 0
 1
 8
 9
 21
 6
 21
 1
 8
 6
 1
 21
 6
 3
 2
 0
 0
 1
 0
 0
 0
 2
 0
 3
 0
 98
 2
 9
 9
 10
 9
 7
 3
 21
 1
 3
 32
 19
 1
 9
 5
 7
 2
 1
 7
 0
 65
 0


    		import java.awt.List;
    		import java.io.*;
    		import java.util.*;
     
    		
    		
    		
    		
    		/*
    		 * 
    		 * daiict
    		 *
    		 * 
    		 * 
    		 */
    		
    		
    		public class prac {
    			FastScanner in;
    			PrintWriter out;
    		
    			static ArrayList[] adj;
    			
    			static int n;
    			static int m;
    			
    			static int[] dp1;
    			static int[] dp2;
    			static int color[];
    			static int visited[];
    			static long[] arr;
    			static long[] brr;
    			static int[][] ans;
    			static int array[];
    			static int pref[];
    			static int tree[];
    			static int maxval = 32;
    		
    			static int sum = 0;
    		//for dfs do not delete
    			static int dir[][] ={{1,0},{0,1},{0,-1},{-1,0},{1,1},{1,-1},{-1,1},{-1,-1}};
    			
    		
    			static long[] seg;
    			static long count = 1;
    			static long mod = (long)1e9 + 7;
    	
    			static class Pair implements Comparable<Pair>
    		    {
    				long x;long y;
    				
    		        Pair(long l, long m) {
    		          
    		        	this.x = l;
    		            this.y = m;
    		          
    		        }
    		        
    		        public int compareTo(Pair p) {
    		            if (this.x == p.x) {
    		                return (int)(this.y-p.y);
    		            }
    		            return (int)(this.x - p.x);
    		        }
    		        
    		        public String toString(){
    		        	return x + " " + y;
    		        }
    		        
    		        public boolean equals(Object o){
    		        	if(o instanceof Pair){
    		        		Pair a = (Pair)o;
    		        		
    		        		return this.x == a.x;
    		        	}
    		        	
    		        	return false;
    		        }
    		        
    		        public int hashCode(){
    		        	return new Long(x).hashCode()*31 + new Long(y).hashCode();
    		        }
    		    
    		    }
    		    
    			
    			public static int gcd(int a, int b) {
    				if (b == 0) return a;
    				return gcd(b, a%b);
    			}
    	
    			void build(int n) {  // build the tree
    				  for (int i = n - 1; i > 0; --i) seg[i] = Math.max(seg[i<<1],seg[i<<1|1]);
    				}
     
    			public static void modify(int p, int i,long val,int n) {  // set value at position p
    					if(i == 1){
    						long temp = val;
    						val = seg[p+n] - arr[p] + val;
    						arr[p] = temp;
    					}else{
    						val = Math.min(val, p) + arr[p];
    						brr[p] = val;
    					}
    					
    				  for (seg[p += n] = val; p > 1; p >>= 1) seg[p>>1] = Math.max(seg[p],seg[p^1]);
    				}
     
    				long query(int l, int r,int n) {  // max on interval [l, r)
    				  long res = Integer.MIN_VALUE;
    				  for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
    				    if ((l&1) == 1) res = (int)Math.max(res,seg[l++]);
    				    if ((r&1) == 1) res = (int)Math.max(res,seg[--r]);
    				  }
    				  return res;
    				}
    				
    			public static void update(int x,int val){
    				while(x<=maxval){
    					tree[x] += val;
    					x = (x&-x);
    				}
    			}
    			
    			public static int read(int idx){
    				int sum = 0;
    				
    				while(idx>= 0){
    					sum += tree[idx];
    					idx -= (idx&(-idx));
    				}
    				
    				return sum;
    			}
     
    		    void solve() throws NumberFormatException, IOException {
    		 
    		    	//Scanner in = new Scanner(System.in);
    		    	StringBuilder sb = new StringBuilder();
    		  
    		    	int n = in.nextInt();
    		    	
    		    	HashMap<Integer,Integer> map = new HashMap();
    		    	
    		    	for(int i = 0;i<n;i++){
    		    		for(int j = 0;j<6;j++){
    		    			int a = in.nextInt();
    		    			
    		    			if(map.containsKey(a)){
    		    				map.put(a,map.get(a)+1);
    		    			}else{
    		    				map.put(a, 1);
    		    			}
    		    		}
    		    	}
    		    	
    		    	int f = -1;
    		    	for(int i = 0;i<=999;i++){
    		    		
    		    		String s = String.valueOf(i);
    		    		int arr[] = new int[10];
    		    		for(int j = 0;j<s.length();j++){
    		    			arr[s.charAt(j)-'0']++;
    		    		}
    		    	
    		    		for(int j = 0;j<10;j++){
    		    			if(map.containsKey(j) && arr[j] > map.get(j)){
    		    				f = 1;
    		    				break;
    		    			}
    		    		
    		    		}
    		    		
    		    		if(f == 1){
    		    			f = i;
    		    			break;
    		    		}
    		    	}
    		    	
    		    	if(f < 0){
    		    		f = 0;
    		    		out.println(0);
    		    	}else{
    		    		out.println(f-1);
    		    	}
    		    	
    		    }
    		    /**
    		     * 
    		     * @param a
    		     * @param left
    		     * @param right
    		     * @param value
    		     * @return the smallest index i which a[i] >= value in range [left, right) if exists, otherwise return -1
    		     */
    		    int ff(long[] a, int left, int right, int value) {
    		        int low = left;
    		        int high = right;
    		        while (low != high) {
    		            int mid = (low + high) / 2;
    		            if (a[mid] < value) {
    		                low = mid + 1;
    		            } else {
    		                high = mid;
    		            }
    		        }
    		        if (low == right) {
    		            return low;
    		        }
    		        return low;
    		    } 
    		   
    		    /**
    		     * 
    		     * @param a
    		     * @param left
    		     * @param right
    		     * @param value
    		     * @return greatest index i which a[i] <= value in range [left, right) if exists, otherwise return a number out of [left, right)
    		     */
    		    int ffff(long[] a, int left, int right, int value) {
    		        while (left != right) {
    		            int mid = (left + right) >> 1;
    		            if (a[mid] <= value) {
    		                left = mid + 1;
    		            } else {
    		                right = mid;
    		            }
    		        }
    		        if (left < 0) {
    		            left *= -1;
    		        }
    		        return --left;
    		    }
	    
    		   
    		  
    		
    		    public static String reverse(String s){
    		    	
    		    	String ans = "";
    		    	
    		    	for(int i = s.length()-1;i>=0;i--){
    		    		ans += s.charAt(i);
    		    	}
    		    	
    		    	return ans;
    		    	
    		    }
    			
    			
    		    
    		 
    		    public static long sum(long x){
    		    	return x<10?x:x%10 + sum(x/10);
    		    }
    			
    			public static long gcd(long x, long y) {
    				if (x == 0)
    					return y;
    				else
    					return gcd( y % x,x);
    			}
    			static long inv(long x , long mod)
    			{
    				long r,y;
    				for(r=1,y=mod-2;y!=0;x=x*x%mod,y>>=1)
    				{
    					if((y&1)==1)
    						r=r*x%mod;
    				
    				}
    				return r;
    			}
    			
    			public static long pow(long x,long y,long n){
    				if(y==0)
    					return 1%n;
    				if(y%2==0){
    					long z=pow(x,y/2,n);
    					return (z*z)%n;
    				}
    				return ((x%n)*pow(x,y-1,n))%n;
    			}
    			
    			
    			
    			
    			public static boolean isPrime(int n) {
    				// Corner cases
    				if (n <= 1)
    					return false;
    				if (n <= 3)
    					return true;
    		 
    				// This is checked so that we can skip 
    				// middle five numbers in below loop
    				if (n % 2 == 0 || n % 3 == 0)
    					return false;
    		 
    				for (int i = 5; i * i <= n; i = i + 6)
    					if (n % i == 0 || n % (i + 2) == 0)
    						return false;
    		 
    				return true;
    			}
    			
    		
    			void run() throws NumberFormatException, IOException {
    				in = new FastScanner();
    				out = new PrintWriter(System.out);
    		
    				solve();
    		
    				out.close();
    			}
    		
    			class FastScanner {
    				BufferedReader br;
    				StringTokenizer st;
    		
    				public FastScanner() {
    					br = new BufferedReader(new InputStreamReader(System.in));
    				}
    		
    				String next() {
    					while (st == null || !st.hasMoreTokens()) {
    						try {
    							st = new StringTokenizer(in.br.readLine());
    						} catch (IOException e) {
    							// TODO Auto-generated catch block
    							e.printStackTrace();
    						}
    					}
    					return st.nextToken();
    				}
    		
    				int nextInt() {
    					return Integer.parseInt(next());
    				}
    		
    				long nextLong() {
    					return Long.parseLong(next());
    				}
    		
    				double nextDouble() {
    					return Double.parseDouble(next());
    				}
    			}
    			
    			
    			
    			
    		 
    		
    			public static void main(String[] args) throws NumberFormatException, IOException {
    				new prac().run();
    			}
    		}
    		
