In BerSoft n programmers work, the programmer i is characterized by a skill r_i.

A programmer a can be a mentor of a programmer b if and only if the skill of the programmer a is strictly greater than the skill of the programmer b (r_a > r_b) and programmers a and b are not in a quarrel.

You are given the skills of each programmers and a list of k pairs of the programmers, which are in a quarrel (pairs are unordered). For each programmer i, find the number of programmers, for which the programmer i can be a mentor.

Input

The first line contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 0 ≤ k ≤ min(2 ⋅ 10^5, (n ⋅ (n - 1))/(2))) — total number of programmers and number of pairs of programmers which are in a quarrel.

The second line contains a sequence of integers r_1, r_2, ..., r_n (1 ≤ r_i ≤ 10^{9}), where r_i equals to the skill of the i-th programmer.

Each of the following k lines contains two distinct integers x, y (1 ≤ x, y ≤ n, x ≠ y) — pair of programmers in a quarrel. The pairs are unordered, it means that if x is in a quarrel with y then y is in a quarrel with x. Guaranteed, that for each pair (x, y) there are no other pairs (x, y) and (y, x) in the input.

Output

Print n integers, the i-th number should be equal to the number of programmers, for which the i-th programmer can be a mentor. Programmers are numbered in the same order that their skills are given in the input.

Examples

Input

4 2
10 4 10 15
1 2
4 3


Output

0 0 1 2 


Input

10 4
5 4 1 5 4 3 7 1 2 5
4 6
2 1
10 8
3 5


Output

5 4 0 5 3 3 9 0 2 5 

Note

In the first example, the first programmer can not be mentor of any other (because only the second programmer has a skill, lower than first programmer skill, but they are in a quarrel). The second programmer can not be mentor of any other programmer, because his skill is minimal among others. The third programmer can be a mentor of the second programmer. The fourth programmer can be a mentor of the first and of the second programmers. He can not be a mentor of the third programmer, because they are in a quarrel.

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

public class FMentors {

    public static void main(String[] args) throws IOException {
        // https://codeforces.com/problemset/problem/651/B
        OutputStream out = new BufferedOutputStream(System.out);
        FastReader sc = new FastReader();
        MergeSort1 ms1 = new MergeSort1();
        MergeSort2 ms2 = new MergeSort2();
        int n = sc.nextInt(), k = sc.nextInt(), r, a, b;
        programer p[] = new programer[n];
        for (int i = 0; i < n; i++) {
            r = sc.nextInt();
            p[i] = new programer(i, r, 0);
        }
        for (int i = 0; i < k; i++) {
            a = sc.nextInt() - 1;
            b = sc.nextInt() - 1;
            if (p[a].r > p[b].r) {
                p[a].mentor--;
            } else {
                if (p[b].r > p[a].r) {
                    p[b].mentor--;
                }
            }
        }
        ms2.sort(p, 0, n - 1);
        for (int i = 0; i < n; i++) {
            p[i].mentor += lowerBound(p, n,p[i].r);
        }
        ms1.sort(p, 0, n - 1);
        for (int i = 0; i < n; i++) {
            if (p[i].mentor > -1) {
                out.write((p[i].mentor + " ").getBytes());
                out.flush();
            } else {
                out.write(("0 ").getBytes());
                out.flush();
            }
        }
    }

    static class programer {

        int index, r, mentor;

        public programer(int index, int r, int quarrel) {
            this.index = index;
            this.r = r;
            this.mentor = quarrel;
        }

    }

    static int lowerBound(programer[] array, int length, int value) {
        int low = 0;
        int high = length;
        while (low < high) {
            final int mid = (low + high) / 2;
            if (value <= array[mid].r) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }
        return low;
    }

    static class MergeSort1 {

        void merge(programer arr[], int l, int m, int r) {
            int n1 = m - l + 1;
            int n2 = r - m;
            programer L[] = new programer[n1];
            programer R[] = new programer[n2];
            for (int i = 0; i < n1; ++i) {
                L[i] = arr[l + i];
            }
            for (int j = 0; j < n2; ++j) {
                R[j] = arr[m + 1 + j];
            }
            int i = 0, j = 0;
            int k = l;
            while (i < n1 && j < n2) {
                if (L[i].index <= R[j].index) {
                    arr[k]= L[i];
                    i++;
                } else {
                    arr[k]= R[j];
                    j++;
                }
                k++;
            }
            while (i < n1) {
                arr[k] = L[i];
                i++;
                k++;
            }
            while (j < n2) {
                arr[k] = R[j];
                j++;
                k++;
            }
        }

        void sort(programer arr[], int l, int r) {
            if (l < r) {
                int m = (l + r) / 2;
                sort(arr, l, m);
                sort(arr, m + 1, r);
                merge(arr, l, m, r);
            }
        }
    }

    static class MergeSort2 {

        void merge(programer arr[], int l, int m, int r) {
            int n1 = m - l + 1;
            int n2 = r - m;
            programer L[] = new programer[n1];
            programer R[] = new programer[n2];
            for (int i = 0; i < n1; ++i) {
                L[i] = arr[l + i];
            }
            for (int j = 0; j < n2; ++j) {
                R[j] = arr[m + 1 + j];
            }
            int i = 0, j = 0;
            int k = l;
            while (i < n1 && j < n2) {
                if (L[i].r <= R[j].r) {
                    arr[k] = L[i];
                    i++;
                } else {
                    arr[k] = R[j];
                    j++;
                }
                k++;
            }
            while (i < n1) {
                arr[k] = L[i];
                i++;
                k++;
            }
            while (j < n2) {
                arr[k] = R[j];
                j++;
                k++;
            }
        }

        void sort(programer arr[], int l, int r) {
            if (l < r) {
                int m = (l + r) / 2;
                sort(arr, l, m);
                sort(arr, m + 1, r);
                merge(arr, l, m, r);
            }
        }
    }

    static class FastReader {

        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {

                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

    }
}
