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.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

public class hacker49 {

	static class FastReader 
    { 
        BufferedReader br; 
        StringTokenizer st; 
  
        public FastReader() 
        { 
            br = new BufferedReader(new
                     InputStreamReader(System.in)); 
        } 
  
        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; 
        } 
    }
	static long[] x= {1,1,1,0,0,0,-1,-1,-1};
	static long[] y= {1,-1,0,-1,0,1,1,-1,0};
	public static void main(String[] args) {
		OutputStream outputStream =System.out;
	    PrintWriter out =new PrintWriter(outputStream);
		FastReader s=new FastReader();
	int n=s.nextInt();
	int k=s.nextInt();
	int[] f=new int[n];
	long[] a=new long[n];
	long[] b=new long[n];
	for(int i=0;i<n;i++) {
		a[i]=s.nextLong();
		b[i]=a[i];
	}
	sf(a);
	Arrays.sort(a);
	for(int i=0;i<k;i++) {
		int x=s.nextInt();
		int y=s.nextInt();
		x--;
		y--;
		if(b[x]>b[y]) {
			f[x]++;
		}else if(b[x]<b[y]) {
			f[y]++;
		}
	}
	for(int i=0;i<n;i++) {
		int g=lower_bound(a,b[i],n);
		if(g==-1) {
			out.print(0+" ");
		}
		else {
			out.print((g+1-f[i])+" ");
		}
	}
   out.close();
	}
	
static long m=-1;
static void sf(long[] arr){
        int n = arr.length;
        Random rnd = new Random();
        for(int i=0; i<n; ++i){
            long tmp = arr[i];
            int randomPos = i + rnd.nextInt(n-i);
            arr[i] = arr[randomPos];
            arr[randomPos] = tmp;
        }   
}
	
static HashMap<Integer,pair> e=new HashMap<>();
static ArrayList<Integer>[] f1=new ArrayList[200001];	
static PriorityQueue<pair> q=new PriorityQueue<>();	
static ArrayList<pair>[] f=new ArrayList[200001];
	static class pair implements Comparable<pair>{
		private int a;
		private int b;
		pair(int a,int b){
			this.a=a;
			this.b=b;
		}
		public int compareTo(pair o) {
			return Integer.compare(o.b, this.b);
		}
//		
		
	}
	static class node{
		private int a;
		private int b;
		node(int a,int b){
			this.a=a;
			this.b=b;
		}
	}
static int[] col=new int[200001];
static int[] subtree=new int[200001];
static int[] vis=new int[200001];
static int dfs(int node) {
		vis[node]=1;
		int c=0;
		for(int i=0;i<f[node].size();i++) {
			if(vis[f[node].get(i).a]==0) {
				c+=dfs(f[node].get(i).a);
			}
		}
		subtree[node]+=c;
		subtree[node]+=col[node];
		return subtree[node];
	}
	public static int upper_bound(long[] a ,long x,int n) {
		int l=-1;
		int r=n;
		while(r>l+1) {
			int mid=(l+r)/2;
			if(a[mid]<x) {
				l=mid;
			}else {
				r=mid;
			}
		}
		return r;
				
	}
	public static int lower_bound(long[] a ,long x,int n) {
		int l=-1;
		int r=n;
		while(r>l+1) {
			int mid=(l+r)/2;
			if(a[mid]<x) {
				l=mid;
			}else {
				r=mid;
			}
		}
		return l;
				
	}
	public static long lb(int n,long[] pre,long k,long a,long b,long x,long y) {
		long l=0;
		long r=n+1;
		while(l<r) {
			long mid=(l+r)/2;
			long sum=0;
			long gcd=GCD(a,b);
			long g=mid/(a*b/gcd);
			long a1=mid/a;
			long b1=mid/b;
			sum+=(pre[(int) g]*(x+y))/100;
			if(x>=y) {
				sum+=((pre[(int) a1]-pre[(int) g])*x)/100;
				sum+=(((pre[(int)(a1+b1-g)]-pre[(int)(a1)])*y))/100;
			}else {
				sum+=((pre[(int) b1]-pre[(int) g])*y)/100;
				sum+=(((pre[(int)(a1+b1-g)]-pre[(int)(b1)])*x))/100;
			}
			if(sum>=k) {
				r=mid;
			}else {
				l=mid+1;
			}
//			System.out.println(mid+" "+h);
		}
		
		return r;
				
	}
	
	
	
	public static long[] merge_sort(long[] A, int start, int end) {
		if (end > start) {
			int mid = (end + start) / 2;
			long[] v = merge_sort(A, start, mid);
			long[] o = merge_sort(A, mid + 1, end);
			return (merge(v, o));
		} else {
			long[] y = new long[1];
			y[0] = A[start];
			return y;
		}
	}
	public static long[] merge(long a[], long b[]) {
		
		long[] temp = new long[a.length + b.length];
		int m = a.length;
		int n = b.length;
		int i = 0;
		int j = 0;
		int c = 0;
		while (i < m && j < n) {
			if (a[i] < b[j]) {
				temp[c++] = a[i++];
			
			} else {
				temp[c++] = b[j++];
			}
		}
		while (i < m) {
			temp[c++] = a[i++];
		}
		while (j < n) {
			temp[c++] = b[j++];
		}
		return temp;
	}	
	public static int[] Create(int[] a,int n) {
		int[] b=new int[n+1];
		for(int i=1;i<=n;i++) {
			int j=i;
			int h=a[i];
			while(i<=n) {
				b[i]+=h;
				i=get_next(i);
			}
			i=j;
		}
		return b;
	}
