import sys

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

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














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

def distance(r,c):
    return abs(r-IT[0])+abs(c-IT[1])





def move_hiders(board):
    global N
    
    cBoard = [[[] for _ in range(N)] for _ in range(N)]

    for i in range(N):
        for j in range(N):
            if board[i][j]!=[]:

                if distance(i,j)<=3:

                    for dr in board[i][j]:
                        nPos = [i+dirs[dr][0], j+dirs[dr][1]]

                        if not (0<=nPos[0]<N and 0<=nPos[1]<N):
                            dr = (dr+2)%4
                            nPos = [i+dirs[dr][0], j+dirs[dr][1]]

                        if nPos!=IT:
                            cBoard[nPos[0]][nPos[1]].append(dr)
                        else:
                            cBoard[i][j].append(dr)
                else:
                    cBoard[i][j]=board[i][j]
    # board=deepcopy(cBoard)
    return deepcopy(cBoard)


def move_IT():
    global N, IT, move_cnt, move_dir, move_flag, rev, flag

    # nPos = [IT[0]+dirs[move_dir][0], IT[1]+dirs[move_dir][1]]
    IT = [IT[0]+dirs[move_dir][0], IT[1]+dirs[move_dir][1]]

    # if nPos==[0,0] or nPos==[N//2, N//2]:
    if IT==[0,0] or IT==[N//2, N//2]:
        rev=(rev+1)%2
        move_dir = (move_dir+2)%4
        # move_cnt=1
        # flag=1

        if rev!=0:
            move_cnt=1
            flag=1
        else:
            move_cnt=0
            flag=0
        # move_flag-=1
        return
    
    move_cnt+=1

    if move_cnt == move_flag:
        move_cnt=0

        if rev==0:
            move_dir= (move_dir+1)%4
        else:
            move_dir= (move_dir+3)%4


        if flag==1:
            if rev==0:
                move_flag+=1
            
            else:
                move_flag-=1
                
            flag=0
        else:
            flag+=1

        
    
    

    




def IT_sight():
    global IT, N, move_dir,ans,time

    nPos = [IT[0], IT[1]]

    while 0<=nPos[0]<N and 0<=nPos[1]<N:
        if board[nPos[0]][nPos[1]]!=[] and tree[nPos[0]][nPos[1]]==0:
            ans+=len(board[nPos[0]][nPos[1]])*time
            board[nPos[0]][nPos[1]]=[]
        
        nPos = [nPos[0]+dirs[move_dir][0], nPos[1]+dirs[move_dir][1]]


if __name__=="__main__":

    N ,M, H, K = map(int, input().split())

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

    # board = [[0]*N for _ in range(N)]
    board = [[[] for _ in range(N)] for _ in range(N)]
    tree = [[0]*N for _ in range(N)]


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

    for _ in range(H):
        r,c = map(lambda x:int(x)-1, input().split())
        tree[r][c]=1

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

    IT = [N//2, N//2]
    move_dir=3
    move_cnt=0
    rev=0
    flag=0
    move_flag=1

    ans =0
    for time in range(1,K+1):
        
        board = move_hiders(board)

        move_IT()
        
        IT_sight()

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