Buggy python submission (verdict: Time Limit Exceeded):
import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
from collections import deque
def resolve():
    m, n = map(int, input().split())
    horizontal, vertical = [], []
    X, Y = {-INF, 0, INF}, {-INF, 0, INF}

    for _ in range(m):
        x0, x1, y = map(int, input().split())
        horizontal.append((x0, x1, y))
        X.add(x0)
        X.add(x1)
        Y.add(y)
    for _ in range(n):
        x, y0, y1 = map(int, input().split())
        vertical.append((x, y0, y1))
        X.add(x)
        Y.add(y0)
        Y.add(y1)
    X = sorted(X)
    Y = sorted(Y)

    # compress
    m, n = len(X), len(Y)
    cX = {v : i for i, v in enumerate(X)}
    cY = {v : i for i, v in enumerate(Y)}

    # make grid
    grid_hor = [[True] * n for _ in range(m)]
    grid_ver = [[True] * n for _ in range(m)]
    for x0, x1, y in horizontal:
        y = cY[y]
        for x in range(cX[x0], cX[x1]):
            grid_hor[x][y] = False
    for x, y0, y1 in vertical:
        x = cX[x]
        for y in range(cY[y0], cY[y1]):
            grid_ver[x][y] = False

    # bfs
    ans = 0
    queue = [(cX[0], cY[0])]
    used = [[False] * n for _ in range(m)]
    used[cX[0]][cY[0]] = True
    for x, y in queue:
        if x == 0 or y == 0 or x == m - 1 or y == n - 1:
            print("INF")
            return
        ans += (X[x + 1] - X[x]) * (Y[y + 1] - Y[y])
        # up
        if y + 1 < n and grid_hor[x][y + 1] and not used[x][y + 1]:
            used[x][y + 1] = True
            queue.append((x, y + 1))
        # down
        if y - 1 >= 0 and grid_hor[x][y] and not used[x][y - 1]:
            used[x][y - 1] = True
            queue.append((x, y - 1))
        # right
        if x + 1 < m and grid_ver[x + 1][y] and not used[x + 1][y]:
            used[x + 1][y] = True
            queue.append((x + 1, y))
        # left
        if x - 1 >= 0 and grid_ver[x][y] and not used[x - 1][y]:
            used[x - 1][y] = True
            queue.append((x - 1, y))

    print(ans)
resolve()

Fixed submission:
import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
from collections import deque
def resolve():
    m, n = map(int, input().split())
    horizontal, vertical = [], []
    X, Y = {-INF, 0, INF}, {-INF, 0, INF}

    for _ in range(m):
        x0, x1, y = map(int, input().split())
        horizontal.append((x0, x1, y))
        X.add(x0)
        X.add(x1)
        Y.add(y)
    for _ in range(n):
        x, y0, y1 = map(int, input().split())
        vertical.append((x, y0, y1))
        X.add(x)
        Y.add(y0)
        Y.add(y1)
    X = sorted(X)
    Y = sorted(Y)

    # compress
    m, n = len(X), len(Y)
    cX = {v : i for i, v in enumerate(X)}
    cY = {v : i for i, v in enumerate(Y)}

    # make grid
    grid_hor = [[True] * n for _ in range(m)]
    grid_ver = [[True] * n for _ in range(m)]
    for x0, x1, y in horizontal:
        y = cY[y]
        for x in range(cX[x0], cX[x1]):
            grid_hor[x][y] = False
    for x, y0, y1 in vertical:
        x = cX[x]
        for y in range(cY[y0], cY[y1]):
            grid_ver[x][y] = False

    # bfs
    ans = 0
    queue = deque([(cX[0], cY[0])])
    used = [[False] * n for _ in range(m)]
    used[cX[0]][cY[0]] = True
    while queue:
        x, y = queue.popleft()
        if x == 0 or y == 0 or x == m - 1 or y == n - 1:
            print("INF")
            return
        ans += (X[x + 1] - X[x]) * (Y[y + 1] - Y[y])
        # up
        if y + 1 < n and grid_hor[x][y + 1] and not used[x][y + 1]:
            used[x][y + 1] = True
            queue.append((x, y + 1))
        # down
        if y - 1 >= 0 and grid_hor[x][y] and not used[x][y - 1]:
            used[x][y - 1] = True
            queue.append((x, y - 1))
        # right
        if x + 1 < m and grid_ver[x + 1][y] and not used[x + 1][y]:
            used[x + 1][y] = True
            queue.append((x + 1, y))
        # left
        if x - 1 >= 0 and grid_ver[x][y] and not used[x - 1][y]:
            used[x - 1][y] = True
            queue.append((x - 1, y))

    print(ans)
