Swaps in Permutation

You are given a permutation of the numbers 1, 2, ..., n and m pairs of positions (aj, bj).

At each step you can choose a pair from the given positions and swap the numbers in that positions. What is the lexicographically maximal permutation one can get?

Let p and q be two permutations of the numbers 1, 2, ..., n. p is lexicographically smaller than the q if a number 1 ≤ i ≤ n exists, sopk = qk for 1 ≤ k < i and pi < qi.

Input

The first line contains two integers n and m (1 ≤ n, m ≤ 106) — the length of the permutation p and the number of pairs of positions.

The second line contains n distinct integers pi (1 ≤ pi ≤ n) — the elements of the permutation p.

Each of the last m lines contains two integers (aj, bj) (1 ≤ aj, bj ≤ n) — the pairs of positions to swap. Note that you are given apositions, not the values to swap.

Output

Print the only line with n distinct integers p'i (1 ≤ p'i ≤ n) — the lexicographically maximal permutation one can get.

Example

input

9 6
1 2 3 4 5 6 7 8 9
1 4
4 7
2 5
5 8
3 6
6 9

output

7 8 9 4 5 6 1 2 3

给你n个数
下m行，每行两个数，这两个位置的数可以无限次的交换
让你输出一个字典序最大的排序

因为1,4可以无限次的交换，4,7也可以无限次的交换，所以1,7也可以交换，这样可以想到用并查集把他们划为一类，

然后再用优先队列把同一个集合的存进去，这样输出的时候就能保证大的在前面。

#include<queue>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>

using namespace std;

int f[1000010];
int a[1000010];
int find(int x)
{
    if(x == f[x])
        return f[x];
    else
        return f[x] = find(f[x]);
}
priority_queue<int> q[1000010];

int main(void)
{
    int n,m,i;
    while(scanf("%d%d",&n,&m)==2)
    {
        for(i=0;i<=n;i++)
            f[i] = i;
        for(i=1;i<=n;i++)
            scanf("%d",&a[i]);
        for(i=1;i<=m;i++)
        {
            int t1,t2;
            scanf("%d%d",&t1,&t2);
            int x = find(t1);
            int y = find(t2);
            if(x != y)
                f[x] = y;
        }
        for(i=1;i<=n;i++)
            q[f[find(i)]].push(a[i]);
        for(i=1;i<=n;i++)
        {
            printf("%d ",q[f[i]].top());
            q[f[i]].pop();
        }
    }
}