# coding: utf-8
import sys
#from operator import itemgetter
sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
#from heapq import heappop, heappush
#from collections import defaultdict
sys.setrecursionlimit(10**7)
#import math
#from itertools import product#accumulate, combinations, product
import bisect# lower_bound etc
#import numpy as np
#from copy import deepcopy
from collections import deque
def run():
    N,M, *A2F = map(int, read().split())
    A = A2F[0:3*N:3]
    B = A2F[1:3*N+1:3]
    C = A2F[2:3*N+2:3]
    D = A2F[3*N::3]
    E = A2F[3*N+1::3]
    F = A2F[3*N+2::3]

    x_list, y_list = sorted(list(set(A+B+D))), sorted(list(set(C+E+F)))
    max_x = len(x_list)
    max_y = len(y_list)
    #x_dic = {val:idx for idx, val in enumerate(x_list)}
    #y_dic = {val:idx for idx, val in enumerate(y_list)}
    #print(x_list)
    tmp1 = deque(x_list)
    tmp1.appendleft(x_list[0])
    tmp2 = x_list[:]
    tmp2.append(x_list[-1])
    x_grid = []
    for t1, t2 in zip(tmp1, tmp2):
        x_grid.append(t2-t1)
    #print(x_grid)
    tmp1 = deque(y_list)
    tmp1.appendleft(y_list[0])
    tmp2 = y_list[:]
    tmp2.append(y_list[-1])
    y_grid = []
    for t1, t2 in zip(tmp1, tmp2):
        y_grid.append(t2-t1)
    #print(y_list)
    #print(y_grid)
    #grid = np.dot(x_grid.reshape(-1,1), y_grid.reshape(1,-1)).tolist()
    seen = [[False] * (max_y+1) for _ in range(max_x+1)]
    walls = [[0] * (max_y+1) for _ in range(max_x+1)]
    for a,b,c in zip(A,B,C):
        a_i = bisect.bisect_left(x_list, a)
        b_i = bisect.bisect_left(x_list, b)
        c_i = bisect.bisect_left(y_list, c)
        for _x in range(a_i+1, b_i+1):
            walls[_x][c_i] |= 1 << 1
            walls[_x][c_i+1] |= 1 << 3

    for d,e,f in zip(D,E,F):
        d_i = bisect.bisect_left(x_list, d)
        e_i = bisect.bisect_left(y_list, e)
        f_i = bisect.bisect_left(y_list, f)
        for _y in range(e_i+1, f_i+1):
            walls[d_i][_y] |= 1 << 0
            walls[d_i+1][_y] |= 1 << 2

    start_x = bisect.bisect_left(x_list, 0)
    start_y = bisect.bisect_left(y_list, 0)

    queue = deque([])
    queue.append((start_x, start_y))
    seen[start_x][start_y] = True
    ret = x_grid[start_x] * y_grid[start_y]
    if not ret:
        print('INF')
        return None

    while queue:
        x, y = queue.popleft()
        for w_i, i, j in ((1, 0, 1), (3, 0, -1), (0, 1, 0), (2, -1, 0)):
            n_x, n_y = x + i, y + j
            if not seen[n_x][n_y] and not walls[x][y] & (1 << w_i):
                queue.append((n_x, n_y))
                seen[n_x][n_y] = True
                ret += x_grid[n_x] * y_grid[n_y]
                if x_grid[n_x] == 0 or y_grid[n_y] == 0:
                    print('INF')
                    return None

    print(int(ret))

if __name__ == "__main__":
    run()
