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.
//package Practice_Problems;
//package Template;

import java.util.*;
import java.io.*;

public class Mentors {
	static final int mod = (int) 1e9 + 7;
	static final int inf = (int) 1e9;
	static final long INF = (long) 1e18;static int n,k;
	static HashMap<Integer, Integer> map = new HashMap<>();
	static int ans[]=new int[(int)2e5+1];
	static int arr[]=new int[ans.length];
	static int copy[]=new int[ans.length];
	public static void main(String[] args) throws IOException
	{
		FastScanner fs=new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		n=fs.nextInt();k=fs.nextInt();
		for(int i=1;i<=n;i++) {arr[i]=fs.nextInt();copy[i]=arr[i];}
		sort(arr);
		for(int i=1;i<=k;i++)
		{
			int u=fs.nextInt();int v=fs.nextInt();
			int val=copy[u];int val2=copy[v];
			if(val==val2)continue;
			else if(val<val2)
			{
				map.put(v,map.getOrDefault(v,0)+1);
			}
			else
			{
				map.put(u,map.getOrDefault(u,0)+1);
			}
		}
		for(int i=1;i<=n;i++)
		{
			int ans=bin_search(copy[i]);
			out.print((Math.max(0,ans-map.getOrDefault(i,0)))+" ");
			
		}
		out.close();
	}
	public static int bin_search(int key)
	{
		int left=1,right=n;int idx=0;
		while(left<=right)
		{
			int mid=(left+right)/2;
			if(arr[mid]<key) {left=mid+1;idx=mid;}
			else right=mid-1;
		}
		return idx;
	}
	public static void sort(int arr[])
	{
		ArrayList<Integer> list = new ArrayList<Integer>();
		for(int i=1;i<=n;i++)list.add(arr[i]);
		Collections.sort(list);
		for(int i=0;i<list.size();i++)arr[i+1]=list.get(i);
	}
	// returns the index of the smallest element in the array that is greater than
	// or equal to
	// the given element.
	public static int lower_bound(int arr[], int key) {
		int index = inf, num = 0;
		int left = 0, right = arr.length - 1;
		while (left <= right) {
			int mid = left + (right - left) / 2;
			if (arr[mid] >= key) {
				index = mid;
				num = arr[mid];
				right = mid - 1;
			} else
				left = mid + 1;
		}
		return index == inf ? arr.length : index;
	}

	// returns the index of the smallest element in the array that is less than or
	// equal to
	// the given element.
	public static int upper_bound(int arr[], int key) {
		int index = inf, num = 0;
		int left = 0, right = arr.length - 1;
		while (left <= right) {
			int mid = left + (right - left) / 2;
			if (arr[mid] <= key) {
				index = mid;
				num = arr[mid];
				left = mid + 1;
			} else
				right = mid - 1;
		}
		return index == inf ? arr.length : index;
	}
}

class FastScanner {
	BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	StringTokenizer st = new StringTokenizer("");

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

	}

	public String nextLine() throws IOException {
		return br.readLine();
	}

	int[] sort(int arr[]) {
		ArrayList<Integer> list = new ArrayList<Integer>();
		for (int i : arr)
			list.add(i);
		Collections.sort(list);
		for (int i = 0; i < arr.length; i++) {
			arr[i] = list.get(i);
		}
		return arr;
	}

	char[] charsort(char arr[]) {
		ArrayList<Character> list = new ArrayList<>();
		for (char c : arr)
			list.add(c);
		Collections.sort(list);
		for (int i = 0; i < list.size(); i++) {
			arr[i] = list.get(i);
		}
		return arr;
	}

	long[] longsort(long arr[]) {
		ArrayList<Long> list = new ArrayList<Long>();
		for (long i : arr)
			list.add(i);
		Collections.sort(list);
		for (int i = 0; i < arr.length; i++) {
			arr[i] = list.get(i);
		}
		return arr;
	}

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

	public int[] readArray(int n) {
		int[] arr = new int[n];
		for (int i = 0; i < n; i++)
			arr[i] = nextInt();
		return arr;
	}

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

	public long[] longreadArray(int n) {
		long[] a = new long[n];
		for (int i = 0; i < n; i++)
			a[i] = nextLong();
		return a;
	}
}
