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.
from fractions import gcd
# from datetime import date, timedelta
from heapq import*
import math
from collections import defaultdict, Counter, deque
from bisect import *
import itertools
import fractions
# import sys
# sys.setrecursionlimit(10 ** 7)
MOD = 10 ** 9 + 7
# input = sys.stdin.readline


def main():
    # n = int(input())
    # b = list(map(int, input().split()))
    # if n <= 2 or max(b) - min(b)> 4:
    #     print(0)
    #     exit()
    # sa = []
    # for i in range(n-1):
    #     sa.append(b[i] - b[i + 1])
    # print(sa)

    # # for i in range(n-2):
    # #     if sa[i] > sa[i + 1]:
    # #         sa[i] -= 1
    # #         sa[i + 1] += 1
    # #     elif sa[i] < sa[i + 1]:
    # #         sa[i] += 1
    # #         sa[i + 1] -= 1
    # # print(sa)
    # ans = float("inf")
    # for i in range(min(b), max(b) + 1):
    #     v = 0
    #     for j in range(n - 1):
    #         if abs(i - sa[j]) == 4:
    #             v = float("inf")
    #             break
    #         else:


    #     ans = min(ans , v)


    n, k = map(int, input().split())
    r = list(map(int, input().split()))
    d = defaultdict(int)
    rr = set()
    Coun = Counter(r)
    for i in range(n):
        d[r[i]] += 1
        rr.add(r[i])
    rr = sorted(list(rr))
    l = [0] * n
    cnt = 0
    c = defaultdict(int)
    for i in range(len(rr)):
        c[rr[i]] = cnt
        cnt += Coun[rr[i]]
    
        

    ans = [0] * n
    for i in range(n):
        ans[i] = c[r[i]]
    # print(ans)
    for i in range(k):
        x, y = map(int, input().split())
        if r[x - 1] > r[y - 1]:
            ans[x - 1] -= 1
        elif r[x - 1] < r[y - 1]:
            ans[y - 1] -= 1
    print(*ans)




if __name__ == '__main__':
    main()
