#pragma GCC optimize ("Ofast")
#pragma GCC optimize ("unroll-loops")
#pragma GCC target ("avx2")

#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }


////////////////////////////////////////////////////////////////////////////////
template <unsigned M_> struct ModInt {
  static constexpr unsigned M = M_;
  unsigned x;
  constexpr ModInt() : x(0U) {}
  constexpr ModInt(unsigned x_) : x(x_ % M) {}
  constexpr ModInt(unsigned long long x_) : x(x_ % M) {}
  constexpr ModInt(int x_) : x(((x_ %= static_cast<int>(M)) < 0) ? (x_ + static_cast<int>(M)) : x_) {}
  constexpr ModInt(long long x_) : x(((x_ %= static_cast<long long>(M)) < 0) ? (x_ + static_cast<long long>(M)) : x_) {}
  ModInt &operator+=(const ModInt &a) { x = ((x += a.x) >= M) ? (x - M) : x; return *this; }
  ModInt &operator-=(const ModInt &a) { x = ((x -= a.x) >= M) ? (x + M) : x; return *this; }
  ModInt &operator*=(const ModInt &a) { x = (static_cast<unsigned long long>(x) * a.x) % M; return *this; }
  ModInt &operator/=(const ModInt &a) { return (*this *= a.inv()); }
  ModInt pow(long long e) const {
    if (e < 0) return inv().pow(-e);
    ModInt a = *this, b = 1U; for (; e; e >>= 1) { if (e & 1) b *= a; a *= a; } return b;
  }
  ModInt inv() const {
    unsigned a = M, b = x; int y = 0, z = 1;
    for (; b; ) { const unsigned q = a / b; const unsigned c = a - q * b; a = b; b = c; const int w = y - static_cast<int>(q) * z; y = z; z = w; }
    assert(a == 1U); return ModInt(y);
  }
  ModInt operator+() const { return *this; }
  ModInt operator-() const { ModInt a; a.x = x ? (M - x) : 0U; return a; }
  ModInt operator+(const ModInt &a) const { return (ModInt(*this) += a); }
  ModInt operator-(const ModInt &a) const { return (ModInt(*this) -= a); }
  ModInt operator*(const ModInt &a) const { return (ModInt(*this) *= a); }
  ModInt operator/(const ModInt &a) const { return (ModInt(*this) /= a); }
  template <class T> friend ModInt operator+(T a, const ModInt &b) { return (ModInt(a) += b); }
  template <class T> friend ModInt operator-(T a, const ModInt &b) { return (ModInt(a) -= b); }
  template <class T> friend ModInt operator*(T a, const ModInt &b) { return (ModInt(a) *= b); }
  template <class T> friend ModInt operator/(T a, const ModInt &b) { return (ModInt(a) /= b); }
  explicit operator bool() const { return x; }
  bool operator==(const ModInt &a) const { return (x == a.x); }
  bool operator!=(const ModInt &a) const { return (x != a.x); }
  friend std::ostream &operator<<(std::ostream &os, const ModInt &a) { return os << a.x; }
};
////////////////////////////////////////////////////////////////////////////////

constexpr unsigned MO = 998244353;
using Mint = ModInt<MO>;

constexpr int LIM_INV = 1010;
Mint inv[LIM_INV], fac[LIM_INV], invFac[LIM_INV];

void prepare() {
  inv[1] = 1;
  for (int i = 2; i < LIM_INV; ++i) {
    inv[i] = -((Mint::M / i) * inv[Mint::M % i]);
  }
  fac[0] = invFac[0] = 1;
  for (int i = 1; i < LIM_INV; ++i) {
    fac[i] = fac[i - 1] * i;
    invFac[i] = invFac[i - 1] * inv[i];
  }
}
Mint binom(Int n, Int k) {
  if (n < 0) {
    if (k >= 0) {
      return ((k & 1) ? -1 : +1) * binom(-n + k - 1, k);
    } else if (n - k >= 0) {
      return (((n - k) & 1) ? -1 : +1) * binom(-k - 1, n - k);
    } else {
      return 0;
    }
  } else {
    if (0 <= k && k <= n) {
      assert(n < LIM_INV);
      return fac[n] * invFac[k] * invFac[n - k];
    } else {
      return 0;
    }
  }
}


Mint interpolateIota(const vector<Mint> &fs, long long n) {
  const int fsLen = fs.size();
  vector<Mint> prodR(fsLen + 1);
  prodR[fsLen] = 1;
  for (int i = fsLen; --i >= 0; ) prodR[i] = (n - i) * prodR[i + 1];
  Mint ans = 0;
  Mint prodL = 1;
  for (int i = 0; i < fsLen; ++i) {
    // (i - 0) ... (i - (i - 1)) (i - (i + 1)) ... (i - (fsLen - 1))
    ans += invFac[i] * (((fsLen - 1 - i) & 1) ? -1 : +1) *
           invFac[fsLen - 1 - i] * fs[i] * prodL * prodR[i + 1];
    prodL *= (n - i);
  }
  return ans;
}


