Problem:
Score : 300 points

Problem Statement

Given is a string S. Let T be the concatenation of K copies of S.
We can repeatedly perform the following operation: choose a character in T and replace it with a different character.
Find the minimum number of operations required to satisfy the following condition: any two adjacent characters in T are different.

Constraints

1 \leq |S| \leq 100

S consists of lowercase English letters.

1 \leq K \leq 10^9

K is an integer.

Input

Input is given from Standard Input in the following format:

S
K

Output

Print the minimum number of operations required.

Sample Input 1

issii
2

Sample Output 1

4

T is issiiissii. For example, we can rewrite it into ispiqisyhi, and now any two adjacent characters are different.

Sample Input 2

qq
81

Sample Output 2

81

Sample Input 3

cooooooooonteeeeeeeeeest
999993333

Sample Output 3

8999939997

Solution in Common Lisp (SBCL 1.1.14) (judge verdict: Runtime Error)

(defun cnt-string (s)
  "入力文字列に対し必要な置換操作の回数を返す"
  (let ((cnt 1)
        (okikae 0)
        (hanei nil)) 
    (dotimes (i (length s))
      (if (> i 0) 
          (if (char= (elt s (1- i)) (elt s i)) 
              (incf cnt)
              (progn 
                (setf hanei t)
                (incf okikae (floor cnt 2)) 
                (setf cnt 1)))))
    (if hanei
        okikae
        (floor cnt 2))))

(defun same-string (s k)
  "入力文字列の両端が同じ場合"
  (let ((start 0)
        (end 0)) 
    (dotimes (i (length s))
      (if (> i 0) 
          (when (char/= (elt s (1- i)) (elt s i)) (setf start i) (return))))
    (do ((l 0 (1+ l)))
        (((>= l (length s)) (setf start l))
         ((char/= (elt s (1- l)) (elt s l)) (setf start l))))
    (setf end 
          (if (>= start (length s)) 
              -1
              (do ((j (1- (length s)) (1- j)))
               ((or (< j 1) (char/= (elt s (1- j)) (elt s j)) ) j))))
    (if (= end -1) 
        (floor (length s) 2) 
        (+ (floor start 2) (floor (- (length s) end) 2) (* k (cnt-string (subseq s start end))) (* (1- k) (floor (+ start (- (length s) end)) 2))))))

(defun main ()
  (let ((s (string (read)))
        (k (read)))
    (if (= (length s) 1) (format t "~a" (floor k 2)))
    (if (char= (elt s 0) (elt s (1- (length s))))
        (format t "~a" (same-string s k)) 
        (format t "~a" (* (cnt-string s) k)))))

(main)