import sys

input = sys.stdin.readline



def I(): return int(eval(input()))

def MI(): return list(map(int, input().split()))

def LI(): return list(map(int, input().split()))



def main():

    ################

    class UnionFind():

        """

        parents : 親要素(findしない場合は根ではないことの注意)，根の場合は"-(要素数）"

        find(x):要素xの属するグループの根を返す

        size(x):要素xの属するグループの要素数を返す

        same(x,y):x,yが同じグループに属しているか返す

        重いかも！　　members(x):要素xが属するグループに属する要素をリストで返す

        roots():全ての根の要素を返す

        group_count():グループの数を返す

        重いかも！　all_group_members():{根要素：[そのグループに含まれる要素のリスト]}の辞書を返す

        """

        def __init__(self, n):

            self.n = n

            self.parents = [-1] * n



        def find(self, x):

            #根を探す&つなぎかえる

            if self.parents[x] < 0:

                return x

            else:

                self.parents[x] = self.find(self.parents[x])

                return self.parents[x]



        def union(self, x, y):

            x = self.find(x)

            y = self.find(y)



            if x == y:

                return



            if self.parents[x] > self.parents[y]:

                x, y = y, x



            self.parents[x] += self.parents[y]

            self.parents[y] = x



        def size(self, x):

            return -self.parents[self.find(x)]



        def same(self, x, y):

            return self.find(x) == self.find(y)



        def members(self, x):

            root = self.find(x)

            return [i for i in range(self.n) if self.find(i) == root]



        def roots(self):

            return [i for i, x in enumerate(self.parents) if x < 0]



        def group_count(self):

            return len(self.roots())



        def all_group_members(self):

            return {r: self.members(r) for r in self.roots()}



        def __str__(self):

            return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())



    ################

    

    N,Q=MI()

    uf=UnionFind(N)

    for _ in range(Q):

        t,u,v=MI()

        if t==0:

            uf.union(u,v)

        else:

            ans=0

            if uf.same(u,v):

                ans=1

            print(ans)







main()

import sys

input = sys.stdin.readline



def I(): return int(eval(input()))

def MI(): return list(map(int, input().split()))

def LI(): return list(map(int, input().split()))



def main():

    ################

    class UnionFind:

        def __init__(self, N: int):

            """

            N:要素数

            root:各要素の親要素の番号を格納するリスト.

                ただし, root[x] < 0 ならその頂点が根で-root[x]が木の要素数.

            rank:ランク

            """

            self.N = N

            self.root = [-1] * N

            self.rank = [0] * N

    

        def __repr__(self):

            return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

    

        def find(self, x: int) -> int:

            """頂点xの根を見つける"""

            if self.root[x] < 0:

                return x

            else:

                while self.root[x] >= 0:

                    x = self.root[x]

                return x

    

        def union(self, x: int, y: int) -> int:

            """x,yが属する木をunion"""

            # 根を比較する

            # すでに同じ木に属していた場合は何もしない.

            # 違う木に属していた場合はrankを見てくっつける方を決める.

            # rankが同じ時はrankを1増やす

            x = self.find(x)

            y = self.find(y)

            if x == y:

                return

            elif self.rank[x] > self.rank[y]:

                self.root[x] += self.root[y]

                self.root[y] = x

            else:

                self.root[y] += self.root[x]

                self.root[x] = y

                if self.rank[x] == self.rank[y]:

                    self.rank[y] += 1

    

        def same(self, x: int, y: int) -> bool:

            """xとyが同じグループに属するかどうか"""

            return self.find(x) == self.find(y)

    

        def count(self, x):

            """頂点xが属する木のサイズを返す"""

            return - self.root[self.find(x)]

    

        def members(self, x):

            """xが属する木の要素を列挙"""

            _root = self.find(x)

            return [i for i in range(self.N) if self.find == _root]

    

        def roots(self):

            """森の根を列挙"""

            return [i for i, x in enumerate(self.root) if x < 0]

    

        def group_count(self):

            """連結成分の数"""

            return len(self.roots())

    

        def all_group_members(self):

            """{ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す"""

            return {r: self.members(r) for r in self.roots()}

    ################

    

    N,Q=MI()

    uf=UnionFind(N)

    for _ in range(Q):

        t,u,v=MI()

        if t==0:

            uf.union(u,v)

        else:

            ans=0

            if uf.same(u,v):

                ans=1

            print(ans)







