#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = uint64_t;
using i32 = int32_t;
using u32 = uint32_t;
using i64 = int64_t;
using u64 = uint64_t;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using ld = double;
namespace io {
auto unistd_read = read;
auto unistd_write = write;
const int BUFSIZE = 1 << 20;
int isize, osize;
char ibuf[BUFSIZE + 10], obuf[BUFSIZE + 10];
char *is, *it, *os = obuf, *ot = obuf + BUFSIZE;
char getchar() {
  if (is == it) {
    is = ibuf;
    it = ibuf + unistd_read(STDIN_FILENO, ibuf, BUFSIZE);
    if (is == it) return EOF;
  }
  return *is++;
}
char getalpha() {
  char c = getchar();
  while (!isalpha(c)) c = getchar();
  return c;
}
void putchar(char c) {
  *os++ = c;
  if (os == ot) {
    unistd_write(STDOUT_FILENO, obuf, BUFSIZE);
    os = obuf;
  }
}
int inp() {
  int x = 0, f = 0;
  char ch;
  for (ch = getchar(); !isdigit(ch); ch = getchar()) {
    if (ch == EOF) return -1;
    if (ch == '-') f = 1;
  }
  for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
    ;
  return f ? -x : x;
}
ll inp_ll() {
  ll x = 0;
  int f = 0;
  char ch;
  for (ch = getchar(); !isdigit(ch); ch = getchar())
    if (ch == '-') f = 1;
  for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
    ;
  return f ? -x : x;
}
template <class T>
bool read(T& x) {
  x = 0;
  int f = 0;
  char ch;
  for (ch = getchar(); !isdigit(ch); ch = getchar()) {
    if (ch == EOF) return 0;
    if (ch == '-') f = 1;
  }
  for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
    ;
  if (f) x = -x;
  return 1;
}
bool read(char* s) {
  char* t = s;
  char ch = getchar();
  for (; ch == ' ' || ch == '\n'; ch = getchar())
    ;
  for (; ch != ' ' && ch != '\n' && ch != EOF; ch = getchar()) *t++ = ch;
  *t = 0;
  return s != t;
}
template <class T, class... Args>
bool read(T& x, Args&... args) {
  return read(x) && read(args...);
}
template <class T>
bool readln(T& x) {
  x = 0;
  int f = 0;
  char ch;
  for (ch = getchar(); !isdigit(ch); ch = getchar()) {
    if (ch == EOF) return 0;
    if (ch == '-') f = 1;
  }
  for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
    ;
  if (f) x = -x;
  for (; ch != '\n' && ch != EOF; ch = getchar())
    ;
  return 1;
}
bool readln(char* s) {
  char* t = s;
  while (1) {
    char ch = getchar();
    if (ch == '\n' || ch == EOF) break;
    *t++ = ch;
  }
  *t = 0;
  return s != t;
}
template <class T, class... Args>
bool readln(T& x, Args&... args) {
  return read(x) && readln(args...);
}
template <class T>
void write(T x) {
  static char s[22];
  static char* it = s + 20;
  static char* end = s + 20;
  if (x < 0) {
    putchar('-');
    x = -x;
  }
  do {
    *--it = x % 10 + '0';
    x /= 10;
  } while (x);
  for (; it < end; ++it) putchar(*it);
}
void write(const char* s) {
  for (; *s; ++s) putchar(*s);
}
template <>
void write(char* s) {
  write((const char*)s);
}
template <>
void write(char c) {
  putchar(c);
}
template <class T, class... Args>
void write(T x, Args... args) {
  write(x);
  write(args...);
}
void writeln() { putchar('\n'); }
template <class T, class... Args>
void writeln(T x, Args... args) {
  write(x);
  writeln(args...);
}
template <class Iterator>
bool input(Iterator st, Iterator ed) {
  for (; st != ed; ++st) {
    if (!read(*st)) return false;
  }
  return true;
}
template <class T>
bool input(T& a) {
  input(a.begin(), a.end());
}
template <class Iterator>
void print(Iterator st, Iterator ed, char c = ' ') {
  int flag = 0;
  for (; st != ed; ++st) {
    if (flag) write(c);
    flag = 1;
    write(*st);
  }
  writeln();
}
template <class T>
void print(const T& a, char c = ' ') {
  print(a.begin(), a.end(), c);
}
struct ender {
  ~ender() {
    if (os != obuf) unistd_write(STDOUT_FILENO, obuf, os - obuf);
  }
} __ender;
}  // namespace io
int64_t power(int64_t a, int64_t b, int64_t p) {
  if (!b) return 1;
  int64_t t = power(a, b >> 1, p);
  t = t * t % p;
  if (b & 1) t = t * a % p;
  return t;
}
mt19937 rd(chrono::steady_clock::now().time_since_epoch().count());
using namespace io;
template <class T>
inline void freshmin(T& a, const T& b) {
  if (a > b) a = b;
}
template <class T>
inline void freshmax(T& a, const T& b) {
  if (a < b) a = b;
}
const ll B = 31;
const ll MOD = 1000000007;
const int INF = 1000000010;
const ll INFll = 4000000000000000000LL;
const int MAXN = 3010;
int dx[] = {-1, 1, 0, 0, -1, -1, 1, 1};
int dy[] = {0, 0, -1, 1, -1, 1, -1, 1};
ld det(ld x1, ld y1, ld x2, ld y2, ld x3, ld y3) {
  return x1 * y2 - x2 * y1 + x2 * y3 - x3 * y2 + x3 * y1 - x1 * y3;
}
int n, m;
tuple<int, int, int> lx[MAXN], ly[MAXN];
bool ok[MAXN][MAXN][4];
bool u[MAXN][MAXN];
void forbid(int x1, int y1, int x2, int y2) {
  for (int k = 0; k < 4; ++k) {
    if (x1 + dx[k] == x2 && y1 + dy[k] == y2) ok[x1][y1][k] = 1;
    if (x2 + dx[k] == x1 && y2 + dy[k] == y1) ok[x2][y2][k] = 1;
  }
}
void solve() {
  read(n, m);
  set<int> Hx, Hy;
  Hx.insert(-INF);
  Hx.insert(INF);
  Hx.insert(0);
  Hy.insert(-INF);
  Hy.insert(INF);
  Hy.insert(0);
  for (int i = 1; i <= n; ++i) {
    int a, b, c;
    read(a, b, c);
    Hx.insert(a);
    Hx.insert(b);
    Hy.insert(c);
    lx[i] = {a, b, c};
  }
  for (int i = 1; i <= m; ++i) {
    int d, e, f;
    read(d, e, f);
    Hx.insert(d);
    Hy.insert(e);
    Hy.insert(f);
    ly[i] = {d, e, f};
  }
  vector<int> px(Hx.begin(), Hx.end());
  vector<int> py(Hy.begin(), Hy.end());
  int R = px.size() - 1, C = py.size() - 1;
  auto getx = [&](int x) {
    return lower_bound(px.begin(), px.end(), x) - px.begin();
  };
  auto gety = [&](int y) {
    return lower_bound(py.begin(), py.end(), y) - py.begin();
  };
  for (int i = 1; i <= n; ++i) {
    auto [a, b, c] = lx[i];
    a = getx(a);
    b = getx(b);
    c = gety(c);
    for (int x = a + 1; x <= b; ++x) {
      forbid(x, c, x, c + 1);
    }
  }
  for (int i = 1; i <= m; ++i) {
    auto [d, e, f] = ly[i];
    d = getx(d);
    e = gety(e);
    f = gety(f);
    for (int y = e + 1; y <= f; ++y) {
      forbid(d, y, d + 1, y);
    }
  }
  int sx = 0, sy = 0;
  sx = getx(sx);
  sy = gety(sy);
  queue<pii> q;
  u[sx][sy] = 1;
  q.push({sx, sy});
  while (!q.empty()) {
    auto [x, y] = q.front();
    q.pop();
    for (int k = 0; k < 4; ++k) {
      if (ok[x][y][k]) continue;
      int tx = x + dx[k], ty = y + dy[k];
      if (0 <= tx && tx < R && 0 <= ty && ty < C && !u[tx][ty]) {
        u[tx][ty] = 1;
        q.push({tx, ty});
      }
    }
  }
  ll res = 0;
  for (int i = 0; i < R; ++i)
    for (int j = 0; j < C; ++j) {
      if (u[i][j]) {
        if (i == 0 || i == R - 1 || j == 0 || j == C - 1) {
          writeln("INF");
          return;
        }
        res += (ll)abs(px[i + 1] - px[i]) * abs(py[j + 1] - py[j]);
      }
    }
  writeln(res);
}
int main() {
  int T = 1;
  for (int test = 1; test <= T; ++test) {
    solve();
  }
  return 0;
}
