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: # -*- coding: utf-8 -*-
  import sys
  import math
  import os
  import itertools
  import string
  import heapq
  import _collections
  from collections import Counter
  from collections import defaultdict
  from functools import lru_cache
  import bisect
  import re
  import queue
  from decimal import *
  
  
  class Scanner:
      @staticmethod
      def int():
          return int(sys.stdin.readline().rstrip())
  
      @staticmethod
      def string():
          return sys.stdin.readline().rstrip()
  
      @staticmethod
      def map_int():
          return [int(x) for x in Scanner.string().split()]
  
      @staticmethod
      def string_list(n):
          return [input() for i in range(n)]
  
      @staticmethod
      def int_list_list(n):
          return [Scanner.map_int() for i in range(n)]
  
      @staticmethod
      def int_cols_list(n):
          return [int(input()) for i in range(n)]
  
  
  class Math:
      @staticmethod
      def gcd(a, b):
          if b == 0:
              return a
          return Math.gcd(b, a % b)
  
      @staticmethod
      def lcm(a, b):
          return (a * b) // Math.gcd(a, b)
  
      @staticmethod
      def divisor(n):
          res = []
          i = 1
          for i in range(1, int(n**0.5) + 1):
              if n % i == 0:
                  res.append(i)
                  if i != n // i:
                      res.append(n // i)
          return res
  
      @staticmethod
      def round_up(a, b):
          return -(-a // b)
  
      @staticmethod
      def is_prime(n):
          if n < 2:
              return False
          if n == 2:
              return True
          if n % 2 == 0:
              return False
          d = int(n**0.5) + 1
          for i in range(3, d + 1, 2):
              if n % i == 0:
                  return False
          return True
  
  
  def pop_count(x):
      x = x - ((x >> 1) & 0x5555555555555555)
      x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
      x = (x + (x >> 4)) & 0x0F0F0F0F0F0F0F0F
      x = x + (x >> 8)
      x = x + (x >> 16)
      x = x + (x >> 32)
      return x & 0x0000007F
  
  
  MOD = int(1e09) + 7
  INF = int(1e15)
  
  
  def solve():
      S = list(Scanner.string())
      K = Scanner.int()
      i = 0
      while i < len(S):
          c = S[i]
          n = ord(c) - ord("a")
          if n > 0 and 26 - n <= K:
              c = "a"
              K -= 26 - n
              S[i] = c
          i += 1
      if K > 0:
          c = S[-1]
          for _ in range(K % 26):
              c = chr(ord(c) + 1)
              if c == chr(ord("z") + 1):
                  c = "a"
          S[-1] = c
      print("".join(S))
  
  
  def main():
      # sys.stdin = open("sample.txt")
      solve()
  
  
  if __name__ == "__main__":
      main()
  
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"}]