resolve()

Buggy python submission (verdict: Time Limit Exceeded):
import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
def resolve():
    m, n = map(int, input().split())
    horizontal, vertical = [], []
    X, Y = {-INF, 0, INF}, {-INF, 0, INF}

    for _ in range(m):
        x0, x1, y = map(int, input().split())
        horizontal.append((x0, x1, y))
        X.add(x0)
        X.add(x1)
        Y.add(y)
    for _ in range(n):
        x, y0, y1 = map(int, input().split())
        vertical.append((x, y0, y1))
        X.add(x)
        Y.add(y0)
        Y.add(y1)
    X = sorted(X)
    Y = sorted(Y)

    # compress
    m, n = len(X), len(Y)
    cX = {v : i for i, v in enumerate(X)}
    cY = {v : i for i, v in enumerate(Y)}

    # make grid
    grid_hor = [[True] * n for _ in range(m)]
    grid_ver = [[True] * n for _ in range(m)]
    for x0, x1, y in horizontal:
        y = cY[y]
        for x in range(cX[x0], cX[x1]):
            grid_hor[x][y] = False
    for x, y0, y1 in vertical:
        x = cX[x]
        for y in range(cY[y0], cY[y1]):
            grid_ver[x][y] = False

    # dfs
    ans = 0
    stack = [(cX[0], cY[0])]
    used = [[False] * n for _ in range(m)]
    used[cX[0]][cY[0]] = True
    while stack:
        x, y = stack.pop()
        if x == 0 or y == 0 or x == m - 1 or y == n - 1:
            print("INF")
            return
        ans += (X[x + 1] - X[x]) * (Y[y + 1] - Y[y])
        # up
        if y + 1 < n and grid_hor[x][y + 1] and not used[x][y + 1]:
            used[x][y + 1] = True
            stack.append((x, y + 1))
        # down
        if y - 1 >= 0 and grid_hor[x][y] and not used[x][y - 1]:
            used[x][y - 1] = True
            stack.append((x, y - 1))
        # right
        if x + 1 < m and grid_ver[x + 1][y] and not used[x + 1][y]:
            used[x + 1][y] = True
            stack.append((x + 1, y))
        # left
        if x - 1 >= 0 and grid_ver[x][y] and not used[x - 1][y]:
            used[x - 1][y] = True
            stack.append((x - 1, y))

    print(ans)
resolve()

Fixed submission:
import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
from collections import deque
def resolve():
    m, n = map(int, input().split())
    horizontal, vertical = [], []
    X, Y = {-INF, 0, INF}, {-INF, 0, INF}

    for _ in range(m):
        x0, x1, y = map(int, input().split())
        horizontal.append((x0, x1, y))
        X.add(x0)
        X.add(x1)
        Y.add(y)
    for _ in range(n):
        x, y0, y1 = map(int, input().split())
        vertical.append((x, y0, y1))
        X.add(x)
        Y.add(y0)
        Y.add(y1)
    X = sorted(X)
    Y = sorted(Y)

    # compress
    m, n = len(X), len(Y)
    cX = {v : i for i, v in enumerate(X)}
    cY = {v : i for i, v in enumerate(Y)}

    # make grid
    grid_hor = [[True] * n for _ in range(m)]
    grid_ver = [[True] * n for _ in range(m)]
    for x0, x1, y in horizontal:
        y = cY[y]
        for x in range(cX[x0], cX[x1]):
            grid_hor[x][y] = False
    for x, y0, y1 in vertical:
        x = cX[x]
        for y in range(cY[y0], cY[y1]):
            grid_ver[x][y] = False

    # bfs
    ans = 0
    queue = deque([(cX[0], cY[0])])
    used = [[False] * n for _ in range(m)]
    used[cX[0]][cY[0]] = True
    while queue:
        x, y = queue.popleft()
        if x == 0 or y == 0 or x == m - 1 or y == n - 1:
            print("INF")
            return
        ans += (X[x + 1] - X[x]) * (Y[y + 1] - Y[y])
        # up
        if y + 1 < n and grid_hor[x][y + 1] and not used[x][y + 1]:
            used[x][y + 1] = True
            queue.append((x, y + 1))
        # down
        if y - 1 >= 0 and grid_hor[x][y] and not used[x][y - 1]:
            used[x][y - 1] = True
            queue.append((x, y - 1))
        # right
        if x + 1 < m and grid_ver[x + 1][y] and not used[x + 1][y]:
            used[x + 1][y] = True
            queue.append((x + 1, y))
        # left
        if x - 1 >= 0 and grid_ver[x][y] and not used[x - 1][y]:
            used[x - 1][y] = True
            queue.append((x - 1, y))

    print(ans)
