#-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))

(declaim (inline bisect-left))
(defun bisect-left (target value &key (start 0) end (order #'<) (key #'identity))
  "TARGET := vector | function (taking an integer argument)
ORDER := strict order

Analogue of lower_bound() of C++ or bisect_left() of Python: Returns the
smallest index (or input) i that fulfills TARGET[i] >= VALUE, where '>=' is the
complement of ORDER. In other words, this function returns the leftmost index at
which VALUE can be inserted with keeping the order. Therefore, TARGET must be
monotonically non-decreasing with respect to ORDER.

- This function returns END if VALUE exceeds TARGET[END-1]. 
- The range [START, END) is half-open.
- END must be explicitly specified if TARGET is function.
- KEY is applied to each element of TARGET before comparison."
  (declare (function key order)
           (integer start)
           ((or null integer) end))
  (macrolet
      ((frob (accessor &optional declaration)
         `(labels
              ((%bisect-left (ng ok)
                 ;; TARGET[OK] >= VALUE always holds (assuming
                 ;; TARGET[END] = +infinity)
                 ,@(when declaration (list declaration))
                 (if (<= (- ok ng) 1)
                     ok
                     (let ((mid (ash (+ ng ok) -1)))
                       (if (funcall order (funcall key (,accessor target mid)) value)
                           (%bisect-left mid ok)
                           (%bisect-left ng mid))))))
            (assert (<= start end))
            (%bisect-left (- start 1) end))))
    (etypecase target
      (vector
       (let ((end (or end (length target))))
         (frob aref (declare ((integer -1 (#.most-positive-fixnum)) ng ok)))))
      (function
       (assert end () "Requires END argument if TARGET is a function.")
       (frob funcall)))))

(declaim (inline bisect-right))
(defun bisect-right (target value &key (start 0) end (order #'<) (key #'identity))
  "TARGET := vector | function (taking an integer argument)
ORDER := strict order

Analogue of upper_bound() of C++ or bisect_right() of Python: Returns the
smallest index (or input) i that fulfills TARGET[i] > VALUE. In other words,
this function returns the rightmost index at which VALUE can be inserted with
keeping the order. Therefore, TARGET must be monotonically non-decreasing with
respect to ORDER.

- This function returns END if VALUE >= TARGET[END-1].
- The range [START, END) is half-open.
- END must be explicitly specified if TARGET is function.
- KEY is applied to each element of TARGET before comparison."
  (declare (function key order)
           (integer start)
           ((or null integer) end))
  (macrolet
      ((frob (accessor &optional declaration)
         `(labels
              ((%bisect-right (ng ok)
                 ;; TARGET[OK] > VALUE always holds (assuming
                 ;; TARGET[END] = +infinity)
                 ,@(when declaration (list declaration))
                 (if (<= (- ok ng) 1)
                     ok
                     (let ((mid (ash (+ ng ok) -1)))
                       (if (funcall order value (funcall key (,accessor target mid)))
                           (%bisect-right ng mid)
                           (%bisect-right mid ok))))))
            (assert (<= start end))
            (%bisect-right (- start 1) end))))
    (etypecase target
      (vector
       (let ((end (or end (length target))))
         (frob aref (declare ((integer -1 (#.array-total-size-limit)) ng ok)))))
      (function
       (assert end () "Requires END argument if TARGET is a function.")
       (frob funcall)))))

;;;
;;; Sort multiple vectors
;;;

;; TODO: throw an error if there are two ore more identical vectors in the given
;; vectors

(declaim (inline %median3))
(defun %median3 (x y z order)
  (if (funcall order x y)
      (if (funcall order y z)
          y
          (if (funcall order z x)
              x
              z))
      (if (funcall order z y)
          y
          (if (funcall order x z)
              x
              z))))

(defun parallel-sort! (vector order &rest vectors)
  "Destructively sorts VECTOR w.r.t. ORDER and applies the same permutation to
all the vectors in VECTORS.

Note: not randomized; shuffle the inputs if necessary"
  (declare (vector vector))
  (labels
      ((recur (left right)
         (when (< left right)
           (let* ((l left)
                  (r right)
                  (pivot (%median3 (aref vector l)
                                   (aref vector (ash (+ l r) -1))
                                   (aref vector r)
                                   order)))
             (declare ((integer 0 #.most-positive-fixnum) l r))
             (loop (loop while (funcall order (aref vector l) pivot)
                         do (incf l 1))
                   (loop while (funcall order pivot (aref vector r))
                         do (decf r 1))
                   (when (>= l r)
                     (return))
                   (rotatef (aref vector l) (aref vector r))
                   (dolist (v vectors)
                     (rotatef (aref v l) (aref v r)))
                   (incf l 1)
                   (decf r 1))
             (recur left (- l 1))
             (recur (+ r 1) right)))))
    (recur 0 (- (length vector) 1))
    vector))

#+sbcl
(eval-when (:compile-toplevel :load-toplevel :execute)
  (sb-c:define-source-transform parallel-sort! (vector order &rest vectors)
    (let ((vec (gensym))
          (vecs (loop for _ in vectors collect (gensym))))
      `(let ((,vec ,vector)
             ,@(loop for v in vectors
                     for sym in vecs
                     collect `(,sym ,v)))
         (labels
             ((recur (left right)
                (when (< left right)
                  (let* ((l left)
                         (r right)
                         (pivot (%median3 (aref ,vec l)
                                          (aref ,vec (ash (+ l r) -1))
                                          (aref ,vec r)
                                          ,order)))
                    (declare ((integer 0 #.most-positive-fixnum) l r))
                    (loop (loop while (funcall ,order (aref ,vec l) pivot)
                                do (incf l 1))
                          (loop while (funcall ,order pivot (aref ,vec r))
                                do (decf r 1))
                          (when (>= l r)
                            (return))
                          (rotatef (aref ,vec l) (aref ,vec r))
                          ,@(loop for sym in vecs
                                  collect `(rotatef (aref ,sym l) (aref ,sym r)))
                          (incf l 1)
                          (decf r 1))
                    (recur left (- l 1))
                    (recur (+ r 1) right)))))
           (recur 0 (- (length ,vec) 1))
           ,vec)))))

(defun parallel-shuffle! (vector &rest vectors)
   "Destructively shuffles VECTOR and applies the same permutation to all the
vectors in VECTORS."
  (loop for i from (- (length vector) 1) above 0
        for j = (random (+ i 1))
        do (rotatef (aref vector i) (aref vector j))
           (dolist (v vectors)
             (rotatef (aref v i) (aref v j)))
        finally (return vector)))

#+sbcl
(eval-when (:compile-toplevel :load-toplevel :execute)
  (sb-c:define-source-transform parallel-shuffle! (vector &rest vectors)
    (let ((vec (gensym))
          (vecs (loop for _ in vectors collect (gensym))))
      `(let ((,vec ,vector)
             ,@(loop for v in vectors
                     for sym in vecs
                     collect `(,sym ,v)))
         (loop for i from (- (length ,vec) 1) above 0
               for j = (random (+ i 1))
               do (rotatef (aref ,vec i) (aref ,vec j))
                  ,@(loop for sym in vecs
                          collect `(rotatef (aref ,sym i) (aref ,sym j)))
               finally (return ,vec))))))

(in-package :cl-user)

(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 (- (bisect-left cs 0) 1))
           (init-j (- (bisect-left ds 0) 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: 154564