public static int get_next(int a) {
	return a+(a&-a);
}
public static int get_parent(int a) {
	return a-(a&-a);
}
public static int query_1(int[] b,int index) {
	int sum=0;
	if(index<=0) {
		return 0;
	}
	while(index>0) {
		sum+=b[index];
		index=get_parent(index);
	}
	return sum;
}
public static int query(int[] b,int n,int l,int r) {
	int sum=0;
	sum+=query_1(b,r);
	sum-=query_1(b,l-1);
	return sum;
}
public static void update(int[] a,int[] b,int n,int index,int val) {
	int diff=val-a[index];
	a[index]+=diff;
	while(index<=n) {
		b[index]+=diff;
		index=get_next(index);
	}	
}
	
//	public static void Create(int[] a,pair[] segtree,int low,int high,int pos) {
//		if(low>high) {
//			return;
//		}
//		if(low==high) {
//			segtree[pos].b.add(a[low]);
//			return ;
//		}
//		int mid=(low+high)/2;
//		Create(a,segtree,low,mid,2*pos);
//		Create(a,segtree,mid+1,high,2*pos+1);
//		segtree[pos].b.addAll(segtree[2*pos].b);
//		segtree[pos].b.addAll(segtree[2*pos+1].b);
//	}
//	public static void update(pair[] segtree,int low,int high,int index,int pos,int val,int prev) {
//		if(index>high || index<low) {
//			return ;
//		}
//		if(low==high && low==index) {
//			segtree[pos].b.remove(prev);
//			segtree[pos].b.add(val);
//			return;
//		}
//			int mid=(high+low)/2;
//			 update(segtree,low,mid,index,2*pos,val,prev);
//			 update(segtree,mid+1,high,index,2*pos+1,val,prev);
//			 segtree[pos].b.clear();
//			  segtree[pos].b.addAll(segtree[2*pos].b);
//			  segtree[pos].b.addAll(segtree[2*pos+1].b);
//			  
//	}
//	public static pair query(pair[] segtree,int low,int high,int qlow,int qhigh ,int pos) {
//		if(low>=qlow && high<=qhigh) {
//			return segtree[pos];
//		}
//		if(qhigh<low || qlow>high) {
//			return new pair();
//		}
//		int mid=(low+high)/2;
//	  pair a1=query(segtree,low,mid,qlow,qhigh,2*pos);
//	  pair a2=query(segtree,mid+1,high,qlow,qhigh,2*pos+1);
//	  pair a3=new pair();
//	  a3.b.addAll(a1.b);
//	  a3.b.addAll(a2.b);
//	  return a3;
//	  
//	}
//	
//	public static int nextPowerOf2(int n) 
//	{ 
//	    n--; 
//	    n |= n >> 1; 
//	    n |= n >> 2; 
//	    n |= n >> 4; 
//	    n |= n >> 8; 
//	    n |= n >> 16; 
//	    n++;     
//	    return n; 
//	} 
//	
////	static class pair implements Comparable<pair>{
////		private int a;
////		private long b;
//////		private long c;
////		pair(int a,long b){
////			this.a=a;
////			this.b=b;
//////			this.c=c;
////		}
////		public int compareTo(pair o) {
//////		if(this.a!=o.a) {
//////			return Long.compare(this.a, o.a);
//////		}else {
////			return Long.compare(o.b,this.b);
//////		}
////		}
////	}
//	static class pair implements Comparable<pair>{
//		private int a;
//		private int b;
//		pair(int a,int b){
////			this.b=new HashSet<>();
//			this.a=a;
//			this.b=b;
//		}
//		public int compareTo(pair o) {
//			return Integer.compare(this.b, o.b);
//		}
//	}
	public static int lower_bound(ArrayList<Long> a ,int n,long x) {
		int l=0;
		int r=n;
		while(r>l+1) {
			int mid=(l+r)/2;
			if(a.get(mid)<=x) {
				l=mid;
			}else {
				r=mid;
			}
		}
		return l;		
	}
	public static int[] is_prime=new int[1000001];
	public static ArrayList<Long> primes=new ArrayList<>();
 	public static void sieve() {
		long maxN=1000000;
		for(long i=1;i<=maxN;i++) {
			is_prime[(int) i]=1;
		}
		is_prime[0]=0;
		is_prime[1]=0;
		for(long i=2;i*i<=maxN;i++) {
			if(is_prime[(int) i]==1) {
//				primes.add((int) i);
				for(long j=i*i;j<=maxN;j+=i) {
					is_prime[(int) j]=0;
				}
			}
		}
		for(long i=0;i<=maxN;i++) {
			if(is_prime[(int) i]==1) {
				primes.add(i);
			}
		}		
	}