inline long long div53(long long a, int b) {
  return static_cast<double>(a) / b;
}
inline long long div53(long long a, long long b) {
  return static_cast<double>(a) / b;
}


using Double = long double;

struct PT {
	Double x, y, z;
	PT() {}
	PT(Double x, Double y, Double z) : x(x), y(y), z(z) {}
	PT operator+(const PT &a) const { return PT(x + a.x, y + a.y, z + a.z); }
	PT operator-(const PT &a) const { return PT(x - a.x, y - a.y, z - a.z); }
	PT operator+() const { return PT(+x, +y, +z); }
	PT operator-() const { return PT(-x, -y, -z); }
	PT operator*(const Double &k) const { return PT(x * k, y * k, z * k); }
	PT operator/(const Double &k) const { return PT(x / k, y / k, z / k); }
	friend PT operator*(const Double &k, const PT &a) { return PT(k * a.x, k * a.y, k * a.z); }
	PT &operator+=(const PT &a) { x += a.x; y += a.y; z += a.z; return *this; }
	PT &operator-=(const PT &a) { x -= a.x; y -= a.y; z -= a.z; return *this; }
	PT &operator*=(const Double &k) { x *= k; y *= k; z *= k; return *this; }
	PT &operator/=(const Double &k) { x /= k; y /= k; z /= k; return *this; }
	Double abs() const { return sqrt(x * x + y * y + z * z); }
	Double abs2() const { return x * x + y * y + z * z; }
	Double dot(const PT &a) const { return x * a.x + y * a.y + z * a.z; }
	PT cross(const PT a) const { return PT(y * a.z - z * a.y, z * a.x - x * a.z, x * a.y - y * a.x); }
	friend ostream &operator<<(ostream &os, const PT &a) { os << "(" << a.x << ", " << a.y << ", " << a.z << ")"; return os; }
};
const Double EPS = 1e-10;
const Double INF = 1e+10;
const Double PI = acos(-1.0L);
int sig(Double r) { return (r < -EPS) ? -1 : (r > EPS) ? 1 : 0; }
PT tri(const PT &a, const PT &b, const PT &c) { return (b - a).cross(c - a); }
Double tet(const PT &a, const PT &b, const PT &c, const PT &d) { return (b - a).cross(c - a).dot(d - a); }


//	Convex Hull
//	No 4 Points Planar!!!
//	Output: [N][0 .. lens[N]]
//********************//
const int LIM_N = 210;
int N;
PT P[LIM_N + 1];
int lens[LIM_N + 1], as[LIM_N + 1][LIM_N * 2], bs[LIM_N + 1][LIM_N * 2], cs[LIM_N + 1][LIM_N * 2], ss[LIM_N + 1][LIM_N * 2];
//********************//
void convexHull3D() {
	fill(lens, lens + N + 1, 0);
	lens[3] = 2;
	as[3][0] = 0; bs[3][0] = 1; cs[3][0] = 2;
	as[3][1] = 0; bs[3][1] = 2; cs[3][1] = 1;
	for (int i = 3; i < N; ++i) {
		for (int j = 0; j < lens[i]; ++j) {
			const int a = as[i][j], b = bs[i][j], c = cs[i][j];
			ss[a][b] = ss[b][c] = ss[c][a] = (tet(P[a], P[b], P[c], P[i]) < 0);
		}
		for (int j = 0; j < lens[i]; ++j) {
			const int a = as[i][j], b = bs[i][j], c = cs[i][j];
			if (ss[a][b]) {
				as[i + 1][lens[i + 1]] = a; bs[i + 1][lens[i + 1]] = b; cs[i + 1][lens[i + 1]] = c; ++lens[i + 1];
			} else {
				if (ss[b][a]) { as[i + 1][lens[i + 1]] = i; bs[i + 1][lens[i + 1]] = a; cs[i + 1][lens[i + 1]] = b; ++lens[i + 1]; }
				if (ss[c][b]) { as[i + 1][lens[i + 1]] = i; bs[i + 1][lens[i + 1]] = b; cs[i + 1][lens[i + 1]] = c; ++lens[i + 1]; }
				if (ss[a][c]) { as[i + 1][lens[i + 1]] = i; bs[i + 1][lens[i + 1]] = c; cs[i + 1][lens[i + 1]] = a; ++lens[i + 1]; }
			}
		}
	}
}
//********************//


Int det3(
    Int a00, Int a01, Int a02,
    Int a10, Int a11, Int a12,
    Int a20, Int a21, Int a22) {
  Int ret = 0;
  ret += a00 * (a11 * a22 - a12 * a21);
  ret += a10 * (a21 * a02 - a22 * a01);
  ret += a20 * (a01 * a12 - a02 * a11);
  return ret;
}


