#!/usr/bin/env python3
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**8)
INF = float("inf")


class UnionFind(object):
    def __init__(self, N):
        self.tree = list(range(N))

    def root(self, i):
        if self.tree[i] == i:
            return i
        else:
            self.tree[i] = self.root(self.tree[i])
            return self.tree[i]

    def same(self, x, y):
        return self.root(x) == self.root(y)

    def unite(self, x, y):
        x = self.root(x)
        y = self.root(y)
        if x != y:
            self.tree[x] = y


def main():
    # 1. 座圧します
    # 2. 座標ごとに線分が乗っているかどうかを示す配列を作ります
    # 3. 面ごとに同じ領域内かどうか、グルーピングします
    # 4. 牛と同じグループの面積を数え上げます

    # 入力
    N, M = map(int, readline().split())
    ABC = [0]*N
    for i in range(N):
        ABC[i] = list(map(int, readline().split()))
    DEF = [0]*M
    for i in range(M):
        DEF[i] = list(map(int, readline().split()))

    # 1. 座圧
    x_coord, y_coord = {-INF, 0, INF}, {-INF, 0, INF}
    for a, b, c in ABC:
        x_coord.add(a)
        x_coord.add(b)
        y_coord.add(c)
    for d, e, f in DEF:
        x_coord.add(d)
        y_coord.add(e)
        y_coord.add(f)

    mx = list(sorted(x_coord))
    my = list(sorted(y_coord))
    invx, invy = {}, {}
    for i, x in enumerate(sorted(x_coord)):
        invx[x] = i
    for i, y in enumerate(sorted(y_coord)):
        invy[y] = i

    # 2. 線分ごとに線分が乗っているかどうかを示す配列を作ります(imos法)
    # segx[i][j]は座標(i, j)と(i+1, j)をつなぐ線分
    # segy[i][j]は座標(i, j)と(i, j+1)をつなぐ線分
    segx = [[0]*len(my) for _ in range(len(mx))]
    segy = [[0]*len(my) for _ in range(len(mx))]

    for i in range(N):
        a, b, c = ABC[i]
        segx[invx[a]][invy[c]-1] += 1
        segx[invx[b]][invy[c]-1] -= 1
    for i in range(len(mx)-1):
        for j in range(len(my)):
            segx[i+1][j] += segx[i][j]

    for i in range(M):
        d, e, f = DEF[i]
        segy[invx[d]-1][invy[e]] += 1
        segy[invx[d]-1][invy[f]] -= 1
    for i in range(len(invx)):
        for j in range(len(invy)-1):
            segy[i][j+1] += segy[i][j]

    # 3. 面ごとに同じ領域内かどうか、グルーピングします
    # UnionFindで検査していく
    uf = UnionFind(len(mx)*len(my))

    def idx(x, y):
        return x+y*len(mx)
    # segx[i][j]は座標(i, j)と(i+1, j)をつなぐ線分であり
    # 面[i][j-1]と面[i][j]の境界にあたる
    # segy[i][j]は座標(i, j)と(i, j+1)をつなぐ線分であり
    # 面[i-1][j]と面[i][j]の境界にあたる
    for i in range(len(mx)):
        for j in range(len(my)):
            if i+1 < len(mx) and segy[i][j] == 0:
                uf.unite(idx(i, j), idx(i+1, j))
            if j+1 < len(my) and segx[i][j] == 0:
                uf.unite(idx(i, j+1), idx(i, j))

    # 4. 牛と同じグループの面積を数え上げます
    # 無限の彼方と同じグル-プなら、INF
    ushi = idx(invx[0], invy[0])
    if uf.same(ushi, idx(0, 0)):
        print("INF")
        return

    area = 0
    for i in range(len(mx)-1):
        for j in range(len(my)-1):
            if uf.same(ushi, idx(i, j)):
                area += (mx[i+1]-mx[i])*(my[j+1]-my[j])
    print(area)
    return


if __name__ == '__main__':
    main()
