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.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.StringTokenizer;

public class F {

	public static void main(String[] args) {
		FastScanner fs=new FastScanner();
		int n=fs.nextInt();
		int m=fs.nextInt();
		Programmer[] programmers=new Programmer[n];
		int[] skills=fs.readArray(n);
		compress(skills);
		int[] cs=new int[210_000];
		for (int i:skills) {
			cs[i]++;
		}
		int[] presums=new int[cs.length];
		for (int i=0; i<presums.length; i++)
			presums[i]=cs[i]+(i!=0?presums[i-1]:0);
		
		for (int i=0; i<n; i++)
			programmers[i]=new Programmer(skills[i]);
		for (int i=0; i<m; i++) {
			int first=fs.nextInt()-1;
			int second=fs.nextInt()-1;
			programmers[first].adj.add(programmers[second]);
			programmers[second].adj.add(programmers[first]);
		}
//		Arrays.sort(programmers);
		for (int i=0; i<n; i++) {
			programmers[i].indexOf=i;
		}
		
		for (Programmer p:programmers) {
			int total=p.skill==0?0:presums[p.skill-1];
			for (Programmer q:p.adj)
				if (q.skill<p.skill) total--;
			System.out.print(total+" ");
		}
	}
	
	static void compress(int[] a) {
		HashSet<Integer> set=new HashSet<>();
		for (int i:a)
			set.add(i);
		int[] clone=new int[set.size()];
		int index=0;
		for (int i:set)
			clone[index++]=i;
		Arrays.sort(clone);
		HashMap<Integer, Integer> compress=new HashMap<>();
		for (int i=0; i<clone.length; i++)
			compress.put(clone[i], i);
		for (int i=0; i<a.length; i++)
			a[i]=compress.get(a[i]);
	}
	
	static class Programmer implements Comparable<Programmer> {
		int skill;
		int indexOf;
		ArrayList<Programmer> adj=new ArrayList<>();
		public Programmer(int skill) {
			this.skill=skill;
		}

		public int compareTo(Programmer o) {
			return skill-o.skill;
		}
	}

	static 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 int nextInt() {
			return Integer.parseInt(next());
		}
		
		public int[] readArray(int n) {
			int[] a=new int[n];
			for (int i=0; i<n; i++)
				a[i]=nextInt();
			return a;
		}
		
		public long[] readLongArray(int n) {
			long[] a=new long[n];
			for (int i=0; i<n; i++)
				a[i]=nextLong();
			return a;
		}
		
		public long nextLong() {
			return Long.parseLong(next());
		}
		
	}
	
}
