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.
// This template code suggested by KT BYTE Computer Science Academy
//   for use in reading and writing files for USACO problems.

// https://content.ktbyte.com/problem.java

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

public class Mentors {

    static StreamTokenizer in;

    static int nextInt() throws IOException {
        in.nextToken();
        return (int) in.nval;
    }

    public static void main(String[] args) throws Exception {
        in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

        int n = nextInt();
        int k = nextInt();

        Programmer[] programmers = new Programmer[n];

        for (int i = 0; i < n; i++) {
            int skill = nextInt();

            programmers[i] = new Programmer(i, skill);
        }

        int[] subs = new int[n];

        for (int i = 0; i < k; i++) {
            int p1 = nextInt() - 1;
            int p2 = nextInt() - 1;

            // we need to add one with the greater skill

            if (programmers[p1].skill > programmers[p2].skill) {
                subs[p1]++;
            }

            else if (programmers[p1].skill < programmers[p2].skill) {
                subs[p2]++;
            }
        }

        Arrays.sort(programmers);

        int[] results = new int[n];

        for (int i = 0; i < n; i++) {
            int id = programmers[i].id;
            int skill = programmers[i].skill;
            int index = findFirstOccurrence(programmers, skill);
            int num = index - subs[id];

            results[id] = num;
        }

        for (int i = 0; i < n; i++) {
            out.print(results[i]);

            if (i != n-1) {
                out.print(" ");
            }
        }

        out.close();
    }

    static class Programmer implements Comparable<Programmer> {
        int skill, id;

        Programmer(int id, int skill) {
            this.id = id;
            this.skill = skill;
        }

        @Override
        public int compareTo(Programmer o) {
            if (this.skill == o.skill) {
                return this.id - o.id;
            }
            return this.skill - o.skill;
        }
    }

    public static int findFirstOccurrence(Programmer[] programmers, int x)
    {
        // search space is A[left..right]
        int left = 0;
        int right = programmers.length - 1;

        // initialize the result by -1
        int result = -1;

        // iterate till search space contains at-least one element
        while (left <= right)
        {
            // find the mid value in the search space and
            // compares it with key value
            int mid = (left + right) / 2;

            // if key is found, update the result and
            // go on searching towards right (higher indices)
            if (x == programmers[mid].skill) {
                result = mid;
                right = mid - 1;
            }

            // if key is less than the mid element, discard right half
            else if (x < programmers[mid].skill) {
                right = mid - 1;
            }

            // if key is more than the mid element, discard left half
            else {
                left = mid + 1;
            }
        }

        // return the leftmost index or -1 if the element is not found
        return result;
    }
}


