You are given three integers n, k, m and m conditions (l_1, r_1, x_1), (l_2, r_2, x_2), ..., (l_m, r_m, x_m).

Calculate the number of distinct arrays a, consisting of n integers such that: 

  * 0 ≤ a_i < 2^k for each 1 ≤ i ≤ n; 
  * bitwise AND of numbers a[l_i] \& a[l_i + 1] \& ... \& a[r_i] = x_i for each 1 ≤ i ≤ m. 



Two arrays a and b are considered different if there exists such a position i that a_i ≠ b_i. 

The number can be pretty large so print it modulo 998244353.

Input

The first line contains three integers n, k and m (1 ≤ n ≤ 5 ⋅ 10^5, 1 ≤ k ≤ 30, 0 ≤ m ≤ 5 ⋅ 10^5) — the length of the array a, the value such that all numbers in a should be smaller than 2^k and the number of conditions, respectively.

Each of the next m lines contains the description of a condition l_i, r_i and x_i (1 ≤ l_i ≤ r_i ≤ n, 0 ≤ x_i < 2^k) — the borders of the condition segment and the required bitwise AND value on it.

Output

Print a single integer — the number of distinct arrays a that satisfy all the above conditions modulo 998244353.

Examples

Input


4 3 2
1 3 3
3 4 6


Output


3


Input


5 2 3
1 3 2
2 5 0
3 3 3


Output


33

Note

You can recall what is a bitwise AND operation [here](https://en.wikipedia.org/wiki/Bitwise_operation#AND).

In the first example, the answer is the following arrays: [3, 3, 7, 6], [3, 7, 7, 6] and [7, 3, 7, 6].
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize("Ofast,inline")
using namespace std;
namespace Base {
inline char gc(void) {
  static char buf[100000], *p1 = buf, *p2 = buf;
  return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
             ? EOF
             : *p1++;
}
template <class T>
inline void read(T &x) {
  T flag = (T)1;
  x = 0;
  static char ch = getchar();
  for (; ch > '9' || ch < '0'; ch = getchar()) flag = ch == '-' ? -1 : 1;
  for (; ch >= '0' && ch <= '9'; ch = getchar())
    x = (x << 1) + (x << 3) + (ch & 15);
  x *= flag;
  return;
}
inline void readstr(string &x) {
  x = "";
  static char ch;
  while (isspace(ch = getchar()))
    ;
  while (x += ch, !isspace(ch = getchar()))
    ;
}
inline void readstr(char *s) {
  do *s = getchar();
  while ((*s == ' ') || (*s == '\n') || (*s == '\r'));
  do *(++s) = getchar();
  while ((~*s) && (*s != ' ') && (*s != '\n') && (*s != '\r'));
  *s = 0;
  return;
}
inline void printstr(string x, int num = 0, char ch = '\n') {
  for (int i = num; i < x.size(); ++i) putchar(x[i]);
  putchar(ch);
}
inline void readch(char &x) {
  while (isspace(x = getchar()))
    ;
}
char pf[100000], *o1 = pf, *o2 = pf + 100000;
template <class T>
inline void println(T x, char c = '\n') {
  if (x < 0)
    (o1 == o2 ? fwrite(pf, 1, 100000, stdout), *(o1 = pf)++ = 45 : *o1++ = 45),
        x = -x;
  static char s[15], *b;
  b = s;
  if (!x) *b++ = 48;
  for (; x; *b++ = x % 10 + 48, x /= 10)
    ;
  for (; b-- != s; (o1 == o2          ? fwrite(pf, 1, 100000, stdout),
                    *(o1 = pf)++ = *b : *o1++ = *b))
    ;
  (o1 == o2 ? fwrite(pf, 1, 100000, stdout), *(o1 = pf)++ = c : *o1++ = c);
}
template <class T>
inline void write(T x) {
  if (x < 0) putchar('-'), x = -x;
  if (x > 9) write(x / 10);
  putchar(x % 10 + '0');
  return;
}
template <class T>
inline void writeln(T x) {
  write(x);
  puts("");
}
template <class T>
inline void writeln(T x, char c) {
  write(x);
  putchar(c);
}
template <class T>
inline void writeln(char c, T x) {
  putchar(c);
  write(x);
}
template <class T>
inline void chkmax(T &x, const T y) {
  x > y ? x = x : x = y;
}
template <class T>
inline void chkmin(T &x, const T y) {
  x < y ? x = x : x = y;
}
template <class T>
inline T max(const T &x, const T &y, const T &z) {
  return x > y ? (x > z ? x : z) : (y > z ? y : z);
}
inline void file(string str) {
  freopen((str + ".in").c_str(), "r", stdin);
  freopen((str + ".out").c_str(), "w", stdout);
}
struct Vector {
  double x, y;
  Vector(double _x = 0, double _y = 0) : x(_x), y(_y) {}
  inline Vector Vary(void) { return Vector(x, -y); }
  inline bool operator<(const Vector &rhs) const {
    return x == rhs.x ? y < rhs.y : x < rhs.x;
  }
  inline Vector operator-(const Vector &rhs) const {
    return Vector(x - rhs.x, y - rhs.y);
  }
  inline Vector operator+(const Vector &rhs) const {
    return Vector(x + rhs.x, y + rhs.y);
  }
  inline Vector operator*(const double &rhs) const {
    return Vector(x * rhs, y * rhs);
  }
  inline Vector operator/(const double &rhs) const {
    return Vector(x / rhs, y / rhs);
  }
  inline Vector operator*(const Vector &rhs) const {
    return Vector(x * rhs.x - y * rhs.y, x * rhs.y + y * rhs.x);
  }
};
}  // namespace Base
using namespace Base;
const int mod = 998244353;
const int Maxn = 5e5 + 5;
int n, k, m, l[Maxn], r[Maxn], x[Maxn], mxl[Maxn], f[Maxn], cf[Maxn];
inline int solve(int bit) {
  for (int i = 1; i <= n; i++) f[i] = cf[i] = mxl[i] = 0;
  for (int i = 1; i <= m; i++) {
    if (x[i] & (1 << bit))
      cf[l[i]]++, cf[r[i] + 1]--;
    else
      chkmax(mxl[r[i]], l[i]);
  }
  f[0] = 1;
  int sum = 1, j = 0;
  for (int i = 1; i <= n + 1; i++) {
    chkmax(mxl[i], mxl[i - 1]), cf[i] += cf[i - 1];
    if (cf[i] > 0) {
      f[i] = 0;
      continue;
    }
    while (j < mxl[i - 1]) {
      sum = (sum - f[j] + mod) % mod;
      ++j;
    }
    f[i] = sum;
    sum = (sum + f[i]) % mod;
  }
  return f[n + 1];
}
signed main(void) {
  read(n), read(k), read(m);
  int ans = 1;
  for (int i = 1; i <= m; i++) read(l[i]), read(r[i]), read(x[i]);
  for (int i = 0; i < k; i++) ans = 1ll * ans * solve(i) % mod;
  writeln(ans);
  return 0;
}
