public void permutation(char[] arr, int depth, int n, int r) {
    if(depth == r) {
        print(arr);
        return;
    }

    for(int i = depth; i < n; i++) {
        swap(arr, depth, i);
        permutation(arr, depth + 1, n, r);
        swap(arr, depth, i);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class GroupPhoto_level2 {
    // 어피치, 콘, 프로도, 제이지, 무지, 네오, 라이언, 튜브
    static char[] kakaoFriends = {'A', 'C', 'F', 'J', 'M', 'N', 'R', 'T'};
    static int totalcnt;

    public static int findFriend(char[] kakao, char pick) {
        for(int i = 0; i < kakao.length; i++) {
            if(kakao[i] == pick) return i;
        }
        return -1;
    } 

    public static void checkOrder(char[] kakao, String[] data) {
        int len = data.length;
        for(int i = 0; i < len; i++) {
            char[] tmp = data[i].toCharArray();
            int first = findFriend(kakao, tmp[0]);
            int second = findFriend(kakao, tmp[2]);
            int gap = tmp[4] - '0';
            if(tmp[3] == '=') {
                if(Math.abs(first - second) != gap + 1) return;
            } else if(tmp[3] == '<') {
                if(Math.abs(first - second) >= gap + 1) return;
            } else if(tmp[3] == '>') {
                if(Math.abs(first - second) <= gap + 1) return;
            }
        }

        totalcnt++;
    }

    public static void swap(char[] data, int depth, int i) {
        char tmp = data[depth];
        data[depth] = data[i];
        data[i] = tmp;
    }

    public static void permutation(char[] arr, int depth, int n, int r, String[] data) {
        if(depth == r) {
            checkOrder(arr, data);
            return;
        }

        for(int i = depth; i < n; i++) {
            swap(arr, depth, i);
            permutation(arr, depth + 1, n, r, data);
            swap(arr, depth, i);
        }
    }
    public static int solution(int n, String[] data) {
        totalcnt = 0;
        permutation(kakaoFriends, 0, 8, 8, data);
        return totalcnt;
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        int N = Integer.parseInt(st.nextToken());
        String[] data = new String[N];
        st = new StringTokenizer(br.readLine());
        for(int i = 0; i < N; i++) {
            data[i] = st.nextToken();
        }

        System.out.println(solution(N, data));
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

public class AlleyBossHoseok_20182 {
    static int N, M, A, B, C;
    static List<List<Pay>> map;
    static int min[];
    static int solution() {
        int answer = 0;

        PriorityQueue<Pay> pq = new PriorityQueue<>(new Comparator<Pay>(){
            @Override
            public int compare(Pay o1, Pay o2) {
                if(o1.p == o2.p) return o1.n - o2.n;
                else return o1.p - o2.p;
            }
        });

        boolean[] visited = new boolean[N + 1];

        pq.add(new Pay(A, 0, Integer.MIN_VALUE));

        while(!pq.isEmpty()) {
            Pay cur = pq.poll();
            if(visited[cur.n] || cur.n == B) continue;
            
            visited[cur.n] = true;

            for(Pay next : map.get(cur.n)) {
                int totalPay = cur.p + next.n;
                if(visited[next.n] || totalPay > C) continue;

                int curMax = cur.max;
                if(curMax < next.p) {
                    curMax = next.p;
                }
                if(min[next.n] > curMax) min[next.n] = curMax;
                pq.add(new Pay(next.n, totalPay, curMax)); 
            }
        }
        
        answer = min[B] != Integer.MAX_VALUE ? min[B] : -1;
        return answer;
    }
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        A = Integer.parseInt(st.nextToken());
        B = Integer.parseInt(st.nextToken());
        C = Integer.parseInt(st.nextToken());

        map = new ArrayList<>();
        min = new int[N + 1];
        Arrays.fill(min, Integer.MIN_VALUE);

        for(int i = 0; i <= N; i++) map.add(new ArrayList<>());
        for(int i = 0; i < M; i++) {
            if(!st.hasMoreTokens()) st = new StringTokenizer(br.readLine());
            int one = Integer.parseInt(st.nextToken());
            int two = Integer.parseInt(st.nextToken());
            int cost = Integer.parseInt(st.nextToken());

            map.get(one).add(new Pay(two, cost));
            map.get(two).add(new Pay(one, cost));
        }

        System.out.println(solution());
    }
}

class Pay {
    int n;
    int p;
    int max;

    public Pay(int n, int p) {
        this.n = n;
        this.p = p;
    }

    public Pay(int n, int p, int max) {
        this.n = n;
        this.p = p;
        this.max = max;
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class MagicianShark_Windblows_21610 {
    static int N, M;
    static int[][] map;
    static boolean[][] rain;
    static int[][] dir = {  // 0은 빈칸, 좌, 좌상, 상, 우상, 우, 우하, 하, 좌하
        {0, 0, -1, -1, -1, 0, 1, 1, 1},
        {0, -1, -1, 0, 1, 1, 1, 0, -1}
    };
    static int[][] checkBucket = {
        {-1, -1, 1, 1},
        {-1, 1, -1, 1}
    };
    static int[][] command;
    static Queue<Cloud> cloud;
    public static void moveCloudnRain(int d, int s) {
        int size = cloud.size();

        rain = new boolean[N + 1][N + 1];
        while(size > 0) {
            Cloud tmp = cloud.poll();
            int nr = tmp.r + (dir[0][d] * (s % N));
            int nc = tmp.c + (dir[1][d] * (s % N));

            // 이어붙인 공간 넘어가기
            if(nr <= 0) nr = N + nr;
            if(nc <= 0) nc = N + nc;
            if(nr > N) nr = nr - N;
            if(nc > N) nc = nc - N;

            cloud.add(new Cloud(nr, nc));
            map[nr][nc]++;
            rain[nr][nc] = true;
            size--;
        }
    }
    public static void copywater() {
        int[][] copyMap = new int[N + 1][N + 1];
        for(int i = 1; i <= N; i++) {
            for(int j = 1; j <= N; j++) {
                copyMap[i][j] = map[i][j];
            }
        }

        while(!cloud.isEmpty()) {
            Cloud tmp = cloud.poll();
            rain[tmp.r][tmp.c] = true;

            // 물 복사 마법
            int cnt = 0;
            for(int i = 0; i < 4; i++) {
                int nr = tmp.r + checkBucket[0][i];
                int nc = tmp.c + checkBucket[1][i];
                if(nr <= 0 || nc <= 0 || nr > N || nc > N) continue;
                if(copyMap[nr][nc] > 0) cnt++; 
            }
            map[tmp.r][tmp.c] += cnt;
        }
    }
    public static void makeCloud() {
        for(int i = 1; i <= N; i++) {
            for(int j = 1; j <= N; j++) {
                if(!rain[i][j] && map[i][j] >= 2) {
                    cloud.add(new Cloud(i, j));
                    map[i][j] -= 2;
                }
            }
        }
    }
    public static void solution() {
        for(int i = 0; i < M; i++) {
            moveCloudnRain(command[i][0], command[i][1]);
            copywater();
            makeCloud();
        }
    }
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());

        map = new int[N + 1][N + 1];
        command = new int[M][2];

        cloud = new LinkedList<Cloud>();

        cloud.add(new Cloud(N, 1));
        cloud.add(new Cloud(N, 2));
        cloud.add(new Cloud(N - 1, 1));
        cloud.add(new Cloud(N - 1, 2));
        
        for(int i = 1; i <= N; i++) {
            if(!st.hasMoreTokens()) st = new StringTokenizer(br.readLine());
            for(int j = 1; j <= N; j++) {
                map[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        for(int i = 0; i < M; i++) {
            if(!st.hasMoreTokens()) st = new StringTokenizer(br.readLine());
            command[i][0] = Integer.parseInt(st.nextToken());
            command[i][1] = Integer.parseInt(st.nextToken());
        }

        solution();

        int result = 0;
        for(int i = 1; i <= N; i++) {
            for(int j = 1; j <= N; j++) {
                result += map[i][j];
            }
        }

        System.out.println(result);
    }
}

class Cloud {
    int r, c;   // 위치 정보 초기 (N, 1), (N, 2), (N-1, 1), (N-1, 2)
    public Cloud(int r, int c) {
        this.r = r;
        this.c = c;
    }
}