Problem: Write a program which manipulates a disjoint set S = {S1, S2, . . . , Sk}.

First of all, the program should read an integer n, then make a disjoint set where each element consists of 0, 1, ... n−1 respectively.

Next, the program should read an integer q and manipulate the set for q queries. There are two kinds of queries for different operations:

* unite(x, y): unites sets that contain x and y, say Sx and Sy, into a new set.
* same(x, y): determine whether x and y are in the same set.

Constraints

* 1 ≤ n ≤ 10000
* 1 ≤ q ≤ 100000
* x ≠ y

Input


n q
com1 x1 y1
com2 x2 y2
...
comq xq yq


In the first line, n and q are given. Then, q queries are given where com represents the type of queries. '0' denotes unite and '1' denotes same operation.

Output

For each same operation, print 1 if x and y are in the same set, otherwise 0, in a line.

Example

Input

5 12
0 1 4
0 2 3
1 1 2
1 3 4
1 1 4
1 3 2
0 1 3
1 2 4
1 3 0
0 0 4
1 0 2
1 3 0


Output

0
0
1
1
1
0
1
1

Solution (in JAVA):

Solution:
import java.util.*;
import java.io.*;

class Node{
    int id;
    Node parent=this;
    int rank;

    public Node(){}
    public Node(int id){
        this.id=id;
    }

    public Node findRoot(){
        Node root =this;
        while(true){
            if(root==root.parent){
                break;
            }
            root=root.parent;
        }
        return root;
    }
}

// class Tree{
//     int rank;
//     Node root;

//     public Tree(int rank,Node root){
//         this.rank=rank;
//         this.root=root;
//     }
// }

public class Main{
    static int INFTY = Integer.MAX_VALUE;
        
    public static void main (String args[]){
        //初期処理
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int q=sc.nextInt();
    //    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    //    try{
    //        int n = Integer.parseInt(br.readLine());
        // } catch (IOException e) {
        //     e.printStackTrace();
        // }
        Node[] nodes = new Node[n];
       // Tree[] tree = new Tree[n];

        for(int i=0;i<n;i++){
            nodes[i]=new Node(i);
         //   tree[i]=new Tree(1,nodes[i]);
        }


        for(int i=0;i<q;i++){
            int command =sc.nextInt();
            int u1=sc.nextInt();
            int u2=sc.nextInt();

            if(command==0){
                unite(nodes[u1],nodes[u2]);
            }
            if(command==1){
                find(nodes[u1],nodes[u2]);
            }
        }
        
    }

    public static void unite(Node u1,Node u2){
        Node root1=u1.findRoot();
        Node root2=u2.findRoot();
        if(root1==root2){
            return;
        }
        if(root1.rank>root2.rank){
            root2.parent=root1;
        }else if(root1.rank<root2.rank){
            root1.parent=root2;
        }else{
            root2.parent=root1;
            root1.rank++;
        }
    }

    public static void find(Node u1,Node u2){
        Node root1=u1.findRoot();
        Node root2=u2.findRoot();
        if(root1==root2){
            System.out.println(1);;
        }else{
            System.out.println(0);
        }
    }
    
}