#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
//#define INPUT
/**
    Problem:1182 - 食物鏈，NOI2001
    Begin Time:4th/Mar/2012 1:00 p.m.
    End Time:4th/Mar/2012 6:47 p.m.
    Cost Time:兩天多，看的別人的解題報告AC的
    Reference:http://apps.hi.baidu.com/share/detail/16059767
    測試資料：
    http://poj.org/showmessage?message_id=93058
    輸出：
    上方有
    教訓：
        WA一次，沒搞清楚先更新父節點relation還是更新當前節點relation的關係！！！
        （在最後那條犯錯誤了！）
    思路：
    老子決心要寫一個，關於這道題的，最詳細的解題報告。
    本題思路是帶權並查集，我們從最開始講起。

    Part I  - 權值(relation)的確定。
    我們根據題意，森林中有3種動物。A吃B，B吃C，C吃A。
    我們還要使用並查集，那麼，我們就以動物之間的關係來作為並查集每個節點的
    權值。
    注意，我們不知道所給的動物（題目說了，輸入只給編號）所屬的種類。
    所以，我們可以用動物之間“相對”的關係來確定一個並查集。
    0 - 這個節點與它的父節點是同類
    1 - 這個節點被它的父節點吃
    2 - 這個節點吃它的父節點。

    注意，這個0,1,2所代表的意義不是隨便制定的，我們看題目中的要求。
    說話的時候，第一個數字（下文中，設為d）指定了後面兩種動物的關係：
    1 - X與Y同類
    2 - X吃Y

    我們注意到，當 d = 1的時候，( d - 1 ) = 0，也就是我們制定的意義
                當 d = 2的時候，( d - 1 ) = 1，代表Y被X吃，也是我們指定的意義。
    所以，這個0,1,2不是隨便選的


    Part II - 路徑壓縮，以及節點間關係確定
    確定了權值之後，我們要確定有關的操作。
    我們把所有的動物全初始化。
    struct Animal
    {
        int num; //該節點（node）的編號
        int parent; //該node的父親
        int relation; //該node與父節點的關係，0同類，1被父節點吃，2吃父節點
    }; Animal ani[50010];
        初始化為
        For i = 0 to N do
            ani[i].num = i;
            ani[i].parent = i;
            ani[i].relation = 0 ; //自己和自己是同類
        End For

        (1)路徑壓縮時的節點演算法
        我們設A,B,C動物集合如下：（為了以後便於舉例）
        A = { 1 , 2 , 3 ,4 ,5 }
        B = { 6 , 7 , 8 ,9 ,10}
        C = { 11, 12, 13,14,15}
        假如我們已經有了一個集合，分別有3個元素
        SET1 = {1,2}，我們規定集合中第一個元素為並查集的“代表”
        假如現在有語句：
        2 2 6
        這是一句真話
        2是6的父親
         ani[6].parent = 2;
         ani[6].relation = 1;
        那麼，6和1的關係如何呢？
         ani[2].parent = 1;
         ani[2].relation = 0;
        我們可以發現6與2的關係是 1.
        通過窮舉我們可以發現
        ani[now].parent = ani[ani[now].parent].parent;
        ani[now].relation = ( ani[now].relation + ani[now.parent].relation ) % 3;
        這個路徑壓縮演算法是正確的
        關於這個路徑壓縮演算法，還有一點需要注意的地方，我們一會再談
        注意，根據當前節點的relation和當前節點父節點的relation推出
        當前節點與其父節點的父節點的relation這個公式十分重要！！
        它推不出來下面都理解不了！！自己用窮舉法推一下：
        好吧，為了方便伸手黨，我給出窮舉過程
                i      j
        爺爺  父親  兒子  兒子與爺爺
               0      0       (i + j)%3 = 0
               0      1       (i + j)%3 = 1
               0      2       (i + j)%3 = 2
               1      0       (i + j)%3 = 1
               1      1       (i + j)%3 = 2
               1      2       (i + j)%3 = 0
               2      0       (i + j)%3 = 2
               2      1       (i + j)%3 = 0
               2      2       (i + j)%3 = 1
        嗯，這樣可以看到，( 兒子relation + 父親relation ) % 3 = 兒子對爺爺的relation
        這就是路徑壓縮的節點演算法
        (2) 集合間關係的確定
        在初始化的時候，我們看到，每個集合都是一個元素，就是他本身。
        這時候，每個集合都是自洽的（集合中每個元素都不違反題目的規定）
        注意，我們使用並查集的目的就是儘量的把路徑壓縮，使之高度儘量矮
        假設我們已經有一個集合
        set1 = {1,2,7,10}
        set2 = {11,4,8,13},每個編號所屬的物種見上文
        set3 = {12,5,4,9}
        現在有一句話
        2 13 2
        這是一句真話,X = 13,Y = 2
        我們要把這兩個集合合併成一個集合。
        直接
        int a = findParent(ani[X]);
        int b = findParent(ani[Y]);
        ani[b].parent = a;
        就是把Y所在集合的根節點的父親設定成X所在集合的根節點。
        但是，但是！！！！
        Y所在集合的根結點與X所在集合的根節點的關係！！！要怎麼確定呢？
        我們設X,Y集合都是路徑壓縮過的，高度只有2層
        我們先給出計算的公式
        ani[b].relation = ( 3 - ani[Y].relation + ( d - 1 ) + ani[X].relation) % 3;
        這個公式，是分三部分，這麼推出來的
        第一部分，好理解的一部分：
        ( d - 1 ) :這是X和Y之間的relation，X是Y的父節點時，Y的relation就是這個
        3 - ani[Y].relation = 根據Y與根節點的關係，逆推根節點與Y的關係
        這部分也是窮舉法推出來的，我們舉例：
        j
        子         父相對於子的relation（即假如子是父的父節點，那麼父的relation應該是什麼，因為父現在是根節點，所以父.relation = 0，我們只能根據父的子節點反推子跟父節點的關係）
         0             ( 3 - 0 ) % 3 = 0
         1（父吃子）   ( 3 - 1 ) % 3 = 2 //父吃子
         2（子吃父)    ( 3 - 2 ) % 3 = 1 //子吃父，一樣的哦親
        ——————————————————————————————————————————————————————
        我們的過程是這樣的：
        把ani[Y]，先連線到ani[X]上，再把ani[Y]的根節點移動到ani[X]上，最後，把ani[Y]的根節點移動到ani[X]的根節點上，這樣算relation的
        還記得麼，如果我們有一個集合，壓縮路徑的時候父子關係是這麼確定的
        ani[爺爺].relation = ( ani[父親].relation + ani[兒子].relation ) % 3
        我們已知道,( d - 1 )就是X與Y的relation了
        而 (3 - ani[Y].relation)就是 以Y為根節點時，他的父親的relation
        那麼
        我們假設把Y接到X上，也就說，現在X是Y的父親，Y原來的根節點現在是Y的兒子
          Y的relation   +     ani[Y]根節點相對於ani[Y]的relation
        ( ( d - 1 )         +    ( 3 - ani[Y].relation) ) % 3
        就是ani[Y]的父親節點與ani[X]的relation了！

        那麼，不難得到，ani[Y]的根節點與ani[X]根節點的關係是：
        ( ( d - 1 ) + ( 3 - ani[Y].relation) + ani[X].relation ) % 3 ->應用了同餘定理
        注意，這個當所有集合都是初始化狀態的時候也適用哦
        還是以最開頭我們給的三個集合（分別代表三個物種）為例
        2 1 6
        帶入公式
        ani[6].relation = ( ( 2 - 1 ) + ( 3 - 0 ) + 0 ) % 3 = 1
        也就是，6被1吃
    Part III - 演算法正確性的證明
        首先，兩個自洽的集合，合併以後仍然是自洽的
        這個不難想吧，數學上有個什麼對稱性定理跟他很像的。
        如果理解不了，就這麼想！！
        當set1和set2合併之後，set2的根節點得到了自己關於set1根節點的
        正確relation值，變成了set1根節點的兒子，那麼
        set2的所有兒子只要用
        ( ani[X].relation + ani[Y].relation ) % 3就能得到自己正確的relation值了
        所以說，針對不在同一集合的兩個元素的話，除非違背了（2）和（3），否則永遠是真的
        （無論這句話說的是什麼，我們都可以根據所給X,Y推出兩個子節點之間應有的關係，這個關係一確定，所有兒子的關係都可以確定）

        其實所有的不同集合到最後都會被合併成一個集合的。
        我們只要在一個集合中找那些假話就可以了。
        首先，如何判斷
        1 X Y是不是假話。//此時 d = 1
        if ( X 和 Y 不在同一集合)
            Union(x,y,xroot,yroot,d)
        else
            if x.relation != y.relation  ->假話
        其次，如何判斷
        2 X Y是不是假話 //此時d = 2
        if ( X 和 Y 不在同一集合）
            Union(x,y,xroot,yroot,d)
        else
            (ani[y].relation + 3 - ani[x].relation ) % 3 != 1 ->假話
        這個公式是這麼來的：
        3 - ani[x].relation得到了根節點關於x的relation
        ani[y] + 3 - ani[x].relation得到了y關於x的relation
        所以，只要y關於x的relation不是1，就是y不被x吃的話，這句話肯定是假話！

        (2)路徑壓縮要特別注意的一點（錯在這裡，要檢討自己）
            路徑壓縮的時候，記得要
            先findParent，再給當前節點的relation賦值。
            否則有可能因為當前節點的父節點的relation不正確而導致錯的稀里嘩啦。
            例子：
            set1 = {1,2,7,10}
            set2 = {3,4,8,11}
            set3 = {12,5,14,9}
            Union(1,3,1,3,1)
            Union(3,12,3,12,2)
            1 5 1
            算5的relation
            如果不先更新parent的relation，算出來應該是
            ( 3 - 0 + 0 + 1 ) % 3 = 1，5被1吃，顯然不對
            這裡面，+ 0的那個0是指根節點 12 的relation（未更新，這裡的0是指12與11的relation）
            如果更新完了的話，應該是
            ( 3 - 0 + 2 + 1 ) % 3 = 0 ,5與1是同一物種，對了
            這裡面的 2 是更新節點12的relation（12與1的relation）
    後記：
        關於這道題，我在網上搜索了許多解題報告，但是都閃爍其詞，大概大家都不想
        把自己辛辛苦苦推出來的公式寫到網上供別人學習來節省時間吧。
        我覺得這麼做不好，對初學者容易產生不良影響，ACM如果只是一個小眾化的圈子，那
        豈不是太沒意思了。
        於是我就把我自己總結的這道題的經驗放了出來，希望可以幫得到大家
        自己總結的，對錯也不知道，但是起碼是“自洽”的，^ ^
        感謝那篇博文的博主，也感謝gzm,lqy兩位學長的指導。
        c0de4fun


*/
using namespace std;
const int c0de4fun = 50010;//動物個數的最大值
///指明父節點與自己的關係，0同類，1被吃，2吃父
const int SAME = 0;
const int ENEMY = 1;
const int FOOD = 2;
struct Animal
{
    int parent;
    int num;
    int relation;
};
Animal ani[c0de4fun];
long ans;
int findParent(Animal* node)
{
    ///Wrong Answer 因為這個函式寫錯了
    ///這個函式得是“自洽的”
    ///就是說，得保證每個元素的父親的relation是對的
    ///再算自己的relation
    ///因為自己的relation和父親的relation有關
    ///這就是為什麼要先findParent再relation更新的原因
    int tmp;
    if ( node->parent == node->num )
    {
        return node->parent;
    }
    tmp = node->parent;
#ifdef DBG
    printf("Animal %d s Parent is %d\n", node->num, node->parent);
#endif
    // node->relation = ( ani[node->parent].relation + node->relation ) % 3;
    node->parent = findParent(&ani[node->parent]);
    node->relation = ( ani[tmp].relation + node->relation ) % 3;
    return node->parent;
}
void Union(int x, int y, int a, int b, int d)
{
    ani[b].parent = a;
    ///rootY.parent = rootX.parent;
    ani[b].relation = ( (3 - ani[y].relation) + (d - 1) + ani[x].relation) % 3;
}

