#include <bits/stdc++.h>
using namespace std;
#define PB push_back
#define LL long long
#define MP make_pair
#define X first
#define Y second
const int INF = 1000LL*1000*1000;
const int base = 1000 * 1000 * 1000;
const int mod = 998244353;
const int ob2 = (mod + 1) / 2;
int add(int a , int b)
{
    return a + b < mod ? a + b : a + b - mod;
}
int mult(int a , int b)
{
    return (a * (LL)b) % mod;
}
int step2[100005];
int dp[100005][2];
int N , M;
int posX[6] = {-1 , 0 , 0 , 0 , -1 , -2};
int posY[6] = {-1 , 0 , -1 , -2 , 0 , 0};
map<pair<int , int> , int> m;
vector<pair<int , int> > v[100005];
int getVal(int r , int c)
{
    if(!m.count({r , c}))
        return 2;
    else
        return m[{r , c}];
}
bool canBe(int val , int r , int c)
{
    return getVal(r , c) == val || getVal(r , c) == 2;
}
int b[64][6];
int main()
{
    ios_base::sync_with_stdio(0);
    for(int i = 0; i < 64; i++)
    {
        for(int j = 0; j < 6; j++)
            b[i][j] = (i >> j) & 1;
    }
    step2[0] = 1;
    for(int i = 1; i < 100005; i++)
        step2[i] = add(step2[i - 1] , step2[i - 1]);
    cin >> N >> M;
    assert(N >= 2);
    for(int i = 0; i < M; i++)
    {
        int a , b , c;
        cin >> a >> b >> c;
        a--;b--;
        m[{a , b}] = c;
        if(a > b)
        {
            swap(a , b);
        }
        if(max(a , b) - min(a , b) >= 3)
        {
            v[max(a , b)].PB({min(a , b) , c});
        }
    }
    for(int i = 1; i <= 100000; i++)
        sort(v[i].begin() , v[i].end());
    
    for(int i = 0; i < (1 << 4); i++)
    {
        int mask = i;
        int b1 , b2 , b3 , b4;
        b1 = mask & 1;
        mask >>= 1;
        b2 = mask & 1;
        mask >>= 1;
        b3 = mask & 1;
        mask >>= 1;
        b4 = mask & 1;
        if(canBe(b1 , 0 , 0) && canBe(b2 , 0 , 1) && canBe(b3 , 1 , 0) && canBe(b4 , 1 , 1) && ((b1 ^ b2 ^ b3 ^ b4) == 0))
        {
            dp[1][b4]++;
        }
    }
    
    for(int i = 2; i < N; i++)
    {
        int multik = step2[i - 2];
        for(int j = 0; j < v[i].size(); j++)
        {
            if(j && v[i][j].X == v[i][j - 1].X)
            {
                if(v[i][j].Y != v[i][j - 1].Y)
                {
                    cout << 0;
                    return 0;
                }
                else
                {
                    continue;
                }
            }
            multik = mult(multik , ob2);
        }
        for(int Mask = 0; Mask < (1 << 6); Mask++)
        {
            int parity = __builtin_popcount(Mask) % 2;
            
            if((parity ^ b[Mask][0]) == 1)
            {
                continue;
            }
            if((b[Mask][0] ^ b[Mask][1] ^ b[Mask][2] ^ b[Mask][4]) == 1)
            {
                continue;
            }
            bool good = true;
            for(int j = 0; j < 6; j++)
                good &= canBe(b[Mask][j] , i + posX[j] , i + posY[j]);
            if(!good)
                continue;
            dp[i][b[Mask][1]] = add(dp[i][b[Mask][1]] , dp[i - 1][b[Mask][0]]);
            
                
        }
        dp[i][0] = mult(dp[i][0] , multik);
        dp[i][1] = mult(dp[i][1] , multik);
        
    }
    int ans = add(dp[N - 1][0] , dp[N - 1][1]);
    
    cout << ans;
    
}

Measured memory_bytes: 8064