Int K;
vector<Int> X, Y, Z;

// a x + b y + c z <= d
int LEN;
vector<Int> A, B, C;
vector<Int> D;

int main() {
  prepare();
  
  for (; ~scanf("%d%lld", &N, &K); ) {
    X.resize(N);
    Y.resize(N);
    Z.resize(N);
    for (int i = 0; i < N; ++i) {
      scanf("%lld%lld%lld", &X[i], &Y[i], &Z[i]);
    }
    
    const Int minX = *min_element(X.begin(), X.end()), maxX = *max_element(X.begin(), X.end());
    const Int minY = *min_element(Y.begin(), Y.end()), maxY = *max_element(Y.begin(), Y.end());
    const Int minZ = *min_element(Z.begin(), Z.end()), maxZ = *max_element(Z.begin(), Z.end());
// cerr<<"["<<minX<<", "<<maxX<<"] ["<<minY<<", "<<maxY<<"] ["<<minZ<<", "<<maxZ<<"]"<<endl;
    
    for (int i = 0; i < N; ++i) {
      const Double theta = tan((Double)(i * i + 1));
      const Double phi = tan((Double)(i * i + 2));
      P[i] = PT(X[i], Y[i], Z[i]) + 1e-4L * PT(sin(theta) * cos(phi), sin(theta) * sin(phi), cos(theta));
    }
    convexHull3D();
    LEN = lens[N];
    A.resize(LEN);
    B.resize(LEN);
    C.resize(LEN);
    D.resize(LEN);
    Int vol = 0;
    for (int h = 0; h < LEN; ++h) {
      const int i = as[N][h];
      const int j = bs[N][h];
      const int k = cs[N][h];
// cerr<<i<<" "<<j<<" "<<k<<endl;
      A[h] = det3(
        Y[i], Z[i], 1,
        Y[j], Z[j], 1,
        Y[k], Z[k], 1
      );
      B[h] = det3(
        Z[i], X[i], 1,
        Z[j], X[j], 1,
        Z[k], X[k], 1
      );
      C[h] = det3(
        X[i], Y[i], 1,
        X[j], Y[j], 1,
        X[k], Y[k], 1
      );
      D[h] = det3(
        X[i], Y[i], Z[i],
        X[j], Y[j], Z[j],
        X[k], Y[k], Z[k]
      );
      vol += D[h];
    }
// cerr<<"A = "<<A<<endl;
// cerr<<"B = "<<B<<endl;
// cerr<<"C = "<<C<<endl;
// cerr<<"D = "<<D<<endl;
    
    // yusushite
    Int plus = 0, minus = 0;
    for (Int x = minX; x <= maxX; ++x) for (Int y = minY; y <= maxY; ++y) {
      Int plusL = minZ, plusU = maxZ;
      Int minusL = minZ, minusU = maxZ;
      for (int h = 0; h < LEN; ++h) if (!(A[h] == 0 && B[h] == 0 && C[h] == 0 && D[h] == 0)) {
        // c z <= d
        Int c = C[h];
        Int d = D[h] - A[h] * x - B[h] * y;
        if (c > 0) {
          // Int q = d / c;
          Int q = div53(d, c);
          Int r = d - c * q;
          if (r < 0) {
            q -= 1;
            r += c;
          }
          chmin(plusU, q);
          chmin(minusU, r ? q : (q - 1));
        } else if (c < 0) {
          c = -c;
          d = -d;
          // c z >= d
          // Int q = d / c;
          Int q = div53(d, c);
          Int r = d - c * q;
          if (r < 0) {
            q -= 1;
            r += c;
          }
          chmax(plusL, r ? (q + 1) : q);
          chmax(minusL, q + 1);
        } else {
          if (0 < d) {
            //
          } else if (0 <= d) {
// if(x==-1999&&y==-1999)cerr<<"HELP "<<A[h]<<" "<<B[h]<<" "<<C[h]<<" "<<D[h]<<endl;
            minusL = maxZ + 1;
            minusU = minZ - 1;
          } else {
            goto failed;
          }
        }
      }
      if (plusL <= plusU) {
// cerr<<x<<" "<<y<<": ["<<plusL<<", "<<plusU<<"] ["<<minusL<<", "<<minusU<<"]"<<endl;
        plus += (plusU - plusL + 1);
      }
      if (minusL <= minusU) {
        minus += (minusU - minusL + 1);
      }
     failed:{}
    }
cerr<<"vol = "<<vol<<", plus = "<<plus<<", minus = "<<minus<<endl;
    
    const Mint res = interpolateIota({
      Mint(-minus) + Mint(vol) / 6,
      Mint(1),
      Mint(plus) - Mint(vol) / 6,
    }, K + 1);
    const Mint ans = res + Mint(vol) / 6 * Mint(K).pow(3);
    printf("%u\n", ans.x);
  }
  return 0;
}