Allen dreams of one day owning a enormous fleet of electric cars, the car of the future! He knows that this will give him a big status boost. As Allen is planning out all of the different types of cars he will own and how he will arrange them, he realizes that he has a problem. 

Allen's future parking lot can be represented as a rectangle with $4$ rows and $n$ ($n \le 50$) columns of rectangular spaces, each of which can contain at most one car at any time. He imagines having $k$ ($k \le 2n$) cars in the grid, and all the cars are initially in the second and third rows. Each of the cars also has a different designated parking space in the first or fourth row. Allen has to put the cars into corresponding parking places.

 [Image] Illustration to the first example. 

However, since Allen would never entrust his cars to anyone else, only one car can be moved at a time. He can drive a car from a space in any of the four cardinal directions to a neighboring empty space. Furthermore, Allen can only move one of his cars into a space on the first or fourth rows if it is the car's designated parking space. 

Allen knows he will be a very busy man, and will only have time to move cars at most $20000$ times before he realizes that moving cars is not worth his time. Help Allen determine if he should bother parking his cars or leave it to someone less important.


-----Input-----

The first line of the input contains two space-separated integers $n$ and $k$ ($1 \le n \le 50$, $1 \le k \le 2n$), representing the number of columns and the number of cars, respectively.

The next four lines will contain $n$ integers each between $0$ and $k$ inclusive, representing the initial state of the parking lot. The rows are numbered $1$ to $4$ from top to bottom and the columns are numbered $1$ to $n$ from left to right.