resolve()

Buggy python submission (verdict: Time Limit Exceeded):
import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
def resolve():
    m, n = map(int, input().split())
    horizontal, vertical = [], []
    X, Y = {-INF, 0, INF}, {-INF, 0, INF}

    for _ in range(m):
        x0, x1, y = map(int, input().split())
        horizontal.append((x0, x1, y))
        X.add(x0)
        X.add(x1)
        Y.add(y)
    for _ in range(n):
        x, y0, y1 = map(int, input().split())
        vertical.append((x, y0, y1))
        X.add(x)
        Y.add(y0)
        Y.add(y1)
    X = sorted(X)
    Y = sorted(Y)

    # compress
    m, n = len(X), len(Y)
    cX = {v : i for i, v in enumerate(X)}
    cY = {v : i for i, v in enumerate(Y)}

    # make grid
    grid_hor = [[True] * n for _ in range(m)]
    grid_ver = [[True] * n for _ in range(m)]
    for x0, x1, y in horizontal:
        y = cY[y]
        for x in range(cX[x0], cX[x1]):
            grid_hor[x][y] = False
    for x, y0, y1 in vertical:
        x = cX[x]
        for y in range(cY[y0], cY[y1]):
            grid_ver[x][y] = False

    # dfs
    ans = 0
    stack = [(cX[0], cY[0])]
    used = [[False] * n for _ in range(m)]
    while stack:
        x, y = stack.pop()
        if used[x][y]:
            continue
        used[x][y] = True
        if x == 0 or y == 0 or x == m - 1 or y == n - 1:
            print("INF")
            return
        ans += (X[x + 1] - X[x]) * (Y[y + 1] - Y[y])
        # up
        if y + 1 < n and grid_hor[x][y + 1]:
            stack.append((x, y + 1))
        # down
        if y - 1 >= 0 and grid_hor[x][y]:
            stack.append((x, y - 1))
        # right
        if x + 1 < m and grid_ver[x + 1][y]:
            stack.append((x + 1, y))
        # left
        if x - 1 >= 0 and grid_ver[x][y]:
            stack.append((x - 1, y))

    print(ans)
resolve()

Fixed submission:
import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
from collections import deque
def resolve():
    m, n = map(int, input().split())
    horizontal, vertical = [], []
    X, Y = {-INF, 0, INF}, {-INF, 0, INF}

    for _ in range(m):
        x0, x1, y = map(int, input().split())
        horizontal.append((x0, x1, y))
        X.add(x0)
        X.add(x1)
        Y.add(y)
    for _ in range(n):
        x, y0, y1 = map(int, input().split())
        vertical.append((x, y0, y1))
        X.add(x)
        Y.add(y0)
        Y.add(y1)
    X = sorted(X)
    Y = sorted(Y)

    # compress
    m, n = len(X), len(Y)
    cX = {v : i for i, v in enumerate(X)}
    cY = {v : i for i, v in enumerate(Y)}

    # make grid
    grid_hor = [[True] * n for _ in range(m)]
    grid_ver = [[True] * n for _ in range(m)]
    for x0, x1, y in horizontal:
        y = cY[y]
        for x in range(cX[x0], cX[x1]):
            grid_hor[x][y] = False
    for x, y0, y1 in vertical:
        x = cX[x]
        for y in range(cY[y0], cY[y1]):
            grid_ver[x][y] = False

    # bfs
    ans = 0
    queue = deque([(cX[0], cY[0])])
    used = [[False] * n for _ in range(m)]
    used[cX[0]][cY[0]] = True
    while queue:
        x, y = queue.popleft()
        if x == 0 or y == 0 or x == m - 1 or y == n - 1:
            print("INF")
            return
        ans += (X[x + 1] - X[x]) * (Y[y + 1] - Y[y])
        # up
        if y + 1 < n and grid_hor[x][y + 1] and not used[x][y + 1]:
            used[x][y + 1] = True
            queue.append((x, y + 1))
        # down
        if y - 1 >= 0 and grid_hor[x][y] and not used[x][y - 1]:
            used[x][y - 1] = True
            queue.append((x, y - 1))
        # right
        if x + 1 < m and grid_ver[x + 1][y] and not used[x + 1][y]:
            used[x + 1][y] = True
            queue.append((x + 1, y))
        # left
        if x - 1 >= 0 and grid_ver[x][y] and not used[x - 1][y]:
            used[x - 1][y] = True
            queue.append((x - 1, y))

    print(ans)
resolve()