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.*;
    import java.lang.reflect.Array;
    import java.util.*;

    public class Main {
        public static void main(String[] args) throws IOException {
            FastReader scan = new FastReader();
            //PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("taming.out")));
            PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
            Task solver = new Task();
            //int t = scan.nextInt();
            int t = 1;
            for(int i = 1; i <= t; i++) solver.solve(i, scan, out);
            out.close();
        }
        static class Task {
            public void solve(int testNumber, FastReader sc, PrintWriter pw) {
                int n =sc.nextInt();
                int m = sc.nextInt();
                int[] arr = new int[n];
                int[] arr2 = new int[n];
                for(int i=0;i<n;i++){
                    arr[i]=sc.nextInt();
                    arr2[i]=arr[i];
                }
                shuffle(arr);
                Arrays.sort(arr);
                HashMap<Integer, Integer> hm = new HashMap<>();
                for(int i=n-1;i>=0;i--){
                    hm.put(arr[i],i);
                }
                int[] ans = new int[n+1];
                for(int i=0;i<n;i++){
                    ans[i+1]=hm.get(arr2[i]);
                }
                //pw.println(Arrays.toString(ans));
                for(int i=0;i<m;i++){
                    int x = sc.nextInt();
                    int y = sc.nextInt();
                    int t = hm.get(arr2[x-1]);
                    int s = hm.get(arr2[y-1]);
                    if(t>s){
                        ans[x]--;
                    }
                    if(s>t){
                        ans[y]--;
                    }
                }
                for(int i=1;i<=n;i++){
                    pw.print(ans[i]+" ");
                }
                pw.println();
            }
        }

        static class bit {
            int n;
            int[] bit;
            public bit(int n) {
                this.n=n;
                bit=new int[n+1];
            }
            void add(int ind, int c) {
                for(; ind<n;ind|=(ind+1)) {
                    bit[ind]+=c;
                }
            }
            int sum(int r) {
                int out =0;
                for(;r>=0;r=(r&(r+1))-1) {
                    out+=bit[r];
                }
                return out;
            }
            int sum(int r, int l) {
                return sum(r)-sum(l-1);
            }
        }
        static class tup implements Comparable<tup> {
            int a, b;

            tup() {
            }

            ;



            tup(int a, int b) {
                this.a = a;
                this.b = b;
            }

            @Override
            public int compareTo(tup o2) {
                return a==o2.a?Integer.compare(o2.b,b):Integer.compare(o2.a, a);
            }
        }
        static void shuffle(long[] a) {
            Random get = new Random();
            for (int i = 0; i < a.length; i++) {
                int r = get.nextInt(a.length);
                long temp = a[i];
                a[i] = a[r];
                a[r] = temp;
            }
        }
        static void shuffle(int[] a) {
            Random get = new Random();
            for (int i = 0; i < a.length; i++) {
                int r = get.nextInt(a.length);
                int temp = a[i];
                a[i] = a[r];
                a[r] = temp;
            }
        }
        static class FastReader {
            BufferedReader br;
            StringTokenizer st;

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

            public FastReader(String s) throws FileNotFoundException {
                br = new BufferedReader(new FileReader(new File(s)));
            }

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

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

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

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

            String nextLine() {
                String str = "";
                try {
                    str = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return str;
            }
        }

    }