;; -*- coding: utf-8 -*-
(eval-when (:compile-toplevel :load-toplevel :execute)
  (defparameter OPT
    #+swank '(optimize (speed 3) (safety 2))
    #-swank '(optimize (speed 3) (safety 0) (debug 0)))
  #+swank (ql:quickload '(:cl-debug-print :fiveam))
  #-swank (set-dispatch-macro-character #\# #\> (lambda (s c p) (declare (ignore c p)) (read s nil (values) t))))
#+swank (cl-syntax:use-syntax cl-debug-print:debug-print-syntax)
#-swank (disable-debugger) ; for CS Academy

;; BEGIN_INSERTED_CONTENTS
(defmacro with-buffered-stdout (&body body)
  "Buffers all outputs to *STANDARD-OUTPUT* in BODY and flushes them to
*STANDARD-OUTPUT* after BODY has been done (without error). Note that only
BASE-CHAR is allowed."
  (let ((out (gensym)))
    `(let ((,out (make-string-output-stream :element-type 'base-char)))
       (let ((*standard-output* ,out))
         ,@body)
       (write-string (get-output-stream-string ,out)))))

(declaim (inline println-sequence))
(defun println-sequence (sequence &key (out *standard-output*) (key #'identity))
  (let ((init t))
    (sequence:dosequence (x sequence)
      (if init
          (setq init nil)
          (write-char #\  out))
      (princ (funcall key x) out))
    (terpri out)))

;;;
;;; Calculate a^n on any monoids in O(log(n)) time
;;;

(declaim (inline power))
(defun power (base exponent op identity)
  "OP := binary operation (on a monoid)
IDENTITY := identity element w.r.t. OP"
  (declare ((integer 0) exponent)
           (function op))
  (labels ((recur (x p)
             (declare ((integer 0 #.most-positive-fixnum) p))
             (cond ((= 0 p) identity)
                   ((evenp p) (recur (funcall op x x) (ash p -1)))
                   (t (nth-value 0 (funcall op x (recur x (- p 1)))))))
           (recur-big (x p)
             (declare ((integer 0) p))
             (cond ((zerop p) identity)
                   ((evenp p) (recur-big (funcall op x x) (ash p -1)))
                   (t (nth-value 0 (funcall op x (recur-big x (- p 1))))))))
    (typecase exponent
      (fixnum (recur base exponent))
      (otherwise (recur-big base exponent)))))

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

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

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

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

(defconstant +mod+ 1000000007)

;; Body

(declaim (inline make-next-table))
(defun make-next-table (vector &key (test #'eql) (element-type 'fixnum) double)
  "Returns a vector of indices: Let the vector be NEXT; Then each
VECTOR[NEXT[index]] is the first element equal to VECTOR[index] later than the
index. Note that this function handles VECTOR in a circular manner: e.g. #(3 2 3
1) |-> #(2 1 0 3)."
  (declare (vector vector))
  (let* ((n (length vector))
         (result (make-array n :element-type element-type))
         (table (make-hash-table :test test)))
    (if double
        (loop for i from (- (* 2 n) 1) downto n
              do (setf (gethash (aref vector (- i n)) table) i))
        (loop for i from (- n 1) downto 0
              do (setf (gethash (aref vector i) table) i)))
    (loop for i from (- n 1) downto 0
          do (setf (aref result i) (gethash (aref vector i) table)
                   (gethash (aref vector i) table) i))
    result))

(defun main ()
  (declare #.OPT)
  (let* ((n (read))
         (k (read))
         (as (make-array n :element-type 'uint32 :initial-element 0))
         (iden (make-array (+ n 1) :element-type 'uint32 :initial-element 0)))
    (declare (uint62 n k))
    (dotimes (i n) (setf (aref as i) (read-fixnum)))
    (dotimes (i (+ n 1)) (setf (aref iden i) i))
    (let ((nexts (make-next-table as :element-type 'uint32 :double t))
          (map (make-array (+ n 1) :element-type 'uint32 :initial-element 0)))
      (dotimes (i n)
        (setf (aref nexts i) (+ 1 (aref nexts i))
              (aref map i) (aref nexts i)))
      (loop for i from (- n 1) downto 0
            do (if (< (aref map i) n)
                   (setf (aref map i) (aref map (aref map i)))
                   (setf (aref map i) (- (aref map i) n))))
      (let* ((final-map
               (power map (- k 1)
                      (lambda (x y)
                        (declare ((simple-array uint32 (*)) x y))
                        (let ((new (make-array (+ n 1) :element-type 'uint32)))
                          (dotimes (i (+ n 1))
                            (setf (aref new i) (aref y (aref x i))))
                          new))
                      iden))
             (pos (aref final-map 0))
             (res (make-array 0 :fill-pointer 0)))
        (loop until (= pos n)
              do (if (<= (aref nexts pos) n)
                     (setq pos (aref nexts pos))
                     (progn
                       (vector-push-extend (aref as pos) res)
                       (incf pos))))
        (with-buffered-stdout
          (println-sequence res))))))

#-swank (main)


Measured memory_bytes: 77280