#include <bits/stdc++.h>

using i64 = long long;

constexpr int P = 1000003;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int N, L;
    std::cin >> N >> L;

    std::vector<std::array<int, 3>> c(N);
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < 3; j++) {
            std::cin >> c[i][j];
            c[i][j]--;
        }
    }

    std::vector<int> f(6 * N), siz(6 * N);
    std::iota(f.begin(), f.end(), 0);

    auto find = [&](int x) {
        while (x != f[x]) {
            x = f[x] = f[f[x]];
        }
        return x;
    };

    auto merge = [&](int x, int y) {
        x = find(x);
        y = find(y);
        if (x == y) {
            return false;
        }
        f[x] = y;
        siz[y] += siz[x];
        return true;
    };

    for (int x = 0; x < N; x++) {
        for (int j = 0; j < 3; j++) {
            int y = c[x][j];
            if (x < y) {
                int k = 0;
                while (c[y][k] != x) {
                    k++;
                }
                merge(x * 6 + 2 * j, y * 6 + 2 * k + 1);
                merge(x * 6 + 2 * j + 1, y * 6 + 2 * k);
            }
        }
    }

    std::vector<int> id(6 * N);
    int cur = 0;
    for (int i = 0; i < 6 * N; i++) {
        if (f[i] == i) {
            id[i] = cur++;
        }
    }
    for (int i = 0; i < 6 * N; i++) {
        id[i] = id[find(i)];
    }

    const int m = N * 3;
    assert(m == cur);
    std::vector g(m, std::vector<int>(m));
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < 6; j++) {
            int u = id[i * 6 + j];
            int v = id[i * 6 + (j + 1) % 6];
            g[u][v] = g[v][u] = (j % 2 == 0 ? L + 1 : 1);
        }
    }

    std::vector<std::array<int, 2>> e1;
    std::vector<std::array<int, 2>> e2;

    for (int i = 0; i < m; i++) {
        for (int j = i + 1; j < m; j++) {
            if (g[i][j] > 1) {
                e1.push_back({i, j});
            } else if (g[i][j] == 1) {
                e2.push_back({i, j});
            }
        }
    }
    
//    std::cerr << e1.size() << " " << e2.size() << "\n";

    int ans = 0;
    std::vector<bool> vis(m);
    f.resize(m);
    std::vector<int> pw(e1.size() + 1);
    pw[0] = 1;
    for (int i = 1; i <= e1.size(); i++) {
        pw[i] = 1LL * pw[i - 1] * (L + 1) % P;
    }
    for (int s = 0; s < (1 << e1.size()); s++) {
        int ways = 1;
        std::iota(f.begin(), f.end(), 0);
        siz.assign(m, 1);
        vis.assign(m, false);
        int cnt = 0;
        for (int i = 0; i < e1.size(); i++) {
            if (s >> i & 1) {
                vis[e1[i][0]] = vis[e1[i][1]] = true;
                cnt++;
            }
        }
        for (auto [u, v] : e2) {
            if (!vis[u] && !vis[v]) {
                if (!merge(u, v)) {
                    ways = 2 * ways % P;
                }
            }
        }
        for (int i = 0; i < m; i++) {
            if (!vis[i] && f[i] == i && siz[i] % 2) {
                ways = 0;
                break;
            }
        }
        ans = (ans + 1LL * ways * pw[cnt]) % P;
    }

    std::cout << ans << "\n";

    return 0;
}