output_description: Print the lexicographically smallest string after performing exactly K
  operations on s.
  
  * * *
input_description: The input is given from Standard Input in the following format:
  
      
      
      s
      K
attempt: #include <algorithm>
  #include <bitset>
  #include <cassert>
  #include <cmath>
  #include <iostream>
  #include <map>
  #include <numeric>
  #include <queue>
  #include <set>
  #include <string>
  #include <vector>
  
  // Acknowledgement: Special thanks to kyomukyomupurin, who developed this
  // template.
  template <class T, class U>
  std::ostream& operator<<(std::ostream& os, const std::pair<T, U>& p) {
    return os << '(' << p.first << ", " << p.second << ')';
  }
  
  template <class T>
  std::ostream& operator<<(std::ostream& os, const std::vector<T>& vec) {
    int n = 0;
    for (auto e : vec) os << (n++ ? ", " : "{") << e;
    return os << (n ? "}" : "{}");
  }
  
  template <class T>
  std::ostream& operator<<(std::ostream& os, const std::set<T>& st) {
    int n = 0;
    for (auto e : st) os << (n++ ? ", " : "{") << e;
    return os << (n ? "}" : "{}");
  }
  
  template <class T, class U>
  std::ostream& operator<<(std::ostream& os, const std::map<T, U>& mp) {
    int n = 0;
    for (auto e : mp) os << (n++ ? ", " : "{") << e;
    return os << (n ? "}" : "{}");
  }
  
  template <class T>
  std::istream& operator>>(std::istream& is, std::vector<T>& vec) {
    for (T& e : vec) is >> e;
    return is;
  }
  
  #ifdef LOCAL
  #define debug(...) \
    std::cerr << "[" << #__VA_ARGS__ << "]: ", debug_out(__VA_ARGS__)
  #else
  #define debug(...)
  #endif
  
  void debug_out() { std::cerr << '\n'; }
  
  template <class Head, class... Tail>
  void debug_out(Head&& head, Tail&&... tail) {
    std::cerr << head;
    if (sizeof...(Tail) != 0) std::cerr << ", ";
    debug_out(std::forward<Tail>(tail)...);
  }
  using namespace std;
  using int64 = long long;
  
  int main() {
    string s;
    int64 K;
    cin >> s >> K;
    int N = s.size();
    for (int i = 0; i < N; i++) {
      int idx = s[i] - 'a';
      if (K >= 26 - idx) {
        K -= 26 - idx;
        s[i] = 'a';
      }
    }
    if (K != 0) {
      int tmp = s[N - 1] - 'a' + K;
      s[N - 1] = tmp + 'a';
    }
    cout << s << endl;
    return 0;
  }
problem_description: 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.
samples: [{"input": "xyz\n    4", "output": "aya\n    \n\nFor example, you can perform the following operations: `xyz`, `yyz`, `zyz`,\n`ayz`, `aya`.\n\n* * *"}, {"input": "a\n    25", "output": "z\n    \n\nYou have to perform exactly K operations.\n\n* * *"}, {"input": "codefestival\n    100", "output": "aaaafeaaivap"}]