Absent-minded Masha got set of *n* cubes for her birthday.

At each of 6 faces of each cube, there is exactly one digit from 0 to 9. Masha became interested what is the largest natural *x* such she can make using her new cubes all integers from 1 to *x*.

To make a number Masha can rotate her cubes and put them in a row. After that, she looks at upper faces of cubes from left to right and reads the number.

The number can't contain leading zeros. It's not required to use all cubes to build a number.

Pay attention: Masha can't make digit 6 from digit 9 and vice-versa using cube rotations.
In first line integer *n* is given (1 ≤ *n* ≤ 3) — the number of cubes, Masha got for her birthday.

Each of next *n* lines contains 6 integers *a*<sub class="lower-index">*i*</sub><sub class="lower-index">*j*</sub> (0 ≤ *a*<sub class="lower-index">*i*</sub><sub class="lower-index">*j*</sub> ≤ 9) — number on *j*-th face of *i*-th cube.
In the first test case, Masha can build all numbers from 1 to 87, but she can't make 88 because there are no two cubes with digit 8.
3
0 1 2 3 4 5
6 7 8 9 0 1
2 3 4 5 6 7
87
3
0 1 3 5 6 8
1 2 4 5 7 8
2 3 4 6 7 9
98
3
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
5
3
1 2 3 7 8 9
9 8 7 1 2 3
7 9 2 3 1 8
3
1
5 2 2 5 6 7
0
1
7 6 5 8 9 0
0
1
2 5 9 6 7 9
0
1
6 3 1 9 4 9
1
1
1 9 8 3 7 8
1
2
1 7 2 0 4 3
5 2 3 6 1 0
7
2
6 0 1 7 2 9
1 3 4 6 7 0
4
2
8 6 4 1 2 0
7 8 5 3 2 1
8
2
0 8 6 2 1 3
5 2 7 1 0 9
3
2
0 9 5 7 6 2
8 6 2 7 1 4
2
3
5 0 7 6 2 1
2 7 4 6 1 9
0 2 6 1 7 5
2
3
0 6 2 9 5 4
3 8 0 1 6 9
6 9 0 1 5 2
6
3
5 6 2 9 3 5
5 4 1 5 9 8
4 4 2 0 3 5
6
3
0 1 9 1 0 8
9 9 3 5 6 2
9 3 9 9 7 3
3
3
2 5 7 4 2 7
1 5 5 9 0 3
8 2 0 1 5 1
5
1
4 6 9 8 2 7
0
1
5 3 8 0 2 6
0
1
7 9 5 0 4 6
0
1
4 0 9 6 3 1
1
1
7 9 2 5 0 4
0
1
0 7 6 3 2 4
0
1
9 8 1 6 5 7
1
1
7 3 6 9 8 1
1
1
3 9 1 7 4 5
1
1
8 6 0 9 4 2
0
1
8 2 7 4 1 0
2
1
8 3 5 4 2 9
0
1
0 8 7 1 3 2
3
1
6 2 8 5 1 3
3
1
6 0 7 5 4 8
0
1
6 2 8 4 5 1
2
1
4 3 8 9 2 3
0
1
8 1 9 2 9 7
2
1
3 7 7 6 4 2
0
1
1 4 5 7 0 5
1
2
6 6 4 7 9 0
2 1 2 8 6 4
2
2
5 3 2 9 8 2
0 7 4 8 1 8
5
2
5 7 4 2 1 9
2 2 7 1 1 8
2
2
9 3 3 6 7 2
6 2 9 1 5 9
3
2
2 0 5 7 0 8
4 5 1 5 4 9
2
2
2 6 8 1 3 1
2 1 3 8 6 7
3
2
4 3 8 6 0 1
4 7 1 8 9 0
1
2
0 2 9 1 8 5
0 7 4 3 2 5
5
2
1 7 6 9 2 5
1 6 7 0 9 2
2
2
0 2 9 8 1 7
6 7 4 3 2 5
9
2
3 6 8 9 5 0
6 7 0 8 2 3
0
2
5 1 2 3 0 8
3 6 7 4 9 2
9
2
7 8 6 1 4 5
8 6 4 3 2 5
8
2
2 3 5 1 9 6
1 6 8 7 3 9
3
2
1 7 8 6 0 9
3 2 1 7 4 9
4
2
2 4 0 3 7 6
3 2 8 7 1 5
8
2
6 5 2 7 1 3
3 7 8 1 0 9
3
2
5 8 4 7 1 2
0 8 6 2 4 9
2
2
8 0 6 5 1 4
7 1 0 8 3 4
1
2
2 3 9 1 6 7
2 5 4 3 0 6
7
3
9 4 3 0 2 6
7 0 5 3 3 9
1 0 7 4 6 7
7
3
3 8 5 1 5 5
1 5 7 2 6 9
4 3 4 8 8 9
9
3
7 7 2 5 3 2
3 0 0 6 4 4
1 2 1 1 9 1
7
3
8 1 6 8 6 8
7 0 2 5 8 4
5 2 0 3 1 9
32
3
2 7 4 0 7 1
5 5 4 9 1 4
2 1 7 5 1 7
2
3
4 4 5 0 6 6
7 1 6 9 5 4
5 0 4 0 3 9
1
3
9 4 3 3 9 3
1 0 3 4 5 3
2 9 6 2 4 1
6
3
3 8 3 5 5 5
3 0 1 6 6 3
0 4 3 7 2 4
8
3
4 1 0 8 0 2
1 5 3 5 0 7
7 7 2 7 2 2
5
3
8 1 8 2 7 1
9 1 9 9 4 7
0 0 9 0 4 0
2
3
4 6 0 3 9 2
8 6 9 0 7 2
6 9 3 2 5 7
0
3
5 1 2 9 6 4
9 0 6 4 2 8
4 6 2 8 3 7
10
3
9 3 1 8 4 6
6 9 1 2 0 7
8 9 1 5 0 3
21
3
7 1 3 0 2 4
2 4 3 0 9 5
1 9 8 0 6 5
65
3
9 4 6 2 7 0
3 7 1 9 6 4
6 1 0 8 7 2
4
3
2 7 3 6 4 5
0 2 1 9 4 8
8 6 9 5 4 0
10
3
2 6 3 7 1 0
9 1 2 4 7 6
1 4 8 7 6 2
4
3
5 4 8 1 6 7
0 9 3 5 8 6
2 4 7 8 1 3
21
3
7 2 1 3 6 9
0 3 8 4 7 6
1 4 5 8 7 0
21
3
8 6 0 5 4 9
1 8 5 3 9 7
7 4 5 1 6 8
1
1
0 1 2 3 4 5
5
3
0 1 1 2 2 3
4 5 6 7 8 9
3 4 5 6 7 8
9
2
0 1 2 3 4 5
6 7 8 9 1 2
29
3
0 1 2 3 4 5
6 7 8 9 1 2
3 4 5 6 7 8
98
3
0 1 1 2 2 3
4 5 6 7 8 9
3 4 5 6 7 1
19
2
0 1 2 3 4 5
6 7 8 9 6 6
9
2
0 1 2 3 4 5
4 5 6 7 8 9
9
2
1 8 9 1 1 0
2 3 4 5 6 7
9
2
0 1 2 3 4 5
9 8 7 6 5 4
9
3
2 3 4 5 6 7
3 4 5 6 7 8
9 1 2 3 4 5
9
3
1 1 2 3 4 5
6 7 8 9 0 2
3 4 5 6 7 8
10
3
1 1 1 0 2 3
4 5 6 7 8 9
0 0 0 0 0 0
10
3
0 1 2 2 4 5
6 7 8 9 0 1
3 3 4 5 6 7
21
3
2 0 1 3 4 5
6 7 8 9 1 1
3 4 5 6 6 7
19
3
1 1 1 1 1 1
0 2 3 4 5 6
7 8 9 2 3 4
10
2
0 1 2 3 4 5
6 6 6 7 8 9
9
3
3 4 5 6 8 9
1 1 1 1 1 1
1 2 4 5 7 0
19
import math
import os
import sys
from io import BytesIO, IOBase
from types import GeneratorType
from collections import defaultdict
BUFSIZE = 8192
from bisect import bisect_left
from bisect import bisect_right


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
from collections import deque

