(eval-when (:compile-toplevel :load-toplevel :execute)
  (defparameter OPT
    #+swank '(optimize (speed 3) (safety 2))
    #-swank '(optimize (speed 3) (safety 0) (debug 0)))
  #+swank (progn (ql:quickload '(:cl-debug-print :fiveam))
                 (shadow :run)
                 (use-package :fiveam)))
#+swank (cl-syntax:use-syntax cl-debug-print:debug-print-syntax)

;; BEGIN_INSERTED_CONTENTS
(declaim (inline split-ints-into-vector))
(defun split-ints-into-vector (string dest-vector &key (offset 0))
  (declare (string string)
           ((simple-array * (*)) dest-vector)
           ((integer 0 #.most-positive-fixnum) offset))
  (loop for idx from offset below (length dest-vector)
        for pos1 = 0 then (1+ pos2)
        for pos2 = (position #\space string :start pos1 :test #'char=)
        do (setf (aref dest-vector idx)
                 (parse-integer string :start pos1 :end pos2))
        finally (return dest-vector)))

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

(defmacro println (obj &optional (stream '*standard-output*))
  `(let ((*read-default-float-format* 'double-float))
     (prog1 (princ ,obj ,stream) (terpri ,stream))))

;; Hauptteil

(defmacro with-collecting (&body body)
  (let ((list (gensym))
        (head (gensym))
        (length (gensym)))
    `(let* ((,list (list :dummy-element))
            (,head ,list)
            (,length 0))
       (labels ((collect (x)
                  (setf (cdr ,list) (list x))
                  (setf ,list (cdr ,list))
                  (incf ,length)))
         ,@body
         (values (cdr ,head) ,length)))))

(defun main ()
  (let* ((h (read))
         (w (read))
         (matrix (make-array (list h w) :element-type 'uint4))
         (row (make-array w :element-type 'uint4)))
    (dotimes (i h)
      (split-ints-into-vector (read-line) row)
      (dotimes (j w)
        (setf (aref matrix i j) (aref row j))))
    (multiple-value-bind (operations n)
        (with-collecting
          (dotimes (i h)
            (cond ((zerop i)
                   (loop for j from 0 below (- w 1)
                         when (oddp (aref matrix i j))
                         do (decf (aref matrix i j))
                            (incf (aref matrix i (+ j 1)))
                            (collect (list i j i (+ j 1)))))
                  ((oddp i)
                   (when (oddp (aref matrix (- i 1) (- w 1)))
                     (decf (aref matrix (- i 1) (- w 1)))
                     (incf (aref matrix i (- w 1)))
                     (collect (list (- i 1) (- w 1) i (- w 1))))
                   (loop for j from (- w 1) above 0
                         when (oddp (aref matrix i j))
                         do (decf (aref matrix i j))
                            (incf (aref matrix i (- j 1)))
                            (collect (list i j i (- j 1)))))
                  ((evenp i)
                   (when (oddp (aref matrix (- i 1) 0))
                     (decf (aref matrix (- i 1) 0))
                     (incf (aref matrix i 0))
                     (collect (list (- i 1) 0 i 0)))
                   (loop for j from 0 below (- w 1)
                         when (oddp (aref matrix i j))
                         do (decf (aref matrix i j))
                            (incf (aref matrix i (+ j 1)))
                            (collect (list i j i (+ j 1))))))))
      (println n)
      (dolist (op operations)
        (destructuring-bind (i1 j1 i2 j2) op
          (format t "~A ~A ~A ~A~%" (+ i1 1) (+ j1 1) (+ i2 1) (+ j2 1)))))))

#-swank(main)


Measured memory_bytes: 41192