Problem:
Score : 400 points

Problem Statement

Mr. Takahashi has a string s consisting of lowercase English letters.
He repeats the following operation on s exactly K times.

Choose an arbitrary letter on s and change that letter to the next alphabet. Note that the next letter of z is a.

For example, if you perform an operation for the second letter on aaz, aaz becomes abz.
If you then perform an operation for the third letter on abz, abz becomes aba.

Mr. Takahashi wants to have the lexicographically smallest string after performing exactly K operations on s.
Find the such string.

Constraints

1≤|s|≤10^5

All letters in s are lowercase English letters.

1≤K≤10^9

Input

The input is given from Standard Input in the following format:

s
K

Output

Print the lexicographically smallest string after performing exactly K operations on s.

Sample Input 1

xyz
4

Sample Output 1

aya

For example, you can perform the following operations: xyz, yyz, zyz, ayz, aya.

Sample Input 2

a
25

Sample Output 2

z

You have to perform exactly K operations.

Sample Input 3

codefestival
100

Sample Output 3

aaaafeaaivap

Solution in Rust (1.42.0) (judge verdict: Wrong Answer)

#![allow(non_snake_case)]
use proconio::input;
// use std::collections::HashMap;

fn next_ch(ch: char, ind: u8) -> char {
    // println!("next_ch({}, {})", ch, ind);

    if ind == 0 {
        return ch;
    }

    if ch == 'z' {
        return next_ch('a', ind - 1);
    }

    let new_ch = ((ch as u8) + 1) as char;

    return next_ch(new_ch, ind - 1);
}

fn main() {
    input! {
        S: String,
        K: i64,
    }

    // 最初の文字を捌けるならやったほうが得
    // そうでないなら、できるだけ後ろの文字を対応したほうがいい

    let len = S.len();
    let mut ans: String = String::from("");


    let mut rest: i64 = K as i64;
    for (i, ch) in S.char_indices() {
        let cand = (('z' as u8) - (ch as u8) + 1) as i64;
        let new_ch = if rest >= cand { 'a' } else { ch };
        if rest >= cand {
            rest -= cand;
        }

        // 最後については、余っているぶんを全適用する
        if i == len - 1 {
            let new_new_ch = next_ch(new_ch, rest as u8);
            ans += &new_new_ch.to_string();
        } else {
            ans += &new_ch.to_string();
        }
    }

    println!("{}", ans);
}