main()

import sys

input = sys.stdin.readline


def I():
    return int(eval(input()))


def MI():
    return list(map(int, input().split()))


def LI():
    return list(map(int, input().split()))


def main():
    ################
    class UnionFind:
        """
        parents : 親要素(findしない場合は根ではないことの注意)，根の場合は"-(要素数）"
        find(x):要素xの属するグループの根を返す
        size(x):要素xの属するグループの要素数を返す
        same(x,y):x,yが同じグループに属しているか返す
        重いかも！　　members(x):要素xが属するグループに属する要素をリストで返す
        roots():全ての根の要素を返す
        group_count():グループの数を返す
        重いかも！　all_group_members():{根要素：[そのグループに含まれる要素のリスト]}の辞書を返す
        """

        def __init__(self, n):
            self.n = n
            self.parents = [-1] * n

        def find(self, x):
            # 根を探す&つなぎかえる
            if self.parents[x] < 0:
                return x
            else:
                self.parents[x] = self.find(self.parents[x])
                return self.parents[x]

        def union(self, x, y):
            x = self.find(x)
            y = self.find(y)
            if x == y:
                return
            if self.parents[x] > self.parents[y]:
                x, y = y, x
            self.parents[x] += self.parents[y]
            self.parents[y] = x

        def size(self, x):
            return -self.parents[self.find(x)]

        def same(self, x, y):
            return self.find(x) == self.find(y)

        def members(self, x):
            root = self.find(x)
            return [i for i in range(self.n) if self.find(i) == root]

        def roots(self):
            return [i for i, x in enumerate(self.parents) if x < 0]

        def group_count(self):
            return len(self.roots())

        def all_group_members(self):
            return {r: self.members(r) for r in self.roots()}

        def __str__(self):
            return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots())

    ################
    N, Q = MI()
    uf = UnionFind(N)
    for _ in range(Q):
        t, u, v = MI()
        if t == 0:
            uf.union(u, v)
        else:
            ans = 0
            if uf.same(u, v):
                ans = 1
            print(ans)


main()

import sys

input = sys.stdin.readline


def I():
    return int(eval(input()))


def MI():
    return list(map(int, input().split()))


def LI():
    return list(map(int, input().split()))


def main():
    ################
    class UnionFind:
        def __init__(self, N: int):
            """
            N:要素数
            root:各要素の親要素の番号を格納するリスト.
                ただし, root[x] < 0 ならその頂点が根で-root[x]が木の要素数.
            rank:ランク
            """
            self.N = N
            self.root = [-1] * N
            self.rank = [0] * N

        def __repr__(self):
            return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots())

        def find(self, x: int) -> int:
            """頂点xの根を見つける"""
            if self.root[x] < 0:
                return x
            else:
                while self.root[x] >= 0:
                    x = self.root[x]
                return x

        def union(self, x: int, y: int) -> int:
            """x,yが属する木をunion"""
            # 根を比較する
            # すでに同じ木に属していた場合は何もしない.
            # 違う木に属していた場合はrankを見てくっつける方を決める.
            # rankが同じ時はrankを1増やす
            x = self.find(x)
            y = self.find(y)
            if x == y:
                return
            elif self.rank[x] > self.rank[y]:
                self.root[x] += self.root[y]
                self.root[y] = x
            else:
                self.root[y] += self.root[x]
                self.root[x] = y
                if self.rank[x] == self.rank[y]:
                    self.rank[y] += 1

        def same(self, x: int, y: int) -> bool:
            """xとyが同じグループに属するかどうか"""
            return self.find(x) == self.find(y)

        def count(self, x):
            """頂点xが属する木のサイズを返す"""
            return -self.root[self.find(x)]

        def members(self, x):
            """xが属する木の要素を列挙"""
            _root = self.find(x)
            return [i for i in range(self.N) if self.find == _root]

        def roots(self):
            """森の根を列挙"""
            return [i for i, x in enumerate(self.root) if x < 0]

        def group_count(self):
            """連結成分の数"""
            return len(self.roots())

        def all_group_members(self):
            """{ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す"""
            return {r: self.members(r) for r in self.roots()}

    ################
    N, Q = MI()
    uf = UnionFind(N)
    for _ in range(Q):
        t, u, v = MI()
        if t == 0:
            uf.union(u, v)
        else:
            ans = 0
            if uf.same(u, v):
                ans = 1
            print(ans)


