Nezzar designs a brand new game "Hidden Permutations" and shares it with his best friend, Nanako.

At the beginning of the game, Nanako and Nezzar both know integers n and m. The game goes in the following way:

  * Firstly, Nezzar hides two permutations p_1,p_2,…,p_n and q_1,q_2,…,q_n of integers from 1 to n, and Nanako secretly selects m unordered pairs (l_1,r_1),(l_2,r_2),…,(l_m,r_m); 
  * After that, Nanako sends his chosen pairs to Nezzar; 
  * On receiving those m unordered pairs, Nezzar checks if there exists 1 ≤ i ≤ m, such that (p_{l_i}-p_{r_i}) and (q_{l_i}-q_{r_i}) have different signs. If so, Nezzar instantly loses the game and gets a score of -1. Otherwise, the score Nezzar gets is equal to the number of indices 1 ≤ i ≤ n such that p_i ≠ q_i. 



However, Nezzar accidentally knows Nanako's unordered pairs and decides to take advantage of them. Please help Nezzar find out two permutations p and q such that the score is maximized.

Input

The first line contains a single integer t (1 ≤ t ≤ 5 ⋅ 10^5) — the number of test cases.

The first line of each test case contains two integers n,m (1 ≤ n ≤ 5 ⋅ 10^5, 0 ≤ m ≤ min((n(n-1))/(2),5 ⋅ 10^5)). 

Then m lines follow, i-th of them contains two integers l_i,r_i (1 ≤ l_i,r_i ≤ n, l_i ≠ r_i), describing the i-th unordered pair Nanako chooses. It is guaranteed that all m unordered pairs are distinct.

It is guaranteed that the sum of n for all test cases does not exceed 5 ⋅ 10^5, and the sum of m for all test cases does not exceed 5⋅ 10^5.

Output

For each test case, print two permutations p_1,p_2,…,p_n and q_1,q_2,…,q_n such that the score Nezzar gets is maximized.

Example

Input


3
4 2
1 2
3 4
6 4
1 2
1 3
3 5
3 6
2 1
1 2


Output


1 2 3 4
3 4 1 2
2 3 4 1 6 5
1 4 3 2 5 6
1 2
1 2

Note

For first test case, for each pair given by Nanako:

  * for the first pair (1,2): p_1 - p_2 = 1 - 2 = -1, q_1 - q_2 = 3 - 4 = -1, they have the same sign; 
  * for the second pair (3,4): p_3 - p_4 = 3 - 4 = -1, q_3 - q_4 = 1 - 2 = -1, they have the same sign. 



As Nezzar does not lose instantly, Nezzar gains the score of 4 as p_i ≠ q_i for all 1 ≤ i ≤ 4. Obviously, it is the maximum possible score Nezzar can get.
#include <bits/stdc++.h>
using namespace std;

set<int> AdjList[500005];
vector<int> AdjList2[500005];
int degree[500005];

set<int> componentList[500005];
int component[500005];
int centre[500005];

int p[500005];
int q[500005];

bool visited[500005];

