# 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 = [x_list[0]]+x_list
    tmp2 = x_list+[x_list[-1]]
    x_grid = []
    for t1, t2 in zip(tmp1, tmp2):
        x_grid.append(t2-t1)
    #print(x_grid)
    tmp1 = [y_list[0]]+y_list
    tmp2 = y_list+[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 = x_dic[a]
        b_i = x_dic[b]
        c_i = y_dic[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 = x_dic[d]
        e_i = y_dic[e]
        f_i = y_dic[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]

    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 seen[n_x][n_y]:continue
            if walls[x][y] & (1 << w_i):continue
            if 0 <= n_x <= max_x and 0 <= n_y <= max_y:
                queue.append((n_x, n_y))
                seen[n_x][n_y] = True
                next_sq = x_grid[n_x] * y_grid[n_y]
                ret += next_sq
                if not next_sq:
                    print('INF')
                    return None
    print(int(ret))

if __name__ == "__main__":
    run()
