import sys
# from copy import deepcopy
from time import time

sys.stdin=open("input.txt", "r")


dirs = ([0,-1],[-1,-1],[-1,0],[-1,1],[0,1],[1,1],[1,0],[1,-1])

sDir = ([-1,0],[0,-1],[1,0],[0,1])

def deepcopy(arr):
    return [[cols[:] for cols in rows] for rows in arr]

def fish_move():
    global shark
    mBoard = [[[] for _ in range(4)] for _ in range(4)]
    for i in range(4):
        for j in range(4):
            if board[i][j]:
                for n in range(len(board[i][j])):
                    dr = board[i][j][n]
                    for t in range(8):
                        nPos = [i+dirs[(dr+(7*t))%8][0], j+dirs[(dr+(7*t))%8][1]]
                        # if i==1 and j==0:
                        #     print("nPos",nPos)
                        #     print("shark",shark)
                        if 0<=nPos[0]<4 and 0<=nPos[1]<4 and smell[nPos[0]][nPos[1]]==0 and nPos!=shark:
                            mBoard[nPos[0]][nPos[1]].append((dr+(7*t))%8)
                            break
                    else:
                        mBoard[i][j].append(dr)
    return mBoard


def shark_move(dep, route, cnt, s, sBoard):
    global shark_cnt, shark_route
    if dep==3:
        if shark_route==[]:
            shark_route =route[:]
            shark_cnt =cnt
        elif cnt> shark_cnt:
            shark_route =route[:]
            shark_cnt =cnt
        return
    
    for d in sDir:
        nPos = [s[0]+d[0],s[1]+d[1]]
        if 0<=nPos[0]<4 and 0<=nPos[1]<4:
            A = sBoard[nPos[0]][nPos[1]][:]
            plus=len(sBoard[nPos[0]][nPos[1]])
            sBoard[nPos[0]][nPos[1]]=[]
            route.append(nPos)
            shark_move(dep+1, route, cnt+plus, nPos ,deepcopy(sBoard))
            sBoard[nPos[0]][nPos[1]]=A
            route.pop()


if __name__=="__main__":
    start =time()
    M, S = map(int, input().split())

    board = [[[] for _ in range(4)] for _ in range(4)]
    smell = [[0]*4 for _ in range(4)]
    

    for _ in range(M):
        r,c,d = map(int, input().split())
        board[r-1][c-1].append(d-1)

    # comm = [list(map(int, input().split())) for _ in range(S)]
    shark=list(map(lambda x: int(x)-1, input().split()))
    # print(*board,sep='\n')
    # print(shark)
    # print(*smell, sep='\n')

    for _ in range(S):
        cBoard = deepcopy(board)
        
        board = fish_move()
        # print(*board,sep='\n')

        shark_route=[]
        shark_cnt=0
        shark_move(0,[],0, shark,deepcopy(board))
        # print()
        # print(shark_route)
        # print(shark_route[2])
        # print(shark_cnt)
        
        shark = shark_route[2]
        for rt in shark_route:
            if board[rt[0]][rt[1]]:
                board[rt[0]][rt[1]]=[]
                smell[rt[0]][rt[1]]=3
        
        # print(*board,sep='\n')
        for i in range(4):
            for j in range(4):
                if smell[i][j]>0:
                    smell[i][j]-=1
                board[i][j]+=cBoard[i][j]
        
        # print()
        # print(*smell, sep='\n')
        # print(*board, sep='\n')
        # print("-"*20)
    
    ans =0
    for i in range(4):
        for j in range(4):
            ans +=len(board[i][j])

    print(ans)

    end =time()

    print(f"time : {end-start}")


_______________________________________________________


import sys

dirs= ([-1,0],[0,-1],[1,0],[0,1])

sys.stdin=open("input.txt", "r")

