;; -*- coding: utf-8 -*-
(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 (set-dispatch-macro-character #\# #\> (lambda (s c p) (declare (ignore c p)) (read s nil (values) t))))
#+swank (cl-syntax:use-syntax cl-debug-print:debug-print-syntax)

;; BEGIN_INSERTED_CONTENTS
(declaim (ftype (function * (values fixnum &optional)) read-fixnum))
(defun read-fixnum (&optional (in *standard-input*))
  (declare #.OPT)
  (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 #\-))
                                  (setf 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))))))))

(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

(defun main ()
  (declare #.OPT)
  (let* ((n (read))
         (ts (make-array n :element-type 'uint32))
         (as (make-array n :element-type 'uint32)))
    (dotimes (i n) (setf (aref ts i) (read-fixnum)))
    (dotimes (i n) (setf (aref as i) (read-fixnum)))
    (let ((tmax (make-array n :element-type 'uint32))
          (tmin (make-array n :element-type 'uint32))
          (amax (make-array n :element-type 'uint32))
          (amin (make-array n :element-type 'uint32)))
      (setf (aref tmax 0) (aref ts 0)
            (aref tmin 0) (aref ts 0)
            (aref amax (- n 1)) (aref as (- n 1))
            (aref amin (- n 1)) (aref as (- n 1)))
      (loop for i from 1 below n
            do (if (= (aref ts i) (aref ts (- i 1)))
                   (setf (aref tmax i) (aref ts i)
                         (aref tmin i) 1)
                   (setf (aref tmax i) (aref ts i)
                         (aref tmin i) (aref ts i))))
      (loop for i from (- n 2) downto 0
            do (if (= (aref as i) (aref as (+ i 1)))
                   (setf (aref amax i) (aref as i)
                         (aref amin i) 1)
                   (setf (aref amax i) (aref as i)
                         (aref amin i) (aref as i))))
      (let ((res 1))
        (declare (uint32 res))
        (dotimes (i n)
          (let ((factor (max 0 (+ 1 (- (min (aref tmax i) (aref amax i))
                                       (max (aref tmin i) (aref amin i)))))))
            (setf res (mod (* res factor) +mod+))))
        (println res)))))

#-swank(main)


Measured memory_bytes: 38240