(in-package :cl-user)
(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)

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

(defconstant +mod+ 1000000007)

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

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

;; BEGIN_INSERTED_CONTENTS
;; BEGIN_USE_PACKAGE
(in-package :cl-user)

;;;
;;; Body
;;;

(defun compare (s1 s2)
  #-swank (declare (simple-base-string s1 s2))
  (let ((s1-small (substitute #\a #\? s1))
        (s1-large (substitute #\z #\? s1))
        (s2-small (substitute #\a #\? s2))
        (s2-large (substitute #\z #\? s2)))
    (values (string<= s1-small s2-large)
            (string>= s1-large s2-small))))

(defun main ()
  (let* ((n (read))
         (ss (make-array n :element-type 'simple-base-string)))
    (dotimes (i n)
      (setf (aref ss i) (coerce (read-line) 'simple-base-string)))
    (let ((target (coerce (read-line) 'simple-base-string))
          (smaller 0)
          (larger 0))
      (declare (uint31 smaller larger))
      (sb-int:dovector (s ss)
        (multiple-value-bind (<= >=) (compare target s)
          (when <= (incf larger))
          (when >= (incf smaller))))
      (let ((init t))
        (write-string
         (with-output-to-string (*standard-output* nil :element-type 'base-char)
           (loop for i from (- (+ n 1) larger) to (+ 1 smaller)
                 do (if init
                        (setq init nil)
                        (write-char #\ ))
                    (write i))
           (terpri)))))))

#-swank (main)

;;;
;;; Test and benchmark
;;;

#+swank
(defun get-clipbrd ()
  (with-output-to-string (out)
    #+os-windows (run-program "powershell.exe" '("-Command" "Get-Clipboard") :output out :search t)
    #+os-unix (run-program "xsel" '("-b" "-o") :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* (or out (make-string-output-stream)))
         (res (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))))))
    (if out res (get-output-stream-string *standard-output*))))

#+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
   (equal "1
"
          (run "2
tourist
petr
e
" nil)))
  (it.bese.fiveam:is
   (equal "1 2 3
"
          (run "2
?o?r?s?
?et?
e
" nil)))
  (it.bese.fiveam:is
   (equal "1 2 3 4 5
"
          (run "4
e
e
e
e
e
" nil)))
  (it.bese.fiveam:is
   (equal "6
"
          (run "5
??
??
d?
?e
?f
zzz
" nil)))
  (it.bese.fiveam:is
   (equal "7
"
          (run "7
atcoder
topcoder
codeforces
hackerrank
csacademy
codechef
atcoder
square
" nil)))
  (it.bese.fiveam:is
   (equal "1 2 3 4 5 6 7
"
          (run "7
??i?
?o???g????
??m??x?
?h?????i
s????
?og????
u??
square
" nil))))


Measured memory_bytes: 30096