def find_same():
    global N,M
    visited = [[0]*M for _ in range(N)]
    flag=0
    for i in range(N):
        for j in range(M):
            if board[i][j]!=0:
                for d in dirs:
                    nPos = [i+d[0], (j+d[1])%M]
                    if 0<=nPos[0]<N and board[i][j] == board[nPos[0]][nPos[1]]:
                        visited[i][j]=1
                        flag=1
                        break

    if flag==1:

        for i in range(N):
            for j in range(M):
                if visited[i][j]==1:
                    board[i][j]=0
        return False
    else:
        return True

    


def average():
    global N,M

    num=0
    cnt =0

    for i in range(N):
        for j in range(M):
            if board[i][j]!=0:
                cnt+=1
                num+=board[i][j]

    num/=cnt

    for i in range(N):
        for j in range(M):
            if board[i][j]!=0:
                if board[i][j]>num:
                    board[i][j]-=1
                elif board[i][j]<num:
                    board[i][j]+=1

if __name__=="__main__":

    N,M,T = map(int, input().split())

    # board = [deque(map(int, input().split())) for _ in range(N)]
    board = [list(map(int, input().split())) for _ in range(N)]

    print(board)

    comm = [list(map(int, input().split())) for _ in range(T)]

    print(*board, sep='\n')
    print()

    for c in comm:
        if c[1]==0:
            c[2]*=-1
        b = c[0]-1

        for a in range(b,N,b+1):
            board[a]=board[a][c[2]:]+board[a][:c[2]]

        print(*board, sep='\n')

        flag =0
        
        if find_same():
            flag=1

        if flag==1:
            average()

    ans = 0
    for n in range(N):
        ans+=sum(board[n])

    print(ans)


        




_____________________________________________________________

import sys


sys.stdin=open("input.txt", "r")

def deepcopy(arr):
    return [[cols[:] for cols in rows] for rows in arr]

dirs = ([-1,0],[-1,-1],[0,-1],[1,-1],[1,0],[1,1],[0,1],[-1,1])


def dfs(shark, board, cnt):
    global a
    
    cBoard = deepcopy(board)
    pos = shark

    cnt+=cBoard[pos[0]][pos[1]][0]
    # a = max(a, cnt)
    cBoard[pos[0]][pos[1]]=[cBoard[pos[0]][pos[1]][1]]
    # print("pos",pos)
    # print(*cBoard, sep='\n')

    for n in range(1,17):
        flag=0
        for i in range(4):
            for j in range(4):
                if len(cBoard[i][j])==2 and cBoard[i][j][0]==n:
                    d = cBoard[i][j][1]-1
                    for t in range(8):
                        d = (d+1)%8
                        nPos = [i+dirs[d][0], j+dirs[d][1]]
                        if 0<=nPos[0]<4 and 0<=nPos[1]<4 and (len(cBoard[nPos[0]][nPos[1]])==2 or len(cBoard[nPos[0]][nPos[1]])==0):
                            cBoard[i][j], cBoard[nPos[0]][nPos[1]] = cBoard[nPos[0]][nPos[1]], [n,d]
                            flag=1
                            break
                if flag==1:
                    break
            if flag==1:
                break
        
                    
    shark_pos=[]
    d = cBoard[pos[0]][pos[1]][0]
    cBoard[pos[0]][pos[1]]=[]
    for _ in range(1,4):
        # print("pos1", pos)
        pos = [pos[0]+dirs[d][0], pos[1]+dirs[d][1]]
        if 0<=pos[0]<4 and 0<=pos[1]<4 and len(cBoard[pos[0]][pos[1]])==2:
            shark_pos.append(pos)
    
    if len(shark_pos)==0:
        a = max(a, cnt)
        return


    for s in shark_pos:
        dfs(s, cBoard, cnt)


if __name__=="__main__":

    fish = [list(map(int, input().split())) for _ in range(4)]
    board = [[[] for _ in range(4)] for _ in range(4)]
    
    a =0
    
    # print(*board, sep='\n')
    for i in range(4):
        for j in range(0,8,2):
            board[i][j//2].append(fish[i][j])
            board[i][j//2].append(fish[i][j+1]-1)
    

    # print(*board, sep='\n')
    shark=[0,0]
    dfs(shark, board, 0)

    print(a)