def ceil(a,b):
    if(a<=0):
        return 0
    if(a%b==0):
        return(a//b)
    else:
        return ((a//b)+1)


t=1
for _ in range(t):
    vis=[0 for i in range(1001)]
    b=[]
    n=int(input())
    for i in range(n):
        b.append(list(map(int,input().split())))
    if(n==1):
        for i in range(6):
            vis[b[0][i]]=True
    elif (n==2):
        poss=[[b[0],b[1]],[b[1],b[0]]]
        for j in poss:
            p1,p2=j
            for i in range(6):
                for j in range(6):
                    vis[p1[i]*10+p2[j]]=True
        for i in range(6):
            vis[b[0][i]]=True
            vis[b[1][i]]=True

    else:
        p1,p2,p3=b

        for i in range(6):
            vis[p1[i]]=True
            vis[p2[i]]=True
            vis[p3[i]]=True
        poss=[[p1,p2],[p2,p3],[p1,p3],[p3,p1],[p3,p2],[p2,p1]]
        for j in poss:
            q1,q2=j
            for i in range(6):
                for j in range(6):
                    vis[q1[i]*10+q2[j]]=True

        poss = [[p1,p2,p3], [p2, p3,p1], [p1,p3,p2], [p3, p1,p2], [p3, p2,p1], [p2, p1,p3]]
        for j in poss:
            q1,q2,q3=j
            for i in range(6):
                for j in range(6):
                    for k in range(6):
                        vis[q1[i]*100+q2[j]*10+q3[k]]=True

    ans=0
    for i in range(1001):
        if(not vis[i]):
            break
        else:
            ans=i

    print(ans)