void init_Animal(int n)
{
    for (int i = 1 ; i <= n ; i++)
    {
        ani[i].num = i;
        ani[i].parent = i;
        ani[i].relation = SAME;
    }
}
int main(int argc, char* argv[])
{
    int N, K;
    int d, X, Y;
#ifdef INPUT
    freopen("b:\\acm\\poj1182\\input.txt", "r", stdin);
#endif
    scanf("%d%d", &N, &K);
    init_Animal(N);
    for (int i = 0 ; i < K ; i++)
    {
        scanf("%d%d%d", &d, &X, &Y);
        if ( X > N || Y > N)
        {
            ans++;
        }
        else
        {
            if (d == 2 && X == Y)
            {
                ans++;
            }
            else
            {
                int a = findParent(&ani[X]);
                int b = findParent(&ani[Y]);
                if ( a != b )
                {
                    ///x，y不在同一集合中
                    Union(X, Y, a, b, d);
                }
                else
                {
                    switch (d)
                    {
                    case 1:
                        if (ani[X].relation != ani[Y].relation)
                        {
                            ans++;
                        }
                        break;
                    case 2:
                        if (((ani[Y].relation + 3 - ani[X].relation) % 3 ) != 1)
                        {
                            ans++;
                        }
                        break;
                    }
                }
            }
        }
    }
    printf("%d\n", ans);
    return 0;
}