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.util.*;
import java.io.*;

// Solution

public class Main 
{    
  public static void main (String[] argv) 
  {
	  new Main();
  } 
  
  int[] par;
  int[] sz;
  int n;
  int[] a;
  int[] decrease;
  Integer[] b;
  public Main() {
	  FastReader in = new FastReader(new BufferedReader(new InputStreamReader(System.in)));
	  //FastReader in = new FastReader(new BufferedReader(new FileReader("Main.in")));
      n = in.nextInt();
      int k = in.nextInt();
      a = new int[n];
      b = new Integer[n];
      decrease = new int[n];
      par = new int[n];
      sz = new int[n];
      for (int i = 0; i < n; i++) {
          a[i] = in.nextInt();
          par[i] = i;
          b[i] = a[i];
          sz[i] = 1;
      }
      
      Arrays.sort(b);
      for (int i = 0; i < k; i++) {
        int p = in.nextInt() - 1;
        int q = in.nextInt() - 1;
        if (a[p] > a[q]) decrease[p]++;
        else if (a[q] > a[p]) decrease[q]++;
      }          
      
      //Integer[][] groups = new Integer[n][];
      //int[] id = new int[n];
      /*
      for (int i = 0; i < n; i++) {
          int root = find(i);
          if (groups[root] == null) groups[root] = new Integer[sz[root]];
              
          groups[root][id[root]++] = a[i];
      }
      
      for (int i = 0; i < n; i++) {
          if (groups[i] != null && groups[i].length > 1) 
              Arrays.sort(groups[i]);
      }
      */
      StringBuilder sb = new StringBuilder();
      for (int i = 0; i < n; i++) {
          int root = find(i);
          int nMentee = binarySearchSmaller(b, a[i]) - decrease[i];
          sb.append(nMentee + " ");
      }
      System.out.println(sb);
  }
  
  private int binarySearchSmaller(Integer[] a, int val) {
      int lo = 0, hi = a.length - 1;
      
      while (lo <= hi) {
          int mid = (lo + hi) / 2;
          if (a[mid] >= val) hi = mid - 1;
          else lo = mid + 1;
      }
      return lo;
  }
  
  private void add(int p, int q) {
     int rp = find(p);
     int rq = find(q);
     
     if (rp == rq) return;     
      
     if (sz[rp] < sz[rq]) {
         par[rp] = rq;
         sz[rq] += sz[rp];
     }else {
         par[rq] = rp;
         sz[rp] += sz[rq];
     }
  }
  
  private int find(int p) {
      int root = p;
      while (par[root] != root) root = par[root];
      
      while (p!=root) {
          int t = par[p];
          par[p] = root;
          p = t;
      }
      
      return root;
  }
  
  static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;
 
        public FastReader(BufferedReader in)
        {            
            br = in;
        }
 
        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    String line = br.readLine();
                    if (line == null || line.length() == 0) return "";
                    st = new StringTokenizer(line);
                }
                catch (IOException  e)
                {
                    return "";
                    //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)
            {
                return "";
                //e.printStackTrace();
            }
            return str;
        }
    }
}