using System;
using System.Linq;
using System.Collections.Generic;
using System.IO;
using static System.Console;
using System.Numerics;
using System.Text.RegularExpressions;
using System.Runtime.Serialization.Formatters.Binary;

namespace atcorder2
{
    [Serializable]
    static class Program
    {
        public static long Read()
        {
            return long.Parse(Console.ReadLine());
        }

        public static long[] Reads()
        {
            return Console.ReadLine().Split().Select(long.Parse).ToArray();
        }


        public static long Gcd(long x, long y)
        {
            if (x < y) Gcd(y, x);
            while (y > 0)
            {
                var z = x;
                x = y;
                y = z % y;
            }
            return x;
        }

        public static long Lcm(long x, long y)
        {
            return x / Gcd(x, y) * y;
        }

        public static bool IsLowercaseAlphabet(char target)
        {
            return new Regex("^[a-z]+$").IsMatch(target.ToString());
        }

        public static T DeepCopy<T>(this T src)
        {
            using (var memoryStream = new MemoryStream())
            {
                var binaryFormatter = new BinaryFormatter();
                binaryFormatter.Serialize(memoryStream, src);
                memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
                return (T)binaryFormatter.Deserialize(memoryStream);
            }
        }


        public static bool Prime(long n)
        {
            if (n < 2) return false;
            else if (n == 2) return true;
            else if (n % 2 == 0) return false;

            for (int i = 3; i <= Math.Sqrt(n); i++)
            {
                if (n % i == 0) return false;
            }
            return true;
        }


        public static int UpperBound<T>(T[] a, T v)
        {
            return UpperBound(a, v, Comparer<T>.Default);
        }

        public static int UpperBound<T>(T[] a, T v, Comparer<T> cmp)
        {
            var l = 0;
            var r = a.Length - 1;
            while (l <= r)
            {
                var mid = l + (r - 1) / 2;
                var res = cmp.Compare(a[mid], v);
                if (res <= 0) l = mid + 1;
                else r = mid - 1;
            }
            return l;
        }
       

        
        public static int LowerBound(long[] a, long v)
        {
            var l = -1;
            var r = a.Length;
            while (r - l > 1)
            {
                var mid = (l + r) / 2;
                if (a[mid] >= v) r = mid;
                else l = mid;
            }
            return r;
        }
        public static  bool LowerBoundf(long[] a, long v)
        {
            var l = -1;
            var r = a.Length;
            var f = false;
            while (r - l > 1)
            {
                var mid = (l + r) / 2;
                if (a[mid] >= v)
                {
                    r = mid;
                    f = true;
                }
                else l = mid;
            }
            return f;
        }

        public static List<int> GeneratePrime(long max)
        {
            System.Diagnostics.Debug.Assert(max >= 2);

            int prime;
            var sqMax = (int)Math.Sqrt(max);
            var primelist = new List<int>();

            var searchList = Enumerable.Range(2, sqMax).ToList();

            do
            {
                prime = searchList.First();
                primelist.Add(prime);
                searchList.RemoveAll(n => n % prime == 0);
            } while (prime < sqMax);

            primelist.AddRange(searchList);

            return primelist;

        }

        static void Main(string[] args)
        {
            var sw = new StreamWriter(OpenStandardOutput()) { AutoFlush = false };
            SetOut(sw);



            var s = ReadLine();
            var k = Read();
            var c = new List<long>();
            var m = s[0];
            c.Add(1);
            long ans = 0;
            for (int i = 1; i < s.Length; i++)
            {
                if (s[i] == m)
                {
                    c[c.Count - 1]++;
                }
                else
                {
                    ans += c[c.Count - 1]/2;
                    c.Add(1);
                    m = s[i];
                }
            }
            if (s.Length > 1 && s[s.Length - 2] == s[s.Length - 1])
                ans += c[c.Count - 1] / 2;


            ans *= k;
            if (s[0] == s[s.Length - 1])
            {
                ans -= (c[0] / 2 + c[c.Count - 1] / 2 - (c[0] + c[c.Count - 1]) / 2) * (k - 1);
            }

            WriteLine(c.Count!=1?ans:s.Length*k/2);



            Out.Flush();
        }
    }
}



Measured memory_bytes: 17584