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.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.math.BigInteger;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Stack;
import java.util.stream.IntStream;
import java.util.stream.Stream;
 

public class Main {

    
   
  
    public static void main(String[] args) throws IOException, Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        int[] _c = nextIntArray(br);
        int n = _c[0];
        int k = _c[1];
        int[]a = nextIntArray(br);
        int[] p = new int[n];
        Integer[] st = new Integer[n];
        for(int i=0;i<n;i++) st[i]=a[i];
        Arrays.sort(st);
        for(int i=0;i<k;i++) {
            _c = nextIntArray(br);
            int x = _c[0];
            int y = _c[1];
            x--;y--;
            if(a[x] < a[y]) p[y]++;
            else if(a[x] > a[y]) p[x]++;
        }
        int[] out = solve(p, st, a);
        for(int t : out) {
            bw.append(t+" ");
        }
        bw.append("\n");
        bw.close();
        
    }
    
    private static int[] solve(int[] p, Integer[] st, int[] a) {
        
        int n= a.length;
        int[] out = new int[n];
        
        for(int i=0;i<n;i++) {
            int val=a[i];
            int lo=0;
            int hi=n-1;
            if(st[0] >= val) {
                out[i]=0;
                //System.out.println("out for "+i+" is "+0);
                continue;
            }
            while(lo < hi) {
                int mid = lo+(hi-lo+1)/2;
                if(st[mid] < val) {
                    lo=mid;
                }
                else hi=mid-1;
            }
            
            out[i]=(lo+1)-p[i];
            //System.out.println("out for "+i+" is "+out[i]);
        }
        return out;
    }

   
    private static int[] nextIntArray(BufferedReader br) throws IOException{
        String[] in=br.readLine().split(" ");
        int[] a = new int[in.length];
        for(int i=0;i<a.length;i++) a[i] = Integer.parseInt(in[i]);
        return a;
    }
    private static long[] nextLongArray(BufferedReader br) throws IOException{
        String[] in=br.readLine().split(" ");
        long[] a = new long[in.length];
        for(int i=0;i<a.length;i++) a[i] = Long.parseLong(in[i]);
        return a;
    }
    private static String stringifyIntArray(int[] t) {
        StringBuilder sb = new StringBuilder();
        for(Integer tt : t) {
            sb.append(tt);
        }
        return sb.toString();
    }
    
   
} 