(in-package :cl-user)
(eval-when (:compile-toplevel :load-toplevel :execute)
  (defparameter *opt*
    #+swank '(optimize (speed 3) (safety 2))
    #-swank '(optimize (speed 3) (safety 0) (debug 0)))
  #+swank (ql:quickload '(:cl-debug-print :fiveam :cp/util) :silent t)
  #+swank (use-package :cp/util :cl-user)
  #-swank (set-dispatch-macro-character
           #\# #\> (lambda (s c p) (declare (ignore c p)) `(values ,(read s nil nil t))))
  #+sbcl (setq *random-state* (seed-random-state (nth-value 1 (get-time-of-day)))))
#-swank (eval-when (:compile-toplevel)
          (setq *break-on-signals* '(and warning (not style-warning))))
#+swank (set-dispatch-macro-character #\# #\> #'cl-debug-print:debug-print-reader)

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

(defconstant +mod+ 1000000007)

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

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

;; BEGIN_INSERTED_CONTENTS
(defpackage :cp/read-fixnum
  (:use :cl)
  (:export #:read-fixnum))
(in-package :cp/read-fixnum)

(declaim (ftype (function * (values fixnum &optional)) read-fixnum))
(defun read-fixnum (&optional (in *standard-input*))
  "NOTE: cannot read -2^62"
  (macrolet ((%read-byte ()
               `(the (unsigned-byte 8)
                     #+swank (char-code (read-char in nil #\Nul))
                     #-swank (sb-impl::ansi-stream-read-byte in nil #.(char-code #\Nul) nil))))
    (let* ((minus nil)
           (result (loop (let ((byte (%read-byte)))
                           (cond ((<= 48 byte 57)
                                  (return (- byte 48)))
                                 ((zerop byte) ; #\Nul
                                  (error "Read EOF or #\Nul."))
                                 ((= byte #.(char-code #\-))
                                  (setq minus t)))))))
      (declare ((integer 0 #.most-positive-fixnum) result))
      (loop
        (let* ((byte (%read-byte)))
          (if (<= 48 byte 57)
              (setq result (+ (- byte 48)
                              (* 10 (the (integer 0 #.(floor most-positive-fixnum 10))
                                         result))))
              (return (if minus (- result) result))))))))

(defpackage :cp/bisect
  (:use :cl)
  (:export #:bisect-left #:bisect-right))
(in-package :cp/bisect)

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

;; BEGIN_USE_PACKAGE
(eval-when (:compile-toplevel :load-toplevel :execute)
  (use-package :cp/bisect :cl-user))
(eval-when (:compile-toplevel :load-toplevel :execute)
  (use-package :cp/read-fixnum :cl-user))
(in-package :cl-user)

;;;
;;; Body
;;;


(defun sort< (as)
  (declare #.*opt*
           (inline sort)
           ((simple-array int32 (*)) as))
  (sort as #'<))

(defun sort> (as)
  (declare #.*opt*
           (inline sort)
           ((simple-array int32 (*)) as))
  (sort as #'>))

(defun solve (as bs s)
  (declare #.*opt*
           ((simple-array int32 (*)) as bs))
  (let* ((n (length as))
         (m (length bs))
         (as+ (make-array n :fill-pointer 0 :element-type 'int32))
         (as- (make-array n :fill-pointer 0 :element-type 'int32))
         (bs+ (make-array m :fill-pointer 0 :element-type 'int32))
         (bs- (make-array m :fill-pointer 0 :element-type 'int32)))
    (declare (uint31 n m))
    (dotimes (i n)
      (let ((a (aref as i)))
        (assert (vector-push a (if (>= a 0) as+ as-)))))
    (dotimes (i m)
      (let ((b (aref bs i)))
        (assert (vector-push b (if (>= b 0) bs+ bs-)))))
    (let* ((as+< (sort< (coerce as+ '(simple-array int32 (*)))))
           (as+> (sort> (coerce as+ '(simple-array int32 (*)))))
           (as-< (sort< (coerce as- '(simple-array int32 (*)))))
           (as-> (sort> (coerce as- '(simple-array int32 (*)))))
           (bs+< (sort< (coerce bs+ '(simple-array int32 (*)))))
           (bs+> (sort> (coerce bs+ '(simple-array int32 (*)))))
           (bs-< (sort< (coerce bs- '(simple-array int32 (*)))))
           (bs-> (sort> (coerce bs- '(simple-array int32 (*))))))
      (declare ((simple-array int32 (*))
                as+< as+> as-< as->
                bs+< bs+> bs-< bs->))
      (dbg as+< as+> as-< as->
           bs+< bs+> bs-< bs->)
      (labels ((calc-count (threshold)
                 (declare (fixnum threshold))
                 (let ((res 0))
                   (declare (uint62 res))
                   (when (>= threshold 0)
                     (let ((end 0))
                       (sb-int:dovector (a as+>)
                         (loop until (or (= end (length bs+<))
                                         (< threshold (* a (aref bs+< end))))
                               do (incf end)
                               finally (incf res end)))))
                   (if (>= threshold 0)
                       (incf res (the uint62 (* (length as+<) (length bs-<))))
                       (let ((end 0))
                         (sb-int:dovector (a as+<)
                           (loop until (or (= end (length bs-<))
                                           (< threshold (* a (aref bs-< end))))
                                 do (incf end)
                                 finally (incf res end)))))
                   (if (>= threshold 0)
                       (incf res (the uint62 (* (length as-<) (length bs+<))))
                       (let ((end 0))
                         (sb-int:dovector (a as->)
                           (loop until (or (= end (length bs+>))
                                           (< threshold (* a (aref bs+> end))))
                                 do (incf end)
                                 finally (incf res end)))))
                   (when (>= threshold 0)
                     (let ((end 0))
                       (sb-int:dovector (a as-<)
                         (loop until (or (= end (length bs->))
                                         (< threshold (* a (aref bs-> end))))
                               do (incf end)
                               finally (incf res end)))))
                   ;; (loop for a across as
                   ;;       for b across bs
                   ;;       when (<= (* a b)))
                   ;; (sb-int:dovector (a as)
                   ;;   (when (<= (* a a) threshold)
                   ;;     (decf res)))
                   ;; (setq res (ash res -1))
                   res)))
        (sb-int:named-let bisect ((ng #.(- (expt 10 18))) (ok #.(expt 10 18)))
          (declare (fixnum ng ok))
          (if (<= (- ok ng) 1)
              ok
              (let ((mid (floor (+ ng ok) 2)))
                (if (>= (calc-count mid) s)
                    (bisect ng mid)
                    (bisect mid ok)))))))))

(defun main ()
  (let* ((k (read))
         (l (read))
         (m (read))
         (n (read))
         (s (read))
         (as (make-array k :element-type 'int32 :initial-element 0))
         (bs (make-array l :element-type 'int32 :initial-element 0))
         (cs (make-array m :element-type 'int32 :initial-element 0))
         (ds (make-array n :element-type 'int32 :initial-element 0))
         (vec1 (make-array (* k l) :element-type 'int32 :initial-element 0))
         (vec2 (make-array (* m n) :element-type 'int32 :initial-element 0))
         (table1 (make-hash-table :test #'eq))
         (table2 (make-hash-table :test #'eq)))
    (dotimes (i k)
      (setf (aref as i) (read-fixnum)))
    (dotimes (i l)
      (setf (aref bs i) (read-fixnum)))
    (dotimes (i m)
      (setf (aref cs i) (read-fixnum)))
    (dotimes (i n)
      (setf (aref ds i) (read-fixnum)))
    (dotimes (i k)
      (dotimes (j l)
        (setf (aref vec1 (+ (* i l) j))
              (* (aref as i) (aref bs j)))))
    (dotimes (i m)
      (dotimes (j n)
        (setf (aref vec2 (+ (* i n) j))
              (* (aref cs i) (aref ds j)))))
    (dbg vec1 vec2)
    (let* ((res (solve vec1 vec2 s)))
      (setq as (sort< as)
            bs (sort< bs)
            cs (sort< cs)
            ds (sort< ds))
      (sb-int:dovector (x vec1)
        (setf (gethash x table1) t))
      (sb-int:dovector (x vec2)
        (setf (gethash x table2) t))
      (println res)
      (loop for x across vec1
            do (multiple-value-bind (y rem) (floor res x)
                 (when (and (zerop rem) (gethash y table2))
                   (loop named outer
                         for a across as
                         do (loop for b across bs
                                  when (= (* a b) x)
                                  do (format t "~D ~D " a b)
                                     (return-from outer)))
                   (loop for c across cs
                         do (loop for d across ds
                                  when (= (* c d) y)
                                  do (format t "~D ~D~%" c d)
                                     (return-from main)))))))))

#-swank (main)

;;;
;;; Test
;;;

#+swank
(progn
  (defparameter *lisp-file-pathname* (uiop:current-lisp-file-pathname))
  (setq *default-pathname-defaults* (uiop:pathname-directory-pathname *lisp-file-pathname*))
  (uiop:chdir *default-pathname-defaults*)
  (defparameter *dat-pathname* (uiop:merge-pathnames* "test.dat" *lisp-file-pathname*))
  (defparameter *problem-url* "https://yukicoder.me/problems/no/1361"))

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

#+(and sbcl (not swank))
(eval-when (:compile-toplevel)
  (when sb-c::*undefined-warnings*
    (error "undefined warnings: ~{~A~^ ~}" sb-c::*undefined-warnings*)))

;; To run: (5am:run! :sample)
#+swank
(5am:test :sample
  (5am:is
   (equal "36
-1 2 -3 6
"
          (run "1 1 2 3 4
-1
2
-3 4
-5 6 -7
" nil)))
  (5am:is
   (equal "1
1 1 1 1
"
          (run "1 2 3 4 12
1
1 1
1 1 1
1 1 1 1
" nil)))
  (5am:is
   (equal "288
2 3 6 8
"
          (run "8 8 8 8 2000
3 1 4 1 5 9 2 6
5 3 5 8 9 7 9 3
2 3 8 4 6 2 6 4
3 3 8 3 2 7 9 5
" nil))))