main()

-        """ -        parents : 親要素(findしない場合は根ではないことの注意)，根の場合は"-(要素数）" -        find(x):要素xの属するグループの根を返す -        size(x):要素xの属するグループの要素数を返す -        same(x,y):x,yが同じグループに属しているか返す -        重いかも！　　members(x):要素xが属するグループに属する要素をリストで返す -        roots():全ての根の要素を返す -        group_count():グループの数を返す -        重いかも！　all_group_members():{根要素：[そのグループに含まれる要素のリスト]}の辞書を返す -        """ +        def __init__(self, N: int): +            """ +            N:要素数 +            root:各要素の親要素の番号を格納するリスト. +                ただし, root[x] < 0 ならその頂点が根で-root[x]が木の要素数. +            rank:ランク +            """ +            self.N = N +            self.root = [-1] * N +            self.rank = [0] * N -        def __init__(self, n): -            self.n = n -            self.parents = [-1] * n +        def __repr__(self): +            return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots()) -        def find(self, x): -            # 根を探す&つなぎかえる -            if self.parents[x] < 0: +        def find(self, x: int) -> int: +            """頂点xの根を見つける""" +            if self.root[x] < 0: -                self.parents[x] = self.find(self.parents[x]) -                return self.parents[x] +                while self.root[x] >= 0: +                    x = self.root[x] +                return x -        def union(self, x, y): +        def union(self, x: int, y: int) -> int: +            """x,yが属する木をunion""" +            # 根を比較する +            # すでに同じ木に属していた場合は何もしない. +            # 違う木に属していた場合はrankを見てくっつける方を決める. +            # rankが同じ時はrankを1増やす -            if self.parents[x] > self.parents[y]: -                x, y = y, x -            self.parents[x] += self.parents[y] -            self.parents[y] = x +            elif self.rank[x] > self.rank[y]: +                self.root[x] += self.root[y] +                self.root[y] = x +            else: +                self.root[y] += self.root[x] +                self.root[x] = y +                if self.rank[x] == self.rank[y]: +                    self.rank[y] += 1 -        def size(self, x): -            return -self.parents[self.find(x)] - -        def same(self, x, y): +        def same(self, x: int, y: int) -> bool: +            """xとyが同じグループに属するかどうか""" +        def count(self, x): +            """頂点xが属する木のサイズを返す""" +            return -self.root[self.find(x)] + -            root = self.find(x) -            return [i for i in range(self.n) if self.find(i) == root] +            """xが属する木の要素を列挙""" +            _root = self.find(x) +            return [i for i in range(self.N) if self.find == _root] -            return [i for i, x in enumerate(self.parents) if x < 0] +            """森の根を列挙""" +            return [i for i, x in enumerate(self.root) if x < 0] +            """連結成分の数""" +            """{ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す""" - -        def __str__(self): -            return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots())