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 JavaScript (node.js v5.12) (judge verdict: Wrong Answer)

var counter = function(str,seq){
  return str.split(seq).length - 1;
}

function main(input){
  var count = 0;
  var length = 0;
  var inputS;
  var inputK;
  input = input.split('\n');
  inputS = input[0];
  inputK =  parseInt(input[1]);
  length = inputS.length;

  if(length == 1){
    if(inputK != 1){
      count = Math.floor(inputK / 2);
    }
  }

  else if(length %2 == 1 && counter(inputS,inputS[0]) == length){
    if(inputK %2 == 0){
      set = inputK / 2;
      count = set * length;
    }
    else if(inputK % 2 ==1){
      set = Math.floor(inputK / 2);
      count = set * length + Math.floor(length / 2);
    }
  }

  else{
    for(var i=0;i<length-1;i++){
      if(inputS[i]==inputS[i+1]){
        count++;
        i++;
      }
    }

    if(inputK>=2){
      count = count * inputK;
      if(inputS[0]==inputS[length-1]){
        if(inputS[0]!=inputS[1] || (inputS[0] == inputS[1] && inputS[1] == inputS[2]))
          count += inputK - 1; 
      }
    }
  }

  console.log(count);
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));