#-swank
(unless (member :child-sbcl *features*)
  (quit
   :unix-status
   (process-exit-code
    (run-program *runtime-pathname*
                 `("--control-stack-size" "256MB"
                   "--noinform" "--disable-ldb" "--lose-on-corruption" "--end-runtime-options"
                   "--eval" "(push :child-sbcl *features*)"
                   "--script" ,(namestring *load-pathname*))
                 :output t :error t :input t))))
(eval-when (:compile-toplevel :load-toplevel :execute)
  (sb-int:defconstant-eqx opt
    #+swank '(optimize (speed 3) (safety 2))
    #-swank '(optimize (speed 3) (safety 0) (debug 0))
    #'equal)
  #+swank (ql:quickload '(:cl-debug-print :fiveam) :silent t)
  #-swank (set-dispatch-macro-character
           #\# #\> (lambda (s c p) (declare (ignore c p)) `(values ,(read s nil nil t)))))
#+swank (cl-syntax:use-syntax cl-debug-print:debug-print-syntax)
#-swank (disable-debugger) ; for CS Academy

;; BEGIN_INSERTED_CONTENTS
(macrolet ((def (name fname)
             `(define-modify-macro ,name (new-value) ,fname)))
  (def minf min)
  (def maxf max)
  (def mulf *)
  (def divf /)
  (def iorf logior)
  (def xorf logxor)
  (def andf logand))

(defmacro dbg (&rest forms)
  #+swank
  (if (= (length forms) 1)
      `(format *error-output* "~A => ~A~%" ',(car forms) ,(car forms))
      `(format *error-output* "~A => ~A~%" ',forms `(,,@forms)))
  #-swank (declare (ignore forms)))

(defmacro define-int-types (&rest bits)
  `(progn
     ,@(mapcar (lambda (b) `(deftype ,(intern (format nil "UINT~A" b)) () '(unsigned-byte ,b))) bits)
     ,@(mapcar (lambda (b) `(deftype ,(intern (format nil "INT~A" b)) () '(signed-byte ,b))) bits)))
(define-int-types 2 4 7 8 15 16 31 32 62 63 64)

(declaim (inline println))
(defun println (obj &optional (stream *standard-output*))
  (let ((*read-default-float-format* 'double-float))
    (prog1 (princ obj stream) (terpri stream))))

(defconstant +mod+ 1000000007)

;;;
;;; Body
;;;

(defconstant +neg-inf+ #x-80000000)
(defconstant +pos-inf+ #x7fffffff)

(defun solve (n m as bs cs ds es fs graph)
  (declare #.OPT
           (uint31 n m)
           ((simple-array int32 (*)) as bs cs ds es fs)
           ((simple-array list (*)) graph))
  (labels ((to-idx (i j) (+ i (* j 1001)))
           (rev (idx)
             (multiple-value-bind (quot rem) (floor idx 1001)
               (values rem quot))))
    (declare (inline to-idx rev))
    (loop
      for i from 0 to n
      do (loop
           for j from 0 to m
           do (let ((d1 (aref ds j))
                    (d2 (aref ds (+ j 1))))
                (when (< i n)
                  (let ((a (aref as (+ i 1)))
                        (b (aref bs (+ i 1))))
                    (unless (<= a d1 d2 b)
                      (push (to-idx (+ i 1) j) (aref graph (to-idx i j))))))
                (when (> i 0)
                  (let ((a (aref as i))
                        (b (aref bs i)))
                    (unless (<= a d1 d2 b)
                      (push (to-idx (- i 1) j) (aref graph (to-idx i j)))))))
              (let ((c1 (aref cs i))
                    (c2 (aref cs (+ i 1))))
                (when (< j m)
                  (let ((e (aref es (+ j 1)))
                        (f (aref fs (+ j 1))))
                    (unless (<= e c1 c2 f)
                      (push (to-idx i (+ j 1)) (aref graph (to-idx i j))))))
                (when (> j 0)
                  (let ((e (aref es j))
                        (f (aref fs j)))
                    (unless (<= e c1 c2 f)
                      (push (to-idx i (- j 1)) (aref graph (to-idx i j)))))))))
    (let* ((init-i (- (position-if (lambda (c) (>= c 0)) cs) 1))
           (init-j (- (position-if (lambda (d) (>= d 0)) ds) 1))
           (init (to-idx init-i init-j))
           (marked (make-array #.(* 1001 1001) :element-type 'bit :initial-element 0)))
      (sb-int:named-let dfs ((v init))
        (setf (aref marked v) 1)
        (dolist (next (aref graph v))
          (when (zerop (aref marked next))
            (dfs next))))
      (when (and (loop for i to n always (= 1 (aref marked (to-idx i 0))))
                 (loop for i to n always (= 1 (aref marked (to-idx i m))))
                 (loop for j to m always (= 1 (aref marked (to-idx 0 j))))
                 (loop for j to m always (= 1 (aref marked (to-idx n j)))))
        (return-from solve nil))
      (let ((res 0))
        (dotimes (idx (length marked))
          (when (= 1 (aref marked idx))
            (multiple-value-bind (i j) (rev idx)
              (let ((c1 (aref cs i))
                    (c2 (aref cs (+ i 1)))
                    (d1 (aref ds j))
                    (d2 (aref ds (+ j 1))))
                (incf res (* (- c2 c1) (- d2 d1)))))))
        res))))

(declaim (inline intersect-p))
(defun intersect-p (l1 r1 l2 r2)
  (and (<= l1 r2) (<= l2 r1)))

(defun main ()
  (declare #.OPT)
  (let* ((n (read))
         (m (read))
         (abcs (make-array (+ n 2)))
         (defs (make-array (+ m 2)))
         (as (make-array (+ n 2) :element-type 'int32 :initial-element 0))
         (bs (make-array (+ n 2) :element-type 'int32 :initial-element 0))
         (cs (make-array (+ n 2) :element-type 'int32 :initial-element 0))
         (ds (make-array (+ m 2) :element-type 'int32 :initial-element 0))
         (es (make-array (+ m 2) :element-type 'int32 :initial-element 0))
         (fs (make-array (+ m 2) :element-type 'int32 :initial-element 0))
         (graph (make-array #.(* 1001 1001) :element-type 'list :initial-element nil)))
    (declare (uint16 n m))
    (dotimes (i n)
      (setf (aref abcs i) (list (read) (read) (read))))
    (setf (aref abcs n) (list 0 0 +neg-inf+)
          (aref abcs (+ n 1)) (list 0 0 +pos-inf+))
    (dotimes (i m)
      (setf (aref defs i) (list (read) (read) (read))))
    (setf (aref defs m) (list +neg-inf+ 0 0)
          (aref defs (+ m 1)) (list +pos-inf+ 0 0))
    (setq abcs (sort abcs (lambda (p1 p2)
                            (or (< (third p1) (third p2))
                                (and (= (third p1) (third p2))
                                     (< (second p1) (second p2)))))))
    (setq defs (sort defs (lambda (p1 p2)
                            (or (< (first p1) (first p2))
                                (and (= (first p1) (first p2))
                                     (< (third p1) (third p2)))))))
    (dotimes (i1 (+ n 2))
      (destructuring-bind (a1 b1 c1) (aref abcs i1)
        (declare (int32 a1 b1 c1))
        (loop for i2 from (+ i1 1) below (+ n 2)
              for (a2 b2 c2) of-type (int32 int32 int32) = (aref abcs i2)
              when (and (= c1 c2) (intersect-p a1 b1 a2 b2))
              do (minf a1 a2)
                 (maxf b1 b2))
        (setf (aref as i1) a1
              (aref bs i1) b1
              (aref cs i1) c1)))
    (dotimes (j1 (+ m 2))
      (destructuring-bind (d1 e1 f1) (aref defs j1)
        (declare (int32 d1 e1 f1))
        (loop for j2 from (+ j1 1) below (+ m 2)
              for (d2 e2 f2) of-type (int32 int32 int32) = (aref defs j2)
              when (and (= d1 d2) (intersect-p e1 f1 e2 f2))
              do (minf e1 e2)
                 (maxf f1 f2))
        (setf (aref ds j1) d1
              (aref es j1) e1
              (aref fs j1) f1)))
    (println (or (solve n m as bs cs ds es fs graph)
                 "INF"))))

#-swank (main)

;;;
;;; Test and benchmark
;;;

#+swank
(defun io-equal (in-string out-string &key (function #'main) (test #'equal))
  "Passes IN-STRING to *STANDARD-INPUT*, executes FUNCTION, and returns true if
the string output to *STANDARD-OUTPUT* is equal to OUT-STRING."
  (labels ((ensure-last-lf (s)
             (if (eql (uiop:last-char s) #\Linefeed)
                 s
                 (uiop:strcat s uiop:+lf+))))
    (funcall test
             (ensure-last-lf out-string)
             (with-output-to-string (out)
               (let ((*standard-output* out))
                 (with-input-from-string (*standard-input* (ensure-last-lf in-string))
                   (funcall function)))))))

#+swank
(defun get-clipbrd ()
  (with-output-to-string (out)
    (run-program "powershell.exe" '("-Command" "Get-Clipboard") :output out :search t)))

#+swank (defparameter *this-pathname* (uiop:current-lisp-file-pathname))
#+swank (defparameter *dat-pathname* (uiop:merge-pathnames* "test.dat" *this-pathname*))

#+swank
(defun run (&optional thing (out *standard-output*))
  "THING := null | string | symbol | pathname

null: run #'MAIN using the text on clipboard as input.
string: run #'MAIN using the string as input.
symbol: alias of FIVEAM:RUN!.
pathname: run #'MAIN using the text file as input."
  (let ((*standard-output* out))
    (etypecase thing
      (null
       (with-input-from-string (*standard-input* (delete #\Return (get-clipbrd)))
         (main)))
      (string
       (with-input-from-string (*standard-input* (delete #\Return thing))
         (main)))
      (symbol (5am:run! thing))
      (pathname
       (with-open-file (*standard-input* thing)
         (main))))))

#+swank
(defun gen-dat ()
  (uiop:with-output-file (out *dat-pathname* :if-exists :supersede)
    (format out "")))

#+swank
(defun bench (&optional (out (make-broadcast-stream)))
  (time (run *dat-pathname* out)))

;; To run: (5am:run! :sample)
#+swank
(it.bese.fiveam:test :sample
  (it.bese.fiveam:is
   (common-lisp-user::io-equal "5 6
1 2 0
0 1 1
0 2 2
-3 4 -1
-2 6 3
1 0 1
0 1 2
2 0 2
-1 -4 5
3 -2 4
1 2 4
"
    "13
"))
  (it.bese.fiveam:is
   (common-lisp-user::io-equal "6 1
-3 -1 -2
-3 -1 1
-2 -1 2
1 4 -2
1 4 -1
1 4 1
3 1 4
"
    "INF
")))


Measured memory_bytes: 154352