Where will your buddies sit? You and some buddies are going bowling. There are a total of N bowlers. However, there are only N-1 chairs to sit in. The solution is simple: whoever's turn it currently is doesn't get a chair. Then when their turn is over, they sit in the chair of the person that goes next. 

Lets take an example. Say You are named A, and your four friends are named B, C, D, and E. Every player moves in alphabetical order, so you get to go first. Since there are 5 players, there are only 4 seats. Your friends sit in the four seats in this order:


  CEBD


You go, and yay you get a strike! It's B's turn next, so you sit in his chair. Now it looks like this:


  CEAD


B goes. Gutterball! Then he sits in C's spot, and C goes next turn.


  BEAD


then C sits in D's chair.


  BEAC


and D sits in E's chair


  BDAC


and lastly, E sits in your chair.


  BDEC


You'll notice that now everybody's seat is (pseudo) shuffled. You must find out, after X turns, who will be sitting where?

Input

Your program must take two inputs from the user, a string and a number. No prompts are needed. The string will be 1-51 alphabetic characters (B-Z and a-z) with no repeats. This represents the order your friends chose to sit. There will be no uppercase A because that is you, and you always go first. The number will be the total number of rounds (not games) that you and your friends play. This number will be positive and reasonably sized (less than 1000).

Output

Your program must print out the order your friends are sitting in after X turns, and whose turn it is. So for example, if after X turns the order was BEDGCAHF and it was Z's turn, your program must print exactly this:

BEDGCAHF
It is Z's turn.


Here are a few sample input and outputs.

input: E, 4 
E
It is A's turn.

input: E, 5 
A
It is E's turn.

input: Bb, 2
AB
It is b's turn.

input: dgOPZXKDQYioHflFhpqzUsSaeILwckVNEtGTCJBvnruRyWMmjxb, 999
JNuvFDqjwEPVnMSlOWXgAZyGKordIRBtkamziphcUYbxfCsTQeH
It is L's turn.


Rules


Everybody goes in alphabetical order, with capital letters taking precedence over lower case. 
This is code-golf, so standard loopholes apply, and submissions are scored in bytes.
Pyth, 39 38 bytes
L@+\ASzbuXGyhHyHQzpyQ&quot;It is &quot;&quot;'s turn.

This is based around repeated applications of the find and replace operation, X. The first bit defines a lookup function, y, which finds the bth player in the player order. Then, we repeatedly perform substitutions to find the final seating order, and finally print out whose turn it is.
Amusingly, the code to find the final seating order is shorter (18 bytes) than the code to print whose turn it is (21 bytes).
The code takes the seating string on the first line of STDIN, and the number of turns on the second.
Demonstration.
Explanation:
L@+\ASzbuXGyhHyHQzpyQ&quot;It is &quot;&quot;'s turn.
                                          Implicit:
                                          z = input()
                                          Q = eval(input())

L                                         def y(b): return
  +\ASz                                    &quot;A&quot; + sorted(z)
 @     b                                  (               )[b]
        u       Qz                        reduce for H in range(len(Q)),
                                          G starts as z.
         XGyhHyH                          replace in G y(H+1) with y(H).
                  pyQ&quot;It is &quot;&quot;'s turn.    Print out whose turn it is.