int main(){
    int t;
    scanf("%d", &t);

    while(t --){
        int n, m;
        scanf("%d%d", &n, &m);

        for(int i = 1; i <= n; i ++){
            AdjList[i] = set<int>();
            AdjList2[i] = vector<int>();
            degree[i] = 0;
            componentList[i] = set<int>();
            component[i] = -1;
            centre[i] = -1;
            p[i] = -1;
            q[i] = -1;
            visited[i] = false;
        }

        for(int i = 0; i < m; i ++){
            int u, v;
            scanf("%d%d", &u, &v);
            AdjList[u].insert(v);
            AdjList[v].insert(u);
            degree[u] ++;
            degree[v] ++;
        }

        set<int> rem;
        int pcnt = 1;
        int qcnt = 1;
        for(int i = 1; i <= n; i ++){
            if(degree[i] == n-1){
                p[i] = pcnt ++;
                q[i] = qcnt ++;
            }else{
                rem.insert(i);
            }
        }

        while(!rem.empty()){
            queue<int> q;
            int u = *rem.begin();
            q.push(u);
            rem.erase(u);
            while(!q.empty()){
                int u = q.front(); q.pop();
                //printf("u=%d\n", u);
                vector<int> toErase;
                for(int x: rem){
                    if(AdjList[u].find(x) == AdjList[u].end()){
                        AdjList2[u].push_back(x);
                        AdjList2[x].push_back(u);
                        //printf("new edge: %d to %d\n", u, x);
                        toErase.push_back(x);
                    }
                }

                for(int x: toErase){
                    //assert(rem.find(x) != rem.end());
                    rem.erase(x);
                    q.push(x);
                }
            }
        }

        int componentCnt = 1;
        for(int i = 1; i <= n; i ++){
            if(!visited[i] && degree[i] < n-1){
                visited[i] = true;
                queue<int> q;
                q.push(i);
                while(!q.empty()){
                    int u = q.front(); q.pop();
                    //printf("u2=%d\n", u);
                    if(component[u] == -1){
                        int cntUnvisited = 0;
                        for(int v: AdjList2[u]){
                            if(!visited[v]){
                                cntUnvisited ++;
                            }
                        }

                        if(cntUnvisited == 0){
                            assert(!AdjList2[u].empty());
                            int v = AdjList2[u][0];
                            int k = component[v];
                            if(componentList[k].size() == 2 || v == centre[k]){
                                componentList[k].insert(u);
                                centre[k] = v;
                                //printf("size=2: u=%d; v=%d; centre[%d]=%d; component[v]=%d\n", u, v, k, v, component[v]);
                                component[u] = k;
                            }else{
                                component[u] = componentCnt;
                                centre[componentCnt] = u;
                                //printf("size>2: u=%d; v=%d; centre[%d]=%d\n", u, v, componentCnt, u);
                                componentList[componentCnt].insert(u);

                                assert(v != centre[k]);
                                componentList[k].erase(v);
                                componentList[componentCnt].insert(v);
                                component[v] = componentCnt;
                                componentCnt ++;
                            }
                        }else{
                            component[u] = componentCnt;
                            centre[componentCnt] = u;
                            componentList[componentCnt].insert(u);
                            for(int v: AdjList2[u]){
                                if(!visited[v]){
                                    visited[v] = true;
                                    component[v] = componentCnt;
                                    componentList[componentCnt].insert(v);
                                    q.push(v);
                                }
                            }
                            componentCnt ++;
                        }
                        assert(component[u] != -1);
                    }
                }
            }
        }

        for(int i = 1; i < componentCnt; i ++){
            p[centre[i]] = pcnt ++;
            if(component[centre[i]] != i){
                //printf("component[centre[%d]] = %d, but supposed to be %d; centre[%d] = %d\n", i, component[centre[i]], i, i, centre[i]);
            }
            //printf("p[%d]=%d\n", centre[i], pcnt-1);
            for(int j: componentList[i]){
                if(component[j] != i){
                    //printf("j=%d does not satisfy component[j]==%d\n", j, i);
                }
                if(centre[i] != j){
                    p[j] = pcnt ++;
                    //printf("p[%d]=%d\n", j, pcnt-1);
                }
            }

            for(int j: componentList[i]){
                if(centre[i] != j){
                    q[j] = qcnt ++;
                    //printf("q[%d]=%d\n", j, qcnt-1);
                }
            }
            q[centre[i]] = qcnt ++;
            //printf("q[%d]=%d\n", centre[i], qcnt-1);
        }
        //assert(pcnt == n+1 && qcnt == n+1);

        for(int i = 1; i <= n; i ++){
            printf("%d ", p[i]);
        }
        printf("\n");
        for(int i = 1; i <= n; i ++){
            printf("%d ", q[i]);
        }
        printf("\n");
    }

    return 0;
}
