(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
;;;
;;; Queue with singly linked list
;;;

(defstruct (queue (:constructor make-queue
                      (&optional list &aux (tail (last list)))))
  (list nil :type list)
  (tail nil :type list))

(declaim (inline enqueue))
(defun enqueue (obj queue)
  "Pushes OBJ to the end of QUEUE."
  (symbol-macrolet ((list (queue-list queue))
                    (tail (queue-tail queue)))
    (if (null list)
        (setf tail (list obj)
              list tail)
        (setf (cdr tail) (list obj)
              tail (cdr tail))))
  queue)

(declaim (inline dequeue))
(defun dequeue (queue)
  "Removes and returns the element at the front of QUEUE. Returns NIL if QUEUE
is empty."
  (pop (queue-list queue)))

(declaim (inline queue-empty-p))
(defun queue-empty-p (queue)
  (null (queue-list queue)))

(declaim (inline queue-peek))
(defun queue-peek (queue)
  (car (queue-list queue)))

(declaim (inline enqueue-front))
(defun enqueue-front (obj queue)
  "Pushes OBJ to the front of QUEUE."
  (symbol-macrolet ((list (queue-list queue))
                    (tail (queue-tail queue)))
    (if (null list)
        (setf tail (list obj)
              list tail)
        (push obj list))
    queue))

(declaim (inline read-schar))
(defun read-schar (&optional (stream *standard-input*))
  (declare #-swank (sb-kernel:ansi-stream stream)
           (inline read-byte))
  #+swank (read-char stream nil #\Newline) ; on SLIME
  #-swank (code-char (read-byte stream nil #.(char-code #\Newline))))

(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 +inf+ #xffffffff)

(defun main ()
  (let* ((h (read))
         (w (read))
         (k (read))
         (start-x (- (read) 1))
         (start-y (- (read) 1))
         (goal-x (- (read) 1))
         (goal-y (- (read) 1))
         (plan (make-array (list h w) :element-type 'bit :initial-element 0))
         (marked (make-array (list h w 4) :element-type 'bit :initial-element 0))
         (dists (make-array (list h w) :element-type 'uint32 :initial-element +inf+))
         ;; x . y
         (que (make-queue)))
    (declare (uint31 h w k))
    (dotimes (i h)
      (dotimes (j w (read-schar))
        (ecase (read-schar)
          (#\@ (setf (aref plan i j) 1))
          (#\.))))
    (enqueue (cons start-x start-y) que)
    ;; up:0, down:1, left:2, right:3
    (setf (aref dists start-x start-y) 0)
    (setf (aref marked start-x start-y 0) 1
          (aref marked start-x start-y 1) 1
          (aref marked start-x start-y 2) 1
          (aref marked start-x start-y 3) 1)
    (loop until (queue-empty-p que)
          for (x . y) of-type (uint31 . uint31) = (dequeue que)
          for dist = (aref dists x y)
          do ;; up
             (loop for delta from 1 to k
                   for new-x = (- x delta)
                   while (and (>= new-x 0)
                              (zerop (aref marked new-x y 0))
                              (zerop (aref plan new-x y)))
                   do (setf (aref marked new-x y 0) 1)
                   when (< (+ dist 1) (aref dists new-x y))
                   do (setf (aref dists new-x y) (+ dist 1))
                      (enqueue (cons new-x y) que))
             ;; down
             (loop for delta from 1 to k
                   for new-x = (+ x delta)
                   while (and (< new-x h)
                              (zerop (aref marked new-x y 1))
                              (zerop (aref plan new-x y)))
                   do (setf (aref marked new-x y 1) 1)
                   when (< (+ dist 1) (aref dists new-x y))
                   do (setf (aref dists new-x y) (+ dist 1))
                      (enqueue (cons new-x y) que))
             ;; left
             (loop for delta from 1 to k
                   for new-y = (- y delta)
                   while (and (>= new-y 0)
                              (zerop (aref marked x new-y 2))
                              (zerop (aref plan x new-y)))
                   do (setf (aref marked x new-y 2) 1)
                   when (< (+ dist 1) (aref dists x new-y))
                   do (setf (aref dists x new-y) (+ dist 1))
                      (enqueue (cons x new-y) que))
             ;; right
             (loop for delta from 1 to k
                   for new-y = (+ y delta)
                   while (and (< new-y w)
                              (zerop (aref marked x new-y 3))
                              (zerop (aref plan x new-y)))
                   do (setf (aref marked x new-y 3) 1)
                   when (< (+ dist 1) (aref dists x new-y))
                   do (setf (aref dists x new-y) (+ dist 1))
                      (enqueue (cons x new-y) que)))
    (let ((res (aref dists goal-x goal-y)))
      (println
       (if (= res +inf+)
           -1
           res)))))

(defun main ()
  (declare #.OPT)
  (let* ((h (read))
         (w (read))
         (k (read))
         (boundary (if (>= k 100000) 100000 0))
         (start-x (- (read) 1))
         (start-y (- (read) 1))
         (goal-x (- (read) 1))
         (goal-y (- (read) 1))
         (plan (make-array (list h w) :element-type 'bit :initial-element 0))
         ;; 既に〇〇進んだ
         (marked (make-array (list h w 4) :element-type 'int32 :initial-element -1))
         (dists (make-array (list h w) :element-type 'uint32 :initial-element +inf+))
         ;; x . y
         (que (make-queue)))
    (declare (uint31 h w k))
    (dotimes (i h)
      (dotimes (j w (read-schar))
        (ecase (read-schar)
          (#\@ (setf (aref plan i j) 1))
          (#\.))))
    (if (<= boundary 100000)
        (progn
          (fill (array-storage-vector marked) 0)
          (enqueue (cons start-x start-y) que)
          ;; up:0, down:1, left:2, right:3
          (setf (aref dists start-x start-y) 0)
          (setf (aref marked start-x start-y 0) 1
                (aref marked start-x start-y 1) 1
                (aref marked start-x start-y 2) 1
                (aref marked start-x start-y 3) 1)
          (loop until (queue-empty-p que)
                for (x . y) of-type (uint31 . uint31) = (dequeue que)
                for dist = (aref dists x y)
                do ;; up
                   (loop for delta from 1 to k
                         for new-x = (- x delta)
                         while (and (>= new-x 0)
                                    (zerop (aref marked new-x y 0))
                                    (zerop (aref plan new-x y)))
                         do (setf (aref marked new-x y 0) 1)
                         when (< (+ dist 1) (aref dists new-x y))
                         do (setf (aref dists new-x y) (+ dist 1))
                            (enqueue (cons new-x y) que))
                   ;; down
                   (loop for delta from 1 to k
                         for new-x = (+ x delta)
                         while (and (< new-x h)
                                    (zerop (aref marked new-x y 1))
                                    (zerop (aref plan new-x y)))
                         do (setf (aref marked new-x y 1) 1)
                         when (< (+ dist 1) (aref dists new-x y))
                         do (setf (aref dists new-x y) (+ dist 1))
                            (enqueue (cons new-x y) que))
                   ;; left
                   (loop for delta from 1 to k
                         for new-y = (- y delta)
                         while (and (>= new-y 0)
                                    (zerop (aref marked x new-y 2))
                                    (zerop (aref plan x new-y)))
                         do (setf (aref marked x new-y 2) 1)
                         when (< (+ dist 1) (aref dists x new-y))
                         do (setf (aref dists x new-y) (+ dist 1))
                            (enqueue (cons x new-y) que))
                   ;; right
                   (loop for delta from 1 to k
                         for new-y = (+ y delta)
                         while (and (< new-y w)
                                    (zerop (aref marked x new-y 3))
                                    (zerop (aref plan x new-y)))
                         do (setf (aref marked x new-y 3) 1)
                         when (< (+ dist 1) (aref dists x new-y))
                         do (setf (aref dists x new-y) (+ dist 1))
                            (enqueue (cons x new-y) que)))))
    (progn

      (enqueue (cons start-x start-y) que)
      ;; up:0, down:1, left:2, right:3
      (setf (aref dists start-x start-y) 0)
      (setf (aref marked start-x start-y 0) k
            (aref marked start-x start-y 1) k
            (aref marked start-x start-y 2) k
            (aref marked start-x start-y 3) k)
      (loop until (queue-empty-p que)
            for (x . y) of-type (uint31 . uint31) = (dequeue que)
            for dist = (aref dists x y)
            do ;; up
               ;; #>marked
               (setf (aref marked x y 0) k
                     (aref marked x y 1) k
                     (aref marked x y 2) k
                     (aref marked x y 3) k)
               (loop for delta from 1 to k
                     for new-x = (- x delta)
                     while (and (>= new-x 0)
                                ;; あとk-deltaだけ進めるが、既にそれ以上に進んでいたら打ち切れる
                                (> (- k delta) (aref marked new-x y 0))
                                (zerop (aref plan new-x y)))
                     do (setf (aref marked new-x y 0) (- k delta))
                     when (< (+ dist 1) (aref dists new-x y))
                     do (setf (aref dists new-x y) (+ dist 1))
                        (enqueue (cons new-x y) que))
               ;; down
               (loop for delta from 1 to k
                     for new-x = (+ x delta)
                     while (and (< new-x h)
                                (>= (- k delta) (aref marked new-x y 1))
                                (zerop (aref plan new-x y)))
                     do (setf (aref marked new-x y 1) (- k delta))
                     when (< (+ dist 1) (aref dists new-x y))
                     do (setf (aref dists new-x y) (+ dist 1))
                        (enqueue (cons new-x y) que))
               ;; left
               (loop for delta from 1 to k
                     for new-y = (- y delta)
                     while (and (>= new-y 0)
                                (>= (- k delta) (aref marked x new-y 2))
                                (zerop (aref plan x new-y)))
                     do (setf (aref marked x new-y 2) (- k delta))
                     when (< (+ dist 1) (aref dists x new-y))
                     do (setf (aref dists x new-y) (+ dist 1))
                        (enqueue (cons x new-y) que))
               ;; right
               (loop for delta from 1 to k
                     for new-y = (+ y delta)
                     while (and (< new-y w)
                                (>= (- k delta) (aref marked x new-y 3))
                                (zerop (aref plan x new-y)))
                     do (setf (aref marked x new-y 3) (- k delta))
                     when (< (+ dist 1) (aref dists x new-y))
                     do (setf (aref dists x new-y) (+ dist 1))
                        (enqueue (cons x new-y) que))))
    (let ((res (aref dists goal-x goal-y)))
      (println
       (if (= res +inf+)
           -1
           res)))))

#-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 "3 5 2
3 2 3 4
.....
.@..@
..@..
"
    "5
"))
  (it.bese.fiveam:is
   (common-lisp-user::io-equal "1 6 4
1 1 1 6
......
"
    "2
"))
  (it.bese.fiveam:is
   (common-lisp-user::io-equal "3 3 1
2 1 2 3
.@.
.@.
.@.
"
    "-1
")))


(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
;;;
;;; Queue with singly linked list
;;;

(defstruct (queue (:constructor make-queue
                      (&optional list &aux (tail (last list)))))
  (list nil :type list)
  (tail nil :type list))

(declaim (inline enqueue))
(defun enqueue (obj queue)
  "Pushes OBJ to the end of QUEUE."
  (symbol-macrolet ((list (queue-list queue))
                    (tail (queue-tail queue)))
    (if (null list)
        (setf tail (list obj)
              list tail)
        (setf (cdr tail) (list obj)
              tail (cdr tail))))
  queue)

(declaim (inline dequeue))
(defun dequeue (queue)
  "Removes and returns the element at the front of QUEUE. Returns NIL if QUEUE
is empty."
  (pop (queue-list queue)))

(declaim (inline queue-empty-p))
(defun queue-empty-p (queue)
  (null (queue-list queue)))

(declaim (inline queue-peek))
(defun queue-peek (queue)
  (car (queue-list queue)))

(declaim (inline enqueue-front))
(defun enqueue-front (obj queue)
  "Pushes OBJ to the front of QUEUE."
  (symbol-macrolet ((list (queue-list queue))
                    (tail (queue-tail queue)))
    (if (null list)
        (setf tail (list obj)
              list tail)
        (push obj list))
    queue))

(declaim (inline read-schar))
(defun read-schar (&optional (stream *standard-input*))
  (declare #-swank (sb-kernel:ansi-stream stream)
           (inline read-byte))
  #+swank (read-char stream nil #\Newline) ; on SLIME
  #-swank (code-char (read-byte stream nil #.(char-code #\Newline))))

(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 +inf+ #xffffffff)

(defun main ()
  (declare #.OPT)
  (let* ((h (read))
         (w (read))
         (k (read))
         (boundary (if (>= k 100000) 100000 0))
         (start-x (- (read) 1))
         (start-y (- (read) 1))
         (goal-x (- (read) 1))
         (goal-y (- (read) 1))
         (plan (make-array (list h w) :element-type 'bit :initial-element 0))
         ;; 既に〇〇進んだ
         (marked (make-array (list h w 4) :element-type 'int32 :initial-element -1))
         (dists (make-array (list h w) :element-type 'uint32 :initial-element +inf+))
         ;; x . y
         (que (make-queue)))
    (declare (uint31 h w k))
    (dotimes (i h)
      (dotimes (j w (read-schar))
        (ecase (read-schar)
          (#\@ (setf (aref plan i j) 1))
          (#\.))))
    (enqueue (cons start-x start-y) que)
    ;; up:0, down:1, left:2, right:3
    (setf (aref dists start-x start-y) 0)
    (setf (aref marked start-x start-y 0) k
          (aref marked start-x start-y 1) k
          (aref marked start-x start-y 2) k
          (aref marked start-x start-y 3) k)
    (loop until (queue-empty-p que)
          for (x . y) of-type (uint31 . uint31) = (dequeue que)
          for dist = (aref dists x y)
          do ;; up
             ;; #>marked
             (setf (aref marked x y 0) k
                   (aref marked x y 1) k
                   (aref marked x y 2) k
                   (aref marked x y 3) k)
             (loop for delta from 1 to k
                   for new-x = (- x delta)
                   while (and (>= new-x 0)
                              ;; あとk-deltaだけ進めるが、既にそれ以上に進んでいたら打ち切れる
                              (> (- (- k delta) boundary) (aref marked new-x y 0))
                              (zerop (aref plan new-x y)))
                   do (setf (aref marked new-x y 0) (- k delta))
                   when (< (+ dist 1) (aref dists new-x y))
                   do (setf (aref dists new-x y) (+ dist 1))
                      (enqueue (cons new-x y) que))
             ;; down
             (loop for delta from 1 to k
                   for new-x = (+ x delta)
                   while (and (< new-x h)
                              (>= (- (- k delta) boundary) (aref marked new-x y 1))
                              (zerop (aref plan new-x y)))
                   do (setf (aref marked new-x y 1) (- k delta))
                   when (< (+ dist 1) (aref dists new-x y))
                   do (setf (aref dists new-x y) (+ dist 1))
                      (enqueue (cons new-x y) que))
             ;; left
             (loop for delta from 1 to k
                   for new-y = (- y delta)
                   while (and (>= new-y 0)
                              (>= (- (- k delta) boundary) (aref marked x new-y 2))
                              (zerop (aref plan x new-y)))
                   do (setf (aref marked x new-y 2) (- k delta))
                   when (< (+ dist 1) (aref dists x new-y))
                   do (setf (aref dists x new-y) (+ dist 1))
                      (enqueue (cons x new-y) que))
             ;; right
             (loop for delta from 1 to k
                   for new-y = (+ y delta)
                   while (and (< new-y w)
                              (>= (- (- k delta) boundary) (aref marked x new-y 3))
                              (zerop (aref plan x new-y)))
                   do (setf (aref marked x new-y 3) (- k delta))
                   when (< (+ dist 1) (aref dists x new-y))
                   do (setf (aref dists x new-y) (+ dist 1))
                      (enqueue (cons x new-y) que)))
    (let ((res (aref dists goal-x goal-y)))
      (println
       (if (= res +inf+)
           -1
           res)))))

#-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 "3 5 2
3 2 3 4
.....
.@..@
..@..
"
    "5
"))
  (it.bese.fiveam:is
   (common-lisp-user::io-equal "1 6 4
1 1 1 6
......
"
    "2
"))
  (it.bese.fiveam:is
   (common-lisp-user::io-equal "3 3 1
2 1 2 3
.@.
.@.
.@.
"
    "-1
")))

Global OOD problem IDs are disjoint from train, validation, and in-distribution test problem IDs.

Score : 600 points

Problem Statement

Snuke, a water strider, lives in a rectangular pond that can be seen as a grid with H east-west rows and W north-south columns. Let (i,j) be the square at the i-th row from the north and j-th column from the west.

Some of the squares have a lotus leaf on it and cannot be entered.
The square (i,j) has a lotus leaf on it if c_{ij} is @, and it does not if c_{ij} is ..

In one stroke, Snuke can move between 1 and K squares (inclusive) toward one of the four directions: north, east, south, and west.
The move may not pass through a square with a lotus leaf. Moving to such a square or out of the pond is also forbidden.

Find the minimum number of strokes Snuke takes to travel from the square (x_1,y_1) to (x_2,y_2).
If the travel from (x_1,y_1) to (x_2,y_2) is impossible, point out that fact.

Constraints

1 \leq H,W,K \leq 10^6

H \times W \leq 10^6

1 \leq x_1,x_2 \leq H

1 \leq y_1,y_2 \leq W

x_1 \neq x_2 or y_1 \neq y_2.

c_{i,j} is . or @.

c_{x_1,y_1} = .

c_{x_2,y_2} = .

All numbers in input are integers.

Input

Input is given from Standard Input in the following format:

H W K
x_1 y_1 x_2 y_2
c_{1,1}c_{1,2} .. c_{1,W}
c_{2,1}c_{2,2} .. c_{2,W}
:
c_{H,1}c_{H,2} .. c_{H,W}

Output

Print the minimum number of strokes Snuke takes to travel from the square (x_1,y_1) to (x_2,y_2), or print -1 if the travel is impossible.

Sample Input 1

3 5 2
3 2 3 4
.....
.@..@
..@..

Sample Output 1

5

Initially, Snuke is at the square (3,2).
He can reach the square (3, 4) by making five strokes as follows:

From (3, 2), go west one square to (3, 1).

From (3, 1), go north two squares to (1, 1).

From (1, 1), go east two squares to (1, 3).

From (1, 3), go east one square to (1, 4).

From (1, 4), go south two squares to (3, 4).

Sample Input 2

1 6 4
1 1 1 6
......

Sample Output 2

2

Sample Input 3

3 3 1
2 1 2 3
.@.
.@.
.@.

Sample Output 3

-1

Submitted source-code file size, in bytes.

Execution CPU time reported by official Project CodeNet metadata, in milliseconds.

Peak memory usage reported by official Project CodeNet metadata, in kilobytes.


(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
;;;
;;; Queue with singly linked list
;;;

(defstruct (queue (:constructor make-queue
                      (&optional list &aux (tail (last list)))))
  (list nil :type list)
  (tail nil :type list))

(declaim (inline enqueue))
(defun enqueue (obj queue)
  "Pushes OBJ to the end of QUEUE."
  (symbol-macrolet ((list (queue-list queue))
                    (tail (queue-tail queue)))
    (if (null list)
        (setf tail (list obj)
              list tail)
        (setf (cdr tail) (list obj)
              tail (cdr tail))))
  queue)

(declaim (inline dequeue))
(defun dequeue (queue)
  "Removes and returns the element at the front of QUEUE. Returns NIL if QUEUE
is empty."
  (pop (queue-list queue)))

(declaim (inline queue-empty-p))
(defun queue-empty-p (queue)
  (null (queue-list queue)))

(declaim (inline queue-peek))
(defun queue-peek (queue)
  (car (queue-list queue)))

(declaim (inline enqueue-front))
(defun enqueue-front (obj queue)
  "Pushes OBJ to the front of QUEUE."
  (symbol-macrolet ((list (queue-list queue))
                    (tail (queue-tail queue)))
    (if (null list)
        (setf tail (list obj)
              list tail)
        (push obj list))
    queue))

(declaim (inline read-schar))
(defun read-schar (&optional (stream *standard-input*))
  (declare #-swank (sb-kernel:ansi-stream stream)
           (inline read-byte))
  #+swank (read-char stream nil #\Newline) ; on SLIME
  #-swank (code-char (read-byte stream nil #.(char-code #\Newline))))

(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 +inf+ #xffffffff)

(defun main ()
  (declare #.OPT)
  (let* ((h (read))
         (w (read))
         (k (read))
         (start-x (- (read) 1))
         (start-y (- (read) 1))
         (goal-x (- (read) 1))
         (goal-y (- (read) 1))
         (plan (make-array (list h w) :element-type 'bit :initial-element 0))
         ;; 既に〇〇進んだ
         (marked (make-array (list h w 4) :element-type 'int32 :initial-element -1))
         (dists (make-array (list h w) :element-type 'uint32 :initial-element +inf+))
         ;; x . y
         (que (make-queue)))
    (declare (uint31 h w k))
    (dotimes (i h)
      (dotimes (j w (read-schar))
        (ecase (read-schar)
          (#\@ (setf (aref plan i j) 1))
          (#\.))))
    (enqueue (cons start-x start-y) que)
    ;; up:0, down:1, left:2, right:3
    (setf (aref dists start-x start-y) 0)
    (setf (aref marked start-x start-y 0) k
          (aref marked start-x start-y 1) k
          (aref marked start-x start-y 2) k
          (aref marked start-x start-y 3) k)
    (loop until (queue-empty-p que)
          for (x . y) of-type (uint31 . uint31) = (dequeue que)
          for dist = (aref dists x y)
          do ;; up
             ;; #>marked
             (loop for delta from 1 to k
                   for new-x = (- x delta)
                   while (and (>= new-x 0)
                              ;; あとk-deltaだけ進めるが、既にそれ以上に進んでいたら打ち切れる
                              (> (- k delta) (aref marked new-x y 0))
                              (zerop (aref plan new-x y)))
                   do (setf (aref marked new-x y 0) (- k delta))
                   when (< (+ dist 1) (aref dists new-x y))
                   do (setf (aref dists new-x y) (+ dist 1))
                      (enqueue (cons new-x y) que))
             ;; down
             (loop for delta from 1 to k
                   for new-x = (+ x delta)
                   while (and (< new-x h)
                              (> (- k delta) (aref marked new-x y 1))
                              (zerop (aref plan new-x y)))
                   do (setf (aref marked new-x y 1) (- k delta))
                   when (< (+ dist 1) (aref dists new-x y))
                   do (setf (aref dists new-x y) (+ dist 1))
                      (enqueue (cons new-x y) que))
             ;; left
             (loop for delta from 1 to k
                   for new-y = (- y delta)
                   while (and (>= new-y 0)
                              (> (- k delta) (aref marked x new-y 2))
                              (zerop (aref plan x new-y)))
                   do (setf (aref marked x new-y 2) (- k delta))
                   when (< (+ dist 1) (aref dists x new-y))
                   do (setf (aref dists x new-y) (+ dist 1))
                      (enqueue (cons x new-y) que))
             ;; right
             (loop for delta from 1 to k
                   for new-y = (+ y delta)
                   while (and (< new-y w)
                              (> (- k delta) (aref marked x new-y 3))
                              (zerop (aref plan x new-y)))
                   do (setf (aref marked x new-y 3) (- k delta))
                   when (< (+ dist 1) (aref dists x new-y))
                   do (setf (aref dists x new-y) (+ dist 1))
                      (enqueue (cons x new-y) que)))
    (let ((res (aref dists goal-x goal-y)))
      (println
       (if (= res +inf+)
           -1
           res)))))

#-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 "3 5 2
3 2 3 4
.....
.@..@
..@..
"
    "5
"))
  (it.bese.fiveam:is
   (common-lisp-user::io-equal "1 6 4
1 1 1 6
......
"
    "2
"))
  (it.bese.fiveam:is
   (common-lisp-user::io-equal "3 3 1
2 1 2 3
.@.
.@.
.@.
"
    "-1
")))


(defun Nickname ()
  (defparameter *my-string* (string (read)))
  (subseq *my-string*  0 3)
)

(format t "~(~A~)~%" (Nickname))

Score : 100 points

Problem Statement

When you asked some guy in your class his name, he called himself S, where S is a string of length between 3 and 20 (inclusive) consisting of lowercase English letters.
You have decided to choose some three consecutive characters from S and make it his nickname. Print a string that is a valid nickname for him.

Constraints

3 \leq |S| \leq 20

S consists of lowercase English letters.

Input

Input is given from Standard Input in the following format:

S

Output

Print your answer.

Sample Input 1

takahashi

Sample Output 1

tak

Sample Input 2

naohiro

Sample Output 2

nao


(let* ((n (cons (read) (read)))
       (m (cons (read) (read)))
       (x (read)))
  (if (<= (car n) (car m))
      (if (<= (+ (car m) (* (cdr m) x))
              (+ (car n) (* (cdr n) x)))
          (princ "YES")
          (princ "NO"))
      (if (>= (- (car m) (* (cdr m) x))
              (- (car n) (* (cdr n) x)))
          (princ "YES")
          (princ "NO"))))

Score : 200 points

Problem Statement

Two children are playing tag on a number line. (In the game of tag, the child called "it" tries to catch the other child.) The child who is "it" is now at coordinate A, and he can travel the distance of V per second.
The other child is now at coordinate B, and she can travel the distance of W per second.

He can catch her when his coordinate is the same as hers.
Determine whether he can catch her within T seconds (including exactly T seconds later).
We assume that both children move optimally.

Constraints

-10^9 \leq A,B \leq 10^9

1 \leq V,W \leq 10^9

1 \leq T \leq 10^9

A \neq B

All values in input are integers.

Input

Input is given from Standard Input in the following format:

A V
B W
T

Output

If "it" can catch the other child, print YES; otherwise, print NO.

Sample Input 1

1 2
3 1
3

Sample Output 1

YES

Sample Input 2

1 2
3 2
3

Sample Output 2

NO

Sample Input 3

1 2
3 3
3

Sample Output 3

NO


(defun Lamps (n k)
    (let* ((readLamps (make-array n ))
        (dousyutuLamps (make-array (+ n 1) :initial-element 0))
        (ans "")
        (stop t)
        )

        (dotimes (i n)
            (setf (aref readLamps i) (read)))

    (loop :named main-loop
          :for _ :from 1 :to k
          :do (progn
            (dotimes (j n)
                (let ((l (max 0 (- j (aref readLamps j))))
                    (r (min (- n 1) (+ j (aref readLamps j)))))
                    (incf (aref dousyutuLamps l))
                    (if (<= (+ 1 r) n)
                        (decf (aref dousyutuLamps (+ 1 r)))
                    )
                )
            )
            (loop for j from 1 to n
                do (incf (aref dousyutuLamps j) (aref dousyutuLamps (- j 1)))
            )
            (dotimes (j n)
                (setf stop (and stop (= (aref dousyutuLamps j) n)))
                (setf (aref readLamps j) (aref dousyutuLamps j))
                (setf (aref dousyutuLamps j) 0)
            )

            (if stop
                (return-from main-loop)
                )
        )
    )
        (dotimes (i (- n 1))
            (format t "~A "(aref readLamps i))
        )
        (format t "~A~%" (aref readLamps (- n 1)))
    ans)

)
(format t "~A~%" (Lamps (read) (read)))

Score : 500 points

Problem Statement

We have N bulbs arranged on a number line, numbered 1 to N from left to right.
Bulb i is at coordinate i.

Each bulb has a non-negative integer parameter called intensity.
When there is a bulb of intensity d at coordinate x, the bulb illuminates the segment from coordinate x-d-0.5 to x+d+0.5.
Initially, the intensity of Bulb i is A_i. We will now do the following operation K times in a row:

For each integer i between 1 and N (inclusive), let B_i be the number of bulbs illuminating coordinate i. Then, change the intensity of each bulb i to B_i.

Find the intensity of each bulb after the K operations.

Constraints

1 \leq N \leq 2 \times 10^5

1 \leq K \leq 2 \times 10^5

0 \leq A_i \leq N

Input

Input is given from Standard Input in the following format:

N K
A_1 A_2 \ldots A_N

Output

Print the intensity A{'}_i of each bulb i after the K operations to Standard Output in the following format:

A{'}_1 A{'}_2 \ldots A{'}_N

Sample Input 1

5 1
1 0 0 1 0

Sample Output 1

1 2 2 1 2

Initially, only Bulb 1 illuminates coordinate 1, so the intensity of Bulb 1 becomes 1 after the operation.
Similarly, the bulbs initially illuminating coordinate 2 are Bulb 1 and 2, so the intensity of Bulb 2 becomes 2.

Sample Input 2

5 2
1 0 0 1 0

Sample Output 2

3 3 4 4 3


(let* ((n (read))
       (k (read))
       (b (make-array `(,(1+ n)) :initial-element 0))
       (a (make-array `(,(1+ n)) :initial-element 0)))
  ;; read
  (loop :for i :from 1 :to n
        :do (setf (aref a i) (read)))
  ;; maybe TLE
  (loop :for _ :from 1 :to k
        :do (progn
              (loop :for x :from 1 :to n
                    :do (let ((d (aref a x)))
                          (loop :for i :from (max 1 (- x d)) :to (min n (+ x d))
                                :do (incf (aref b i)))))
              (loop :for i :from 1 :to n
                    :do (setf (aref a i) (aref b i))
                    :do (setf (aref b i) 0))))
  ;;
  (when (> n 1)
    (loop :for i :from 1 :to (1- n)
          :do (format t "~A " (aref a i))))
  (format t "~A~%" (aref a n)))


(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 (ftype (function * (values fixnum &optional)) read-fixnum))
(defun read-fixnum (&optional (in *standard-input*))
  "NOTE: cannot read -2^62"
  (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 #\-))
                                  (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))))))))

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

(declaim (inline bisect-right))
(defun bisect-right (target value &key (start 0) end)
  (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 (< value (the fixnum (cdr (,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)))))

(defun main ()
  (declare #.OPT)
  (let* ((n (read))
         (boundary 10)
         (vs (make-array n :element-type 'uint31 :initial-element 0))
         (ws (make-array n :element-type 'uint31 :initial-element 0))
         (max-l 0))
    (declare (uint31 n boundary max-l))
    (dotimes (i n)
      (setf (aref vs i) (read-fixnum)
            (aref ws i) (read-fixnum)))
    (let* ((q (read))
           (query-store (make-array n :element-type 'list :initial-element nil))
           (res (make-array q :element-type 'fixnum :initial-element 0)))
      (dotimes (i q)
        (let ((v (- (read-fixnum) 1))
              (l (read-fixnum)))
          (maxf max-l l)
          (push (list v l i) (aref query-store v))))
      (labels ((make (half-vs half-ws v w)
                 (declare ((simple-array uint31 (*)) half-vs half-ws)
                          (uint31 v w))
                 (let* ((new-vs (make-array (* 2 (length half-vs)) :element-type 'uint31))
                        (new-ws (make-array (* 2 (length half-ws)) :element-type 'uint31))
                        (len (length half-vs))
                        (pos1 0)
                        (pos2 0)
                        (end 0)
                        (current-w -1)
                        (current-v -1))
                   (declare ((simple-array uint31 (*)) new-vs new-ws)
                            (uint31 pos1 pos2 end)
                            (int32 current-w current-v))
                   (loop (when (= pos1 len)
                           (loop for pos from pos2 below len
                                 for v2 = (aref half-vs pos)
                                 for w2 = (aref half-ws pos)
                                 when (and (> (+ v2 v) current-v)
                                           (> (+ w2 w) current-w))
                                 do (setf (aref new-vs end) (+ v2 v)
                                          (aref new-ws end) (+ w2 w)
                                          end (+ end 1)
                                          current-w (+ w2 w)
                                          current-v (+ v2 v)))
                           (return))
                         (let ((v1 (aref half-vs pos1))
                               (w1 (aref half-ws pos1))
                               (v2 (aref half-vs pos2))
                               (w2 (aref half-ws pos2)))
                           (declare (uint31 v1 v2 w1 w2))
                           (cond ((< w1 (+ w2 w))
                                  (when (and (> w1 current-w)
                                             (> v1 current-v))
                                    (setf (aref new-vs end) v1
                                          (aref new-ws end) w1
                                          end (+ end 1)
                                          current-w w1
                                          current-v v1))
                                  (incf pos1))
                                 ((> w1 (+ w2 w))
                                  (when (and (> (+ w2 w) current-w)
                                             (> (+ v2 v) current-v))
                                    (setf (aref new-vs end) (+ v2 v)
                                          (aref new-ws end) (+ w2 w)
                                          end (+ end 1)
                                          current-w (+ w2 w)
                                          current-v (+ v2 v)))
                                  (incf pos2))
                                 ((= w1 (+ w2 w))
                                  (let ((max-v (max v1 (+ v2 v))))
                                    (declare (uint31 max-v))
                                    (when (and (> w1 current-w)
                                               (> max-v current-v))
                                      (setf (aref new-vs end) max-v
                                            (aref new-ws end) w1
                                            end (+ end 1)
                                            current-w w1
                                            current-v max-v))
                                    (incf pos1)
                                    (incf pos2)))
                                 (t (error "Huh?")))))
                   (values (adjust-array new-vs end)
                           (adjust-array new-ws end)))))
        (sb-int:named-let recur ((i 0)
                                 (depth 0)
                                 (half-vs1 (make-array 1
                                                       :element-type 'uint31
                                                       :initial-element 0))
                                 (half-ws1 (make-array 1
                                                       :element-type 'uint31
                                                       :initial-element 0))
                                 (half-vs2 (make-array 1
                                                       :element-type 'uint31
                                                       :initial-element 0))
                                 (half-ws2 (make-array 1
                                                       :element-type 'uint31
                                                       :initial-element 0)))
          (declare (uint31 i depth)
                   ((simple-array uint31 (*)) half-vs1 half-ws1 half-vs2 half-ws2))
          (when (>= i n) (return-from recur))
          (let ((v (aref vs i))
                (w (aref ws i)))
            (declare (uint31 v w))
            (if (< depth boundary)
                (multiple-value-bind (half-vs1 half-ws1) (make half-vs1 half-ws1 v w)
                  (declare ((simple-array uint31 (*)) half-vs1 half-ws1))
                  (loop for (q-v q-l index) of-type (uint31 uint31 uint31) in (aref query-store i)
                        do (setf (aref res index)
                                 (loop for v across half-vs1
                                       for w across half-ws1
                                       while (<= w q-l)
                                       maximize v)))
                  (recur (+ (* i 2) 1) (+ depth 1) half-vs1 half-ws1 half-vs2 half-ws2)
                  (recur (+ (* i 2) 2) (+ depth 1) half-vs1 half-ws1 half-vs2 half-ws2))
                (multiple-value-bind (half-vs2 half-ws2) (make half-vs2 half-ws2 v w)
                  (declare ((simple-array uint31 (*)) half-vs2 half-ws2))
                  (if (aref query-store i)
                      (progn
                        (loop
                          for (q-v q-l index) of-type (uint31 uint31 uint31) in (aref query-store i)
                          for max-value of-type uint31 = 0
                          for pos2 = (- (length half-vs2) 1)
                          do (loop for v1 across half-vs1
                                   for w1 across half-ws1
                                   while (<= w1 q-l)
                                   do (loop for w2 = (aref half-ws2 pos2)
                                            until (<= (+ w1 w2) q-l)
                                            do (decf pos2))
                                      (let ((v2 (aref half-vs2 pos2)))
                                        (declare (uint31 v2))
                                        (maxf max-value (+ v1 v2))))
                             (setf (aref res index) max-value))
                        (recur (+ (* i 2) 1) (+ depth 1)
                               half-vs1 half-ws1 half-vs2 half-ws2)
                        (recur (+ (* i 2) 2) (+ depth 1)
                               half-vs1 half-ws1 half-vs2 half-ws2))
                      (progn
                        (recur (+ (* i 2) 1) (+ depth 1)
                               half-vs1 half-ws1 half-vs2 half-ws2)
                        (recur (+ (* i 2) 2) (+ depth 1)
                               half-vs1 half-ws1 half-vs2 half-ws2))))))))
      (write-string
       (with-output-to-string (*standard-output* nil :element-type 'base-char)
         (map () #'println res))))))

#-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)
    (let ((n 262143))
      (format out "~D~%" n)
      (dotimes (_ n)
        (format out "~D ~D~%" (+ 1 (random 100000)) (+ 1 (random 100000))))
      (println 100000 out)
      (dotimes (_ 100000)
        (format out "~D ~D~%" (+ 130000 (random (- n 130000))) (+ 1 (random 100000)))))))

#+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 "3
1 2
2 3
3 4
3
1 1
2 5
3 5
"
    "0
3
3
"))
  (it.bese.fiveam:is
   (common-lisp-user::io-equal "15
123 119
129 120
132 112
126 109
118 103
115 109
102 100
130 120
105 105
132 115
104 102
107 107
127 116
121 104
121 115
8
8 234
9 244
10 226
11 227
12 240
13 237
14 206
15 227
"
    "256
255
250
247
255
259
223
253
")))

Score : 700 points

Problem Statement

We have a rooted binary tree with N vertices, where the vertices are numbered 1 to N.
Vertex 1 is the root, and the parent of Vertex i (i \geq 2) is Vertex \left[ \frac{i}{2} \right].

Each vertex has one item in it. The item in Vertex i has a value of V_i and a weight of W_i.
Now, process the following query Q times:

Given are a vertex v of the tree and a positive integer L.
Let us choose some (possibly none) of the items in v and the ancestors of v so that their total weight is at most L.
Find the maximum possible total value of the chosen items.

Here, Vertex u is said to be an ancestor of Vertex v when u is an indirect parent of v, that is, there exists a sequence of vertices w_1,w_2,\ldots,w_k (k\geq 2) where w_1=v, w_k=u, and w_{i+1} is the parent of w_i for each i.

Constraints

All values in input are integers.

1 \leq N < 2^{18}

1 \leq Q \leq 10^5

1 \leq V_i \leq 10^5

1 \leq W_i \leq 10^5

For the values v and L given in each query, 1 \leq v \leq N and 1 \leq L \leq 10^5.

Input

Let v_i and L_i be the values v and L given in the i-th query.
Then, Input is given from Standard Input in the following format:

N
V_1 W_1
:
V_N W_N
Q
v_1 L_1
:
v_Q L_Q

Output

For each integer i from 1 through Q,
the i-th line should contain the response to the i-th query.

Sample Input 1

3
1 2
2 3
3 4
3
1 1
2 5
3 5

Sample Output 1

0
3
3

In the first query, we are given only one choice: the item with (V, W)=(1,2). Since L = 1, we cannot actually choose it, so our response should be 0.

In the second query, we are given two choices: the items with (V, W)=(1,2) and (V, W)=(2,3). Since L = 5, we can choose both of them, so our response should be 3.

Sample Input 2

15
123 119
129 120
132 112
126 109
118 103
115 109
102 100
130 120
105 105
132 115
104 102
107 107
127 116
121 104
121 115
8
8 234
9 244
10 226
11 227
12 240
13 237
14 206
15 227

Sample Output 2

256
255
250
247
255
259
223
253


#-swank
(unless (member :child-sbcl *features*)
  (quit
   :unix-status
   (process-exit-code
    (run-program *runtime-pathname*
                 `("--control-stack-size" "128MB"
                   "--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 log2-ceil))
(defun log2-ceil (x)
  "Rounds up log2(x)."
  (let ((ceil (ceiling x)))
    (declare ((integer 0) ceil))
    (integer-length (- ceil 1))))

(declaim (inline log-ceil))
(defun log-ceil (x base)
  "Rounds up log(x)."
  (declare (real x)
           ((integer 2) base))
  (assert (>= x 0))
  (labels ((%log ()
             (nth-value 0 (ceiling (log x base)))))
    (if (integerp x)
        (let ((y x)
              (result 0))
          (loop (when (zerop y)
                  (return result))
                (multiple-value-bind (quot rem) (floor y base)
                  (unless (zerop rem)
                    (return (%log)))
                  (setq y quot)
                  (incf result))))
        (%log))))

(declaim (ftype (function * (values fixnum &optional)) read-fixnum))
(defun read-fixnum (&optional (in *standard-input*))
  "NOTE: cannot read -2^62"
  (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 #\-))
                                  (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))))))))

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

(declaim (inline bisect-right))
(defun bisect-right (target value &key (start 0) end)
  (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 (< value (the fixnum (cdr (,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)))))

(defun main ()
  (declare #.OPT)
  (let* ((n (read))
         (boundary 10)
         (vs (make-array n :element-type 'uint31 :initial-element 0))
         (ws (make-array n :element-type 'uint31 :initial-element 0))
         (max-l 0))
    (declare (uint31 n boundary max-l))
    (dotimes (i n)
      (setf (aref vs i) (read-fixnum)
            (aref ws i) (read-fixnum)))
    (let* ((q (read))
           (query-store (make-array n :element-type 'list :initial-element nil))
           (res (make-array q :element-type 'fixnum :initial-element 0))
           (tree (make-array (* 3 n) :element-type 'bit :initial-element 1)))
      (dotimes (i q)
        (let ((v (- (read-fixnum) 1))
              (l (read-fixnum)))
          (maxf max-l l)
          (push (list v l i) (aref query-store v))))
      (sb-int:named-let recur ((i 0))
        (declare (uint31 i))
        (if (>= i n)
            nil
            (let ((res1 (recur (+ (* i 2) 1)))
                  (res2 (recur (+ (* i 2) 2))))
              (when (or (aref query-store i)
                        res1 res2)
                (setf (aref tree i) 1)))))
      (labels ((make (half2 v w)
                 (declare ((simple-array list (*)) half2)
                          (uint31 v w))
                 (let* ((new-half2 (make-array (* 2 (length half2)) :element-type 'list))
                        (len (length half2))
                        (pos1 0)
                        (pos2 0)
                        (end 0)
                        (current-w -1)
                        (current-v -1))
                   (declare ((simple-array list (*)) new-half2)
                            (uint31 pos1 pos2 end)
                            (fixnum current-w current-v))
                   (loop (when (= pos1 len)
                           (loop for pos from pos2 below len
                                 for (v2 . w2) of-type (uint62 . uint62) = (aref half2 pos)
                                 when (and (> (+ v2 v) current-v)
                                           (> (+ w2 w) current-w))
                                 do (setf (aref new-half2 end) (cons (the fixnum (+ v2 v))
                                                                     (the fixnum (+ w2 w)))
                                          end (+ end 1)
                                          current-w (+ w2 w)
                                          current-v (+ v2 v)))
                           (return))
                         (destructuring-bind (v1 . w1) (aref half2 pos1)
                           (destructuring-bind (v2 . w2) (aref half2 pos2)
                             (declare (uint62 v1 v2 w1 w2))
                             (cond ((< w1 (+ w2 w))
                                    (when (and (> w1 current-w)
                                               (> v1 current-v))
                                      (setf (aref new-half2 end) (cons v1 w1)
                                            end (+ end 1)
                                            current-w w1
                                            current-v v1))
                                    (incf pos1))
                                   ((> w1 (+ w2 w))
                                    (when (and (> (+ w2 w) current-w)
                                               (> (+ v2 v) current-v))
                                      (setf (aref new-half2 end) (cons (the fixnum (+ v2 v))
                                                                       (the fixnum (+ w2 w)))
                                            end (+ end 1)
                                            current-w (+ w2 w)
                                            current-v (+ v2 v)))
                                    (incf pos2))
                                   ((= w1 (+ w2 w))
                                    (let ((max-v (max v1 (+ v2 v))))
                                      (declare (uint62 max-v))
                                      (when (and (> w1 current-w)
                                                 (> max-v current-v))
                                        (setf (aref new-half2 end) (cons max-v w1)
                                              end (+ end 1)
                                              current-w w1
                                              current-v max-v))
                                      (incf pos1)
                                      (incf pos2)))
                                   (t (error "Huh?"))))))
                   (adjust-array new-half2 end))))
        (sb-int:named-let recur ((i 0)
                                 (depth 0)
                                 (half1 (make-array 1
                                                    :element-type 'list
                                                    :initial-element (cons 0 0)))
                                 (half2 (make-array 1
                                                    :element-type 'list
                                                    :initial-element (cons 0 0))))
          (declare (uint31 i depth)
                   ((simple-array list (*)) half1 half2))
          (when (>= i n) (return-from recur))
          (let ((v (aref vs i))
                (w (aref ws i)))
            (declare (uint31 v w))
            (if (< depth boundary)
                (let ((new-half1 (make half1 v w)))
                  (declare ((simple-array list (*)) new-half1))
                  (loop for (q-v q-l index) of-type (uint62 uint62 uint62) in (aref query-store i)
                        do (setf (aref res index)
                                 (loop for (v1 . w1) of-type (uint62 . uint62) across new-half1
                                       when (<= w1 q-l)
                                       maximize v1)))
                  (when (= 1 (aref tree (+ (* i 2) 1)))
                    (recur (+ (* i 2) 1) (+ depth 1) new-half1 half2))
                  (when (= 1 (aref tree (+ (* i 2) 2)))
                    (recur (+ (* i 2) 2) (+ depth 1) new-half1 half2)))
                (let* ((new-half2 (make half2 v w)))
                  (declare ((simple-array list (*)) new-half2))
                  ;; answer query
                  ;; 各重みについて最大の価値しかいらない
                  (if (aref query-store i)
                      (progn
                        (loop
                          for (q-v q-l index) of-type (uint62 uint62 uint62) in (aref query-store i)
                          for max-value of-type fixnum = 0
                          for pos2 = (- (length new-half2) 1)
                          do (loop for (v1 . w1) of-type (fixnum . fixnum) across half1
                                   ;; 重さがl-w1以下のものを見つける
                                   while (<= w1 q-l)
                                   do (loop
                                        (destructuring-bind (v2 . w2) (aref new-half2 pos2)
                                          (declare (fixnum v2 w2))
                                          (when (<= (+ w1 w2) q-l)
                                            (return))
                                          (decf pos2)))
                                      (destructuring-bind (v2 . w2) (aref new-half2 pos2)
                                        (declare (fixnum v2 w2))
                                        (maxf max-value (+ v1 v2))))
                             (setf (aref res index) max-value))
                        (when (= 1 (aref tree (+ (* i 2) 1)))
                          (recur (+ (* i 2) 1) (+ depth 1) half1 new-half2))
                        (when (= 1 (aref tree (+ (* i 2) 2)))
                          (recur (+ (* i 2) 2) (+ depth 1) half1 new-half2)))
                      (progn
                        (when (= 1 (aref tree (+ (* i 2) 1)))
                          (recur (+ (* i 2) 1) (+ depth 1) half1 new-half2))
                        (when (= 1 (aref tree (+ (* i 2) 2)))
                          (recur (+ (* i 2) 2) (+ depth 1) half1 new-half2)))))))))
      (write-string
       (with-output-to-string (*standard-output* nil :element-type 'base-char)
         (map () #'println res))))))

#-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)
    (let ((n 262143))
      (format out "~D~%" n)
      (dotimes (_ n)
        (format out "~D ~D~%" (+ 1 (random 100000)) (+ 1 (random 100000))))
      (println 100000 out)
      (dotimes (_ 100000)
        (format out "~D ~D~%" (+ 130000 (random (- n 130000))) (+ 1 (random 100000)))))))

#+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 "3
1 2
2 3
3 4
3
1 1
2 5
3 5
"
    "0
3
3
"))
  (it.bese.fiveam:is
   (common-lisp-user::io-equal "15
123 119
129 120
132 112
126 109
118 103
115 109
102 100
130 120
105 105
132 115
104 102
107 107
127 116
121 104
121 115
8
8 234
9 244
10 226
11 227
12 240
13 237
14 206
15 227
"
    "256
255
250
247
255
259
223
253
")))


(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
;;;
;;; Quicksort (randomized median-of-three partitioning)
;;;

;; TODO: Consider worst case of deterministic partitioning
;; Reference:
;; Hannu Erkio, The worst case permutation for median-of-three quicksort

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

(declaim (inline quicksort!))
(defun quicksort! (vector order &key (start 0) end)
  "Destructively sorts VECTOR w.r.t. ORDER."
  (declare (vector vector))
  (unless end
    (setq end (length vector)))
  (assert (<= 0 start end))
  (labels
      ((recur (left right)
         (declare (fixnum left right))
         (when (< left right)
           (let* ((l left)
                  (r right)
                  (pivot (%median3 (aref vector l)
                                   (aref vector (the fixnum (+ l (random (+ 1 (- r l))))))
                                   (aref vector r)
                                   order)))
             (declare ((integer 0 #.most-positive-fixnum) l r))
             (loop (loop while (funcall order (aref vector l) pivot)
                         do (incf l))
                   (loop while (funcall order pivot (aref vector r))
                         do (decf r))
                   (when (>= l r)
                     (return))
                   (rotatef (aref vector l) (aref vector r))
                   (incf l 1)
                   (decf r 1))
             (recur left (- l 1))
             (recur (+ r 1) right)))))
    (recur start (- end 1))
    vector))

(declaim (inline quicksort-by2!))
(defun quicksort-by2! (vector order)
  "Destructively sorts VECTOR by two elements. This function regards
each (VECTOR[i], VECTOR[i+1]) for even i as an element, and compares only the
first elements (i.e. VECTOR[i] for even i)."
  (declare (vector vector))
  (assert (evenp (length vector)))
  (labels
      ((recur (left right)
         (declare (fixnum left right))
         (when (< left right)
           (let* ((l left)
                  (r right)
                  (pivot (%median3
                          (aref vector l)
                          (aref vector (the fixnum (+ l (logandc2 (random (+ 1 (- r l))) 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 2))
                   (loop while (funcall order pivot (aref vector r))
                         do (decf r 2))
                   (when (>= l r)
                     (return))
                   (rotatef (aref vector l) (aref vector r))
                   (rotatef (aref vector (+ l 1)) (aref vector (+ r 1)))
                   (incf l 2)
                   (decf r 2))
             (recur left (- l 2))
             (recur (+ r 2) right)))))
    (recur 0 (- (length vector) 2))
    vector))

(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 log2-ceil))
(defun log2-ceil (x)
  "Rounds up log2(x)."
  (let ((ceil (ceiling x)))
    (declare ((integer 0) ceil))
    (integer-length (- ceil 1))))

(declaim (inline log-ceil))
(defun log-ceil (x base)
  "Rounds up log(x)."
  (declare (real x)
           ((integer 2) base))
  (assert (>= x 0))
  (labels ((%log ()
             (nth-value 0 (ceiling (log x base)))))
    (if (integerp x)
        (let ((y x)
              (result 0))
          (loop (when (zerop y)
                  (return result))
                (multiple-value-bind (quot rem) (floor y base)
                  (unless (zerop rem)
                    (return (%log)))
                  (setq y quot)
                  (incf result))))
        (%log))))

(declaim (ftype (function * (values fixnum &optional)) read-fixnum))
(defun read-fixnum (&optional (in *standard-input*))
  "NOTE: cannot read -2^62"
  (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 #\-))
                                  (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))))))))

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

(declaim (inline bisect-right))
(defun bisect-right (target value &key (start 0) end)
  (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 (< value (the fixnum (cdr (,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)))))

(defun main ()
  (declare #.OPT)
  (let* ((n (read))
         (boundary (ash (log2-ceil n) -1))
         (vs (make-array n :element-type 'uint31 :initial-element 0))
         (ws (make-array n :element-type 'uint31 :initial-element 0)))
    (declare (uint31 n boundary))
    (dotimes (i n)
      (setf (aref vs i) (read-fixnum)
            (aref ws i) (read-fixnum)))
    (let* ((q (read))
           (query-store (make-array n :element-type 'list :initial-element nil))
           (res (make-array q :element-type 'fixnum :initial-element 0))
           (tree (make-array (* 3 n) :element-type 'bit :initial-element 1)))
      (dotimes (i q)
        (let ((v (- (read-fixnum) 1))
              (l (read-fixnum)))
          (push (list v l i) (aref query-store v))))
      (sb-int:named-let recur ((i 0))
        (declare (uint31 i))
        (if (>= i n)
            nil
            (let ((res1 (recur (+ (* i 2) 1)))
                  (res2 (recur (+ (* i 2) 2))))
              (when (or (aref query-store i)
                        res1 res2)
                (setf (aref tree i) 1)))))
      (sb-int:named-let recur ((i 0)
                               (depth 0)
                               (half1 (list (cons 0 0)))
                               (half2 (make-array 1
                                                  :element-type 'list
                                                  :initial-element (cons 0 0))))
        (declare (uint31 i depth)
                 ((simple-array list (*)) half2))
        (when (>= i n) (return-from recur))
        (let ((v (aref vs i))
              (w (aref ws i)))
          (declare (uint31 v w))
          (if (< depth boundary)
              (let ((new-half1
                      (append (loop for (v-sum . w-sum) of-type (uint62 . uint62) in half1
                                    collect (cons (+ v-sum v) (+ w-sum w)))
                              half1)))
                (loop for (q-v q-l index) of-type (uint62 uint62 uint62) in (aref query-store i)
                      do (setf (aref res index)
                               (loop for (v1 . w1) of-type (uint62 . uint62) in new-half1
                                     when (<= w1 q-l)
                                     maximize v1)))
                (recur (+ (* i 2) 1) (+ depth 1) new-half1 half2)
                (recur (+ (* i 2) 2) (+ depth 1) new-half1 half2))
              (let ((new-half2 (make-array (length half2) :element-type 'list)))
                (dotimes (i (length half2))
                  (destructuring-bind (v-sum . w-sum) (aref half2 i)
                    (declare (uint62 v-sum w-sum))
                    (setf (aref new-half2 i)
                          (cons (+ v v-sum) (+ w w-sum)))))
                ;; #>new-half2
                (let* ((new-half2 (concatenate '(simple-array list (*))
                                               half2 new-half2)))
                  ;; #>new-half2
                  ;; answer query
                  ;; 各重みについて最大の価値しかいらない
                  (if (aref query-store i)
                      (progn
                        (quicksort! new-half2
                                    (lambda (node1 node2)
                                      (let ((v1 (car node1))
                                            (w1 (cdr node1))
                                            (v2 (car node2))
                                            (w2 (cdr node2)))
                                        (declare (fixnum v1 w1 v2 w2))
                                        (or (< w1 w2)
                                            (and (= w1 w2) (> v1 v2))))))
                        (let ((current-v -1)
                              (nn-half2 (make-array 0 :element-type 'list :fill-pointer 0)))
                          (dotimes (i (length new-half2))
                            (destructuring-bind (v . w) (aref new-half2 i)
                              (declare (uint62 v w))
                              (when (> v current-v)
                                (setq current-v v)
                                (vector-push-extend (aref new-half2 i) nn-half2))))
                          (let ((nn-half2 (coerce nn-half2 '(simple-array list (*)))))
                            (declare ((simple-array list (*)) nn-half2))
                            (loop for (q-v q-l index) of-type (uint62 uint62 uint62) in (aref query-store i)
                                  for max-value of-type fixnum = 0
                                  do (loop for (v1 . w1) of-type (fixnum . fixnum) in half1
                                           ;; 重さがl-w1以下のものを見つける
                                           when (<= w1 q-l)
                                           do (let ((idx (- (bisect-right nn-half2
                                                                          (- q-l w1))
                                                            1)))
                                                (destructuring-bind (v2 . w2) (aref nn-half2 idx)
                                                  (declare (fixnum v2 w2))
                                                  (assert (<= (+ w1 w2) q-l))
                                                  (maxf max-value (+ v1 v2)))))
                                     (setf (aref res index) max-value))
                            (when (= 1 (aref tree (+ (* i 2) 1)))
                              (recur (+ (* i 2) 1) (+ depth 1) half1 nn-half2))
                            (when (= 1 (aref tree (+ (* i 2) 2)))
                              (recur (+ (* i 2) 2) (+ depth 1) half1 nn-half2)))))
                      (progn
                        (when (= 1 (aref tree (+ (* i 2) 1)))
                          (recur (+ (* i 2) 1) (+ depth 1) half1 new-half2))
                        (when (= 1 (aref tree (+ (* i 2) 2)))
                          (recur (+ (* i 2) 2) (+ depth 1) half1 new-half2)))))))))
      (write-string
       (with-output-to-string (*standard-output* nil :element-type 'base-char)
         (map () #'println res))))))

#-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)
    (let ((n 262143))
      (format out "~D~%" n)
      (dotimes (_ n)
        (format out "~D ~D~%" (+ 1 (random 100000)) (+ 1 (random 100000))))
      (println 100000 out)
      (dotimes (_ 100000)
        (format out "~D ~D~%" (+ 1 (random n)) (+ 1 (random 100000)))))))

#+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 "3
1 2
2 3
3 4
3
1 1
2 5
3 5
"
    "0
3
3
"))
  (it.bese.fiveam:is
   (common-lisp-user::io-equal "15
123 119
129 120
132 112
126 109
118 103
115 109
102 100
130 120
105 105
132 115
104 102
107 107
127 116
121 104
121 115
8
8 234
9 244
10 226
11 227
12 240
13 237
14 206
15 227
"
    "256
255
250
247
255
259
223
253
")))


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

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

(defun test (n as s)
  (dbg n as s)
  (with-cache (:array ((+ n 1) (ash 1 4)) :element-type 'int8 :initial-element -1)
    (labels ((dp (pos sum)
               (cond ((= pos n)
                      (if (zerop sum) 0 1))
                     ((char= #\0 (aref s pos))
                      (if (or (zerop (dp (+ pos 1) sum))
                              (zerop (dp (+ pos 1) (logxor sum (aref as pos)))))
                          0
                          1))
                     ((char= #\1 (aref s pos))
                      (if (or (= 1 (dp (+ pos 1) sum))
                              (= 1 (dp (+ pos 1) (logxor sum (aref as pos)))))
                          1
                          0))
                     (t (error "Huh?")))))
      (dp 0 0))))

(defun main ()
  (let ((tt (read)))
    (dotimes (_ tt)
      (block continue
        (labels ((no () (println 1) (return-from continue)))
          (let* ((n (read))
                 (as (make-array n :element-type 'uint62 :initial-element 0))
                 (dp (make-array (+ n 1) :element-type 'list :initial-element nil)))
            (dotimes (i n)
              (setf (aref as i) (read-fixnum)))
            #>as
            (let ((s (read-line)))
              (loop for i from (- n 1) downto 0
                    for a = (aref as i)
                    for prev = (aref dp (+ i 1))
                    do #>dp
                    when (char= #\0 (aref s i))
                    do (loop for x in (aref dp (+ i 1))
                             do (minf a (logxor a x))
                             finally (setf (aref dp i)
                                           (if (zerop a)
                                               prev
                                               (sort (cons a prev) #'>))))
                    else
                    do (loop for x in (aref dp (+ i 1))
                             do (minf a (logxor a x))
                             finally (if (zerop a)
                                         (setf (aref dp i) prev)
                                         (no)))
                    finally (println 0)))))))))

#-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 "3
2
1 2
10
2
1 1
10
6
2 3 4 5 6 7
111000
"
    "1
0
0
")))

Score : 400 points

Problem Statement

There are two persons, numbered 0 and 1, and a variable x whose initial value is 0.
The two persons now play a game.
The game is played in N rounds. The following should be done in the i-th round (1 \leq i \leq N):

Person S_i does one of the following:

Replace x with x \oplus A_i, where \oplus represents bitwise XOR.

Do nothing.

Person 0 aims to have x=0 at the end of the game, while Person 1 aims to have x \neq 0 at the end of the game.

Determine whether x becomes 0 at the end of the game when the two persons play optimally.

Solve T test cases for each input file.

Constraints

1 \leq T \leq 100

1 \leq N \leq 200

1 \leq A_i \leq 10^{18}

S is a string of length N consisting of 0 and 1.

All numbers in input are integers.

Input

Input is given from Standard Input in the following format.
The first line is as follows:

T

Then, T test cases follow.
Each test case is given in the following format:

N
A_1 A_2 \cdots A_N
S

Output

For each test case, print a line containing 0 if x becomes 0 at the end of the game, and 1 otherwise.

Sample Input 1

3
2
1 2
10
2
1 1
10
6
2 3 4 5 6 7
111000

Sample Output 1

1
0
0

In the first test case, if Person 1 replaces x with 0 \oplus 1=1, we surely have x \neq 0 at the end of the game, regardless of the choice of Person 0.

In the second test case, regardless of the choice of Person 1, Person 0 can make x=0 with a suitable choice.


(let ((a (read))
      (b (round (* (read) 100))))
     (princ (floor (* a b) 100)))

Score : 100 points

Problem Statement

Compute A \times B.

Constraints

1 \leq A \leq 100

1 \leq B \leq 100

All values in input are integers.

Input

Input is given from Standard Input in the following format:

A B

Output

Print the value A \times B as an integer.

Sample Input 1

2 5

Sample Output 1

10

We have 2 \times 5 = 10.

Sample Input 2

100 100

Sample Output 2

10000