In the first and last line, an integer $1 \le x \le k$ represents a parking spot assigned to car $x$ (you can only move this car to this place), while the integer $0$ represents a empty space (you can't move any car to this place).

In the second and third line, an integer $1 \le x \le k$ represents initial position of car $x$, while the integer $0$ represents an empty space (you can move any car to this place).

Each $x$ between $1$ and $k$ appears exactly once in the second and third line, and exactly once in the first and fourth line.


-----Output-----

If there is a sequence of moves that brings all of the cars to their parking spaces, with at most $20000$ car moves, then print $m$, the number of moves, on the first line. On the following $m$ lines, print the moves (one move per line) in the format $i$ $r$ $c$, which corresponds to Allen moving car $i$ to the neighboring space at row $r$ and column $c$.

If it is not possible for Allen to move all the cars to the correct spaces with at most $20000$ car moves, print a single line with the integer $-1$.


-----Examples-----
Input
4 5
1 2 0 4
1 2 0 4
5 0 0 3
0 5 0 3

Output
6
1 1 1
2 1 2
4 1 4
3 4 4
5 3 2
5 4 2

Input
1 2
1
2
1
2

Output
-1

Input
1 2
1
1
2
2

Output
2
1 1 1
2 4 1



-----Note-----

In the first sample test case, all cars are in front of their spots except car $5$, which is in front of the parking spot adjacent. The example shows the shortest possible sequence of moves, but any sequence of length at most $20000$ will be accepted.

In the second sample test case, there is only one column, and the cars are in the wrong order, so no cars can move and the task is impossible.

Difficulty: competition

Starter code:

Solutions:
def main():
    n, k = map(int, input().split())
    a, b, c, d = (list(map(int, input().split())) for _ in 'abcd')
    ss, tt, n2, res = [*b, *c[::-1]], [*a, *d[::-1]], n * 2, []
    yx = [*[(2, i + 1) for i in range(n)], *[(3, i) for i in range(n, 0, -1)]]

    def park():
        for i, s, t, (y, x) in zip(range(n2), ss, tt, yx):
            if s == t != 0:
                ss[i] = 0
                res.append(f'{s} {(1, 4)[y == 3]} {x}')

    def rotate():
        start = ss.index(0)
        for i in range(start - n2, start - 1):
            s = ss[i] = ss[i + 1]
            if s:
                y, x = yx[i]
                res.append(f'{s} {y} {x}')
        ss[start - 1] = 0

    park()
    if all(ss):
        print(-1)
        return
    while any(ss):
        rotate()
        park()
    print(len(res), '\n'.join(res), sep='\n')


def __starting_point():
    main()

__starting_point()

def main():
    n, k = map(int, input().split())
    a, b, c, d = (list(map(int, input().split())) for _ in 'abcd')
    ss, tt, n2, res = [*b, *c[::-1]], [*a, *d[::-1]], n * 2, []
    yx = [*[(2, i + 1) for i in range(n)], *[(3, i) for i in range(n, 0, -1)]]

    def park():
        for i, s, t, (y, x) in zip(range(n2), ss, tt, yx):
            if s == t != 0:
                ss[i] = 0
                res.append(f'{s} {(1, 4)[y == 3]} {x}')

    def rotate():
        start = ss.index(0)
        for i in range(start - n2, start - 1):
            s = ss[i] = ss[i + 1]
            if s:
                y, x = yx[i]
                res.append(f'{s} {y} {x}')
        ss[start - 1] = 0

    park()
    if all(ss):
        print(-1)
        return
    while any(ss):
        rotate()
        park()
    print(len(res), '\n'.join(res), sep='\n')


def __starting_point():
    main()




# Made By Mostafa_Khaled
__starting_point()

def all_parked(parked):
    result = True
    for p in parked:
        result = result and p
    return result


class CodeforcesTask995ASolution:
    def __init__(self):
        self.result = ''
        self.n_k = []
        self.parking = []

    def read_input(self):
        self.n_k = [int(x) for x in input().split(" ")]
        for x in range(4):
            self.parking.append([int(y) for y in input().split(" ")])

    def process_task(self):
        parked = [False for x in range(self.n_k[1])]
        moves = []
        for x in range(self.n_k[0]):
            if self.parking[0][x] == self.parking[1][x] and self.parking[1][x]:
                moves.append([self.parking[0][x], 1, x + 1])
                self.parking[1][x] = 0
                parked[self.parking[0][x] - 1] = True
            if self.parking[3][x] == self.parking[2][x] and self.parking[3][x]:
                moves.append([self.parking[3][x], 4, x + 1])
                self.parking[2][x] = 0
                parked[self.parking[3][x] - 1] = True
        if sum([1 if not x else 0 for x in parked]) == self.n_k[1] and self.n_k[1] == self.n_k[0] * 2:
            self.result = "-1"
        else:
            while not all_parked(parked):
                moved = [False for x in range(self.n_k[0])]
                #for p in self.parking:
                #    print(p)
                #print("\n")
                #print(moves)
                if self.parking[1][0] and not self.parking[2][0]:
                    moves.append([self.parking[1][0], 3, 1])
                    self.parking[2][0] = self.parking[1][0]
                    self.parking[1][0] = 0
                    moved[0] = True
                for x in range(1, self.n_k[0]):
                    if not self.parking[1][x - 1] and self.parking[1][x]:
                        moves.append([self.parking[1][x], 2, x])
                        self.parking[1][x - 1] = self.parking[1][x]
                        self.parking[1][x] = 0
                if not self.parking[1][self.n_k[0] - 1] and self.parking[2][self.n_k[0] - 1] and not moved[self.n_k[0] - 1]:
                    moves.append([self.parking[2][self.n_k[0] - 1], 2, self.n_k[0]])
                    self.parking[1][self.n_k[0] - 1] = self.parking[2][self.n_k[0] - 1]
                    self.parking[2][self.n_k[0] - 1] = 0
                for x in range(self.n_k[0] - 1):
                    if not self.parking[2][x + 1] and self.parking[2][x] and not moved[x]:
                        moves.append([self.parking[2][x], 3, x + 2])
                        self.parking[2][x + 1] = self.parking[2][x]
                        self.parking[2][x] = 0
                        moved[x + 1] = True
                for x in range(self.n_k[0]):
                    if self.parking[0][x] == self.parking[1][x] and self.parking[1][x]:
                        moves.append([self.parking[0][x], 1, x + 1])
                        self.parking[1][x] = 0
                        parked[self.parking[0][x] - 1] = True
                    if self.parking[3][x] == self.parking[2][x] and self.parking[3][x]:
                        moves.append([self.parking[3][x], 4, x + 1])
                        self.parking[2][x] = 0
                        parked[self.parking[3][x] - 1] = True
            self.result = "{0}\n{1}".format(len(moves), "\n".join([" ".join([str(x) for x in move]) for move in moves]))

    def get_result(self):
        return self.result


def __starting_point():
    Solution = CodeforcesTask995ASolution()
    Solution.read_input()
    Solution.process_task()
    print(Solution.get_result())

__starting_point()

n,k=list(map(int,input().split()))
m=[]
c=0
for i in range(4):
    m.append(list(map(int,input().split())))
res=[]
for i in range(n):
    if m[1][i] != 0:
        if m[1][i] == m[0][i]:
            res.append([m[1][i],1,i+1])
            m[1][i] = 0
            k-=1
for i in range(n):
    if m[2][i] != 0:
        if m[2][i] == m[3][i]:
            res.append([m[2][i],4,i+1])
            m[2][i] = 0
            k-=1
if k >= n*2:
    print(-1)
    return
if True:
    while True:
        c+=1
        for i in range(n):
            if m[1][i] != 0:
                if i != 0:
                    if m[1][i-1] == 0:
                        res.append([m[1][i],2,i])
                        m[1][i-1] = m[1][i]
                        m[1][i] = 0
                        if m[0][i-1] == m[1][i-1]:
                            res.append([m[1][i-1],1,i])
                            m[0][i-1] = m[1][i-1]
                            m[1][i-1] = 0
                            k-=1
                elif i == 0:
                    if m[2][i] == 0:
                        res.append([m[1][i],3,i+1])
                        m[2][i] = m[1][i]
                        m[1][i] = 0
                        if m[3][i] == m[2][i]:
                            res.append([m[2][i],4,i+1])
                            m[3][i] = m[2][i]
                            m[2][i] = 0
                            k-=1
        for i in range(n):
            if m[2][i] != 0:
                if i != n-1:
                    if m[2][i+1] == 0:
                        res.append([m[2][i],3,i+2])
                        m[2][i+1] = m[2][i]
                        m[2][i] = 0
                        if m[3][i+1] == m[2][i+1]:
                            res.append([m[2][i+1],4,i+2])
                            m[3][i+1] = m[2][i+1]
                            m[2][i+1] = 0
                            k-=1
                else:
                    if m[1][i] == 0:
                        res.append([m[2][i],2,i+1])
                        m[1][i] = m[2][i]
                        m[2][i] = 0
                        if m[0][i] == m[1][i]:
                            res.append([m[1][i],1,i+1])
                            m[0][i] = m[1][i]
                            m[1][i] = 0
                            k-=1
        if k <= 0:
            break
                
else:
    print(-1)
    return
print(len(res))
for i in res:
    print(*i)


def __starting_point():
    numbers = list(map(int, input().split()))
    n = numbers[0]
    k = numbers[1]
    left = 0
    left = k
    table = []
    x = 4
    while x > 0:
        table.append(list(map(int, input().split())))
        x = x -1
    moves = []
    for i in range(n):
        if table[1][i] == table[0][i] and table[1][i] != 0:
            moves.append((table[1][i], 1, i + 1))
            table[0][i] = table[1][i]
            table[1][i] = 0
        if table[2][i] == table[3][i] and table[2][i] != 0:
            moves.append((table[2][i], 4, i + 1))
            table[3][i] = table[2][i]
            table[2][i] = 0
    ok = 0
    for i in range(n):
        if table[1][i] == 0:
            ok = 1
            break
        if table[2][i] == 0:
            ok = 1
            break
    if ok == 0:
        print(-1)
        return
    for i in range(20000):
        if table[1][0] != 0 and table[2][0] == 0:
            moves.append((table[1][0], 3,  1))
            table[2][0] = table[1][0]
            table[1][0] = 0
            if n == 1:
                continue
        for j in range(1, n):
            if table[1][j - 1] == 0 and table[1][j] != 0:
                moves.append((table[1][j], 2, j))
                table[1][j - 1] = table[1][j]
                table[1][j] = 0
        for j in range(n):
            if table[1][j] == table[0][j] and table[1][j] != 0:
                moves.append((table[1][j], 1, j + 1))
                table[0][j] = table[1][j]
                table[1][j] = 0
            if table[2][j] == table[3][j] and table[2][j] != 0:
                moves.append((table[2][j], 4, j + 1))
                table[3][j] = table[2][j]
                table[2][j] = 0
        if table[1][n - 1] == 0 and table[2][n - 1] != 0:
            moves.append((table[2][n - 1], 2, n))
            table[1][n-1] = table[2][n-1]
            table[2][n-1] = 0
        for j in range(n - 2,  -1, -1):
            if table[2][j + 1] == 0 and table[2][j] != 0:
                moves.append((table[2][j], 3, j + 2))
                table[2][j + 1] = table[2][j]
                table[2][j] = 0

        for j in range(n):
            if table[1][j] == table[0][j] and table[1][j] != 0:
                        moves.append((table[1][j], 1, j + 1))
                        table[0][j] = table[1][j]
                        table[1][j] = 0
            if table[2][j] == table[3][j] and table[2][j] != 0:
                        moves.append((table[2][j], 4, j + 1))
                        table[3][j] = table[2][j]
                        table[2][j] = 0
    if len(moves) > 20000:
        print(-1)
        return
    print(len(moves))
    # for j in range(len(moves)):
      #  print(moves[j])
    for j in moves:
        print(*j)



__starting_point()

a=[0]*4
n,k=list(map(int,input().split()))
for i in range(4):
    a[i]=list(map(int,input().split()))
for i in range(n-1,-1,-1):
    a[0].append(a[3][i])
    a[1].append(a[2][i])
ans=[]
def check():
    nonlocal k
    for i in range(2*n):
        if a[0][i]==a[1][i] and a[0][i]!=0:
            if i<n:
                ans.append([a[1][i],0,i])
            else:
                ans.append([a[1][i],3,2*n-i-1])
            k-=1
            a[0][i]=a[1][i]=0
def fuck():
    step=-1
    for i in range(2*n):
        if a[1][i]==0:
            step=i
            break
    if step==-1:
        return False
    else:
        for i in range(2*n-1):
            x=(step+i)%(2*n)
            y=(step+1+i)%(2*n)
            if a[1][y]!=0:
                a[1][x]=a[1][y]
                if x==n-1 and y==n:
                    ans.append([a[1][y],1,n-1])
                elif x==0 and y==0:
                    ans.append([a[1][y],2,0])
                elif x<n:
                    ans.append([a[1][y],1,x])
                else:
                    ans.append([a[1][y],2,2*n-x-1])
                a[1][y] = 0
        return True
check()
while k!=0:
    if fuck()==False:
        print(-1)
        return
    check()
print(len(ans))
for i in ans:
    x,y,z=i
    print(x,y+1,z+1)