//	public static pair[] merge_sort(pair[] A, int start, int end) {
//		if (end > start) {
//			int mid = (end + start) / 2;
//			pair[] v = merge_sort(A, start, mid);
//			pair[] o = merge_sort(A, mid + 1, end);
//			return (merge(v, o));
//		} else {
//			pair[] y = new pair[1];
//			y[0] = A[start];
//			return y;
//		}
//	}
//	public static pair[] merge(pair a[], pair b[]) {
//		pair[] temp = new pair[a.length + b.length];
//		int m = a.length;
//		int n = b.length;
//		int i = 0;
//		int j = 0;
//		int c = 0;
//		while (i < m && j < n) {
//			if (a[i].b >= b[j].b) {
//				temp[c++] = a[i++];
//			
//			} else {
//				temp[c++] = b[j++];
//			}
//		}
//		while (i < m) {
//			temp[c++] = a[i++];
//		}
//		while (j < n) {
//			temp[c++] = b[j++];
//		}
//		return temp;
//	}
	public static long im(long a) {
		return binary_exponentiation_1(a,mod-2)%mod;
	}
	public static long binary_exponentiation_1(long a,long n) {
		long res=1;
		while(n>0) {
			if(n%2!=0) {
				res=((res)%(mod) * (a)%(mod))%(mod);
				n--;
			}else {
				a=((a)%(mod) *(a)%(mod))%(mod);
				n/=2;
			}
		}
		return (res)%(mod);
		
	}

	public static double bn1(double a,double n) {
		double res=1;
		while(n>0) {
			if(n%2!=0) {
//				res=((res)%(1000000007) * (a)%(1000000007))%(1000000007);
				res=(res*a);
				n--;
			}else {
//				a=((a)%(1000000007) *(a)%(1000000007))%(1000000007);
				a=(a*a);
				n/=2;
			}
		}
		return (res);	
	}
	public static long bn(long a,long n) {
		long res=1;
		while(n>0) {
			if(n%2!=0) {
				res=res*a;
				n--;
			}else {
				a*=a;
				n/=2;
			}
		}
		return res;
		
	}
public static long[] fac=new long[300001];
public static void ff() {
		fac[0]=(long)1;
		fac[1]=(long)1;
		for(long i=2;i<=300000;i++) {
			fac[(int) i]=(fac[(int) (i-1)]*i)%(m);
		}
	}	
public static long mod=998244353;
public static long GCD(long a,long b) {
		if(b==(long)0) {
			return a;
		}
		return GCD(b , a%b);
	}
public static long c=0;	
}