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.DataInputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.StreamTokenizer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Stack;
import java.util.StringTokenizer;
import static java.lang.Math.min;
import static java.lang.Math.max;
import static java.lang.Math.abs;



public class Main {
	private static Scanner scan;
	//private static PrintStream out;
	private static PrintWriter out = new PrintWriter(System.out);
    static StreamTokenizer in;
	
	public static void main (String ... args) throws IOException {
		in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
		scan = new Scanner(System.in);
		//out = new PrintStream(System.out);
	    int n = nextInt(); int k = nextInt();
	    int[] arr = new int[n];
	    person[] p = new person[n];
	    int[] res = new int[n];
	    
	    for (int i = 0; i < n; i++) {
	        arr[i] = nextInt();
	        
	    	p[i] = new person(arr[i], i);
	    }
	    int regr = 1;
	    int last = 0;
	    
	    //applied lambda caluclus
	    Arrays.sort(p, (a, b) -> {
	    	return Integer.compare(((person) a).iq, ((person) b).iq);
	    });
	    
	    
	    
	    for (int i = 0; i < n; i++) {
	        if (p[i].iq == last) regr++;
	        else {last = p[i].iq; regr = 1;}
	    	int x = i - regr + 1;
	        
	       
	        res[p[i].num] = x;
	    }
	    //out.println(Arrays.toString(res));
	    for (int i = 0; i < k; i++) {
	    	int a = -1 + nextInt();
	    	int b = -1 + nextInt();
	    	if (arr[a] > arr[b]) res[a]--;
	    	if (arr[b] > arr[a]) res[b]--;
	    }
	    
	    
	    for (int a : res) out.print(a + " ");
	    out.flush();
	
	}
	
	static class person {
		int iq;
		int num;
		public person (int a, int b) {
			iq = a;
			num = b;
		}
	}
	
	
	// algos
	// 1. prime(int n)          O(sqrt(n))
	// 2. eratoSieve(int n)     O(nloglog(n))
	/////////////////////////////////////////////////////////////////
	
	
	
	
	
	// returns (int -> boolean: prime(a))   complexity(O(sqrt(n))
	public static boolean isPrime (int a) {
		if (a == 2 || a == 3 || a == 5) return true;
		if (a % 2 == 0 || a % 3 == 0 || a % 5 == 0) return false;
		
		int sqrt = (int) Math.sqrt(a);
		for (int i = 7; i <= sqrt; i += 2) if (a % i == 0) return false;
		return true;
	}
	


	
	// get all primes in [2, maxValue - 1] in O(nloglog(n))
	public static ArrayList<Integer> eratoSieve (int maxValue) {
		boolean[] isPrime = new boolean[maxValue];
        Arrays.fill(isPrime, true);
        ArrayList<Integer> ret = new ArrayList<>();
        for (int value = 2; value < maxValue; ++value) {
            if (isPrime[value]) {
                ret.add(value);
                for (int i = 2 * value; i < maxValue; i += value) {
                    isPrime[i] = false;
                }
            }
        }
        return ret;
	}
	
	static int nextInt() throws IOException
	   {
	      in.nextToken();
	      return (int)in.nval;
	   }
}