

snake_case_			  = range(2, 20 + 1)
snake_case_			  = [10**k for k in range(ks[-1] + 1)]
snake_case_			  = {}

def 	snake_case__			(    SCREAMING_SNAKE_CASE_		:    Optional[int]	,     SCREAMING_SNAKE_CASE_		:    str	,     SCREAMING_SNAKE_CASE_		:    Dict	,     SCREAMING_SNAKE_CASE_		:    Union[str, Any]			):



     '''simple docstring'''





     lowercase__    :   Optional[Any]      =       sum(a_i[j] for j in range(SCREAMING_SNAKE_CASE_	,     len(SCREAMING_SNAKE_CASE_			)			)			)
     lowercase__    :   Dict      =       sum(a_i[j] * base[j] for j in range(min(len(SCREAMING_SNAKE_CASE_			)	,     SCREAMING_SNAKE_CASE_			)			)			)

     lowercase__      , lowercase__    :   Any      =       0, 0
     lowercase__    :   Tuple      =       n - i

     lowercase__    :   Union[str, Any]      =       memo.get(SCREAMING_SNAKE_CASE_			)

     if sub_memo is not None:
          lowercase__    :   List[str]      =       sub_memo.get(SCREAMING_SNAKE_CASE_			)

          if jumps is not None and len(SCREAMING_SNAKE_CASE_			) > 0:
               # find and make the largest jump without going over
               lowercase__    :   int      =       -1
               for _k in range(len(SCREAMING_SNAKE_CASE_			) - 1	,     -1	,     -1			):
                    if jumps[_k][2] <= k and jumps[_k][1] <= max_dn:
                         lowercase__    :   List[Any]      =       _k
                         break

               if max_jump >= 0:
                    lowercase__      , lowercase__      , lowercase__    :   List[str]      =       jumps[max_jump]
                    # since the difference between jumps is cached, add c
                    lowercase__    :   List[str]      =       diff + c
                    for j in range(min(SCREAMING_SNAKE_CASE_	,     len(SCREAMING_SNAKE_CASE_			)			)			):
                         lowercase__      , lowercase__    :   List[Any]      =       divmod(SCREAMING_SNAKE_CASE_	,     10			)
                    if new_c > 0:
                         add(SCREAMING_SNAKE_CASE_	,     SCREAMING_SNAKE_CASE_	,     SCREAMING_SNAKE_CASE_			)

          else:
               lowercase__    :   str      =       []
     else:
          lowercase__    :   List[str]      =       {c: []}
          lowercase__    :   int      =       sub_memo

     if dn >= max_dn or c + diff >= base[k]:
          return diff, dn

     if k > ks[0]:
          while True:
               # keep doing smaller jumps
               lowercase__      , lowercase__    :   Optional[int]      =       next_term(SCREAMING_SNAKE_CASE_	,     k - 1	,     i + dn	,     SCREAMING_SNAKE_CASE_			)
               diff += _diff
               dn += terms_jumped

               if dn >= max_dn or c + diff >= base[k]:
                    break
     else:
          # would be too small a jump, just compute sequential terms instead
          lowercase__      , lowercase__    :   Dict      =       compute(SCREAMING_SNAKE_CASE_	,     SCREAMING_SNAKE_CASE_	,     i + dn	,     SCREAMING_SNAKE_CASE_			)
          diff += _diff
          dn += terms_jumped

     lowercase__    :   str      =       sub_memo[c]

     # keep jumps sorted by # of terms skipped
     lowercase__    :   Optional[int]      =       0
     while j < len(SCREAMING_SNAKE_CASE_			):
          if jumps[j][1] > dn:
               break
          j += 1

     # cache the jump for this value digitsum(b) and c
     sub_memo[c].insert(SCREAMING_SNAKE_CASE_	,     (diff, dn, k)			)
     return (diff, dn)

def 	snake_case__			(    SCREAMING_SNAKE_CASE_		:    Dict	,     SCREAMING_SNAKE_CASE_		:    int	,     SCREAMING_SNAKE_CASE_		:    Dict	,     SCREAMING_SNAKE_CASE_		:    List[str]			):



     '''simple docstring'''





     if i >= n:
          return 0, i
     if k > len(SCREAMING_SNAKE_CASE_			):
          a_i.extend([0 for _ in range(k - len(SCREAMING_SNAKE_CASE_			)			)]			)

     # note: a_i -> b * 10^k + c
     # ds_b -> digitsum(b)
     # ds_c -> digitsum(c)
     lowercase__    :   int      =       i
     lowercase__      , lowercase__      , lowercase__    :   int      =       0, 0, 0
     for j in range(len(SCREAMING_SNAKE_CASE_			)			):
          if j >= k:
               ds_b += a_i[j]
          else:
               ds_c += a_i[j]

     while i < n:
          i += 1
          lowercase__    :   Tuple      =       ds_c + ds_b
          diff += addend
          lowercase__    :   List[str]      =       0
          for j in range(SCREAMING_SNAKE_CASE_			):
               lowercase__    :   Optional[int]      =       a_i[j] + addend
               lowercase__      , lowercase__    :   Optional[Any]      =       divmod(SCREAMING_SNAKE_CASE_	,     10			)

               ds_c += a_i[j]

          if addend > 0:
               break

     if addend > 0:
          add(SCREAMING_SNAKE_CASE_	,     SCREAMING_SNAKE_CASE_	,     SCREAMING_SNAKE_CASE_			)
     return diff, i - start_i

def 	snake_case__			(    SCREAMING_SNAKE_CASE_		:    Optional[Any]	,     SCREAMING_SNAKE_CASE_		:    Optional[Any]	,     SCREAMING_SNAKE_CASE_		:    str			):



     '''simple docstring'''





     for j in range(SCREAMING_SNAKE_CASE_	,     len(SCREAMING_SNAKE_CASE_			)			):
          lowercase__    :   List[Any]      =       digits[j] + addend
          if s >= 10:
               lowercase__      , lowercase__    :   str      =       divmod(SCREAMING_SNAKE_CASE_	,     10			)
               lowercase__    :   Tuple      =       addend // 10 + quotient
          else:
               lowercase__    :   Tuple      =       s
               lowercase__    :   Any      =       addend // 10

          if addend == 0:
               break

     while addend > 0:
          lowercase__      , lowercase__    :   Union[str, Any]      =       divmod(SCREAMING_SNAKE_CASE_	,     10			)
          digits.append(SCREAMING_SNAKE_CASE_			)

def 	snake_case__			(    SCREAMING_SNAKE_CASE_		:    int = 10**15			):



     '''simple docstring'''





     lowercase__    :   Optional[Any]      =       [1]
     lowercase__    :   List[Any]      =       1
     lowercase__    :   Optional[int]      =       0
     while True:
          lowercase__      , lowercase__    :   int      =       next_term(SCREAMING_SNAKE_CASE_	,     20	,     i + dn	,     SCREAMING_SNAKE_CASE_			)
          dn += terms_jumped
          if dn == n - i:
               break

     lowercase__    :   Tuple      =       0
     for j in range(len(SCREAMING_SNAKE_CASE_			)			):
          a_n += digits[j] * 10**j
     return a_n


if __name__ == "__main__":
       print(F'''{solution() = }''')




from __future__ import annotations

from typing import Any


class       SCREAMING_SNAKE_CASE__					:





    def __init__(      self						,   a						,   a						,   a = 0):
         lowercase__      , lowercase__    :   Dict      =       row, column
         lowercase__    :   Optional[Any]      =       [[default_value for c in range(a)] for r in range(a)]





    def __str__(      self):
         lowercase__    :   Tuple      =       f"""Matrix consist of {self.row} rows and {self.column} columns\n"""

         # Make string identifier
         lowercase__    :   Optional[int]      =       0
         for row_vector in self.array:
              for obj in row_vector:
                   lowercase__    :   List[str]      =       max(a						,   len(str(a)))
         lowercase__    :   Optional[int]      =       f"""%{max_element_length}s"""

         # Make string and return
         def single_line(a) -> str:
              nonlocal string_format_identifier
              lowercase__    :   Tuple      =       '['
              line += ", ".join(string_format_identifier % (obj,) for obj in row_vector)
              line += "]"
              return line

         s += "\n".join(single_line(a) for row_vector in self.array)
         return s





    def __repr__(      self):
         return str(self)





    def       snake_case_				(      self						,   a):
         if not (isinstance(a						,   (list, tuple)) and len(a) == 2):
              return False
         elif not (0 <= loc[0] < self.row and 0 <= loc[1] < self.column):
              return False
         else:
              return True





    def __getitem__(      self						,   a):
         assert self.validate_indicies(a)
         return self.array[loc[0]][loc[1]]





    def __setitem__(      self						,   a						,   a):
         assert self.validate_indicies(a)
         lowercase__    :   List[str]      =       value





    def __add__(      self						,   a):
         assert isinstance(a						,   a)
         assert self.row == another.row and self.column == another.column

         # Add
         lowercase__    :   List[str]      =       Matrix(self.row						,   self.column)
         for r in range(self.row):
              for c in range(self.column):
                   lowercase__    :   Dict      =       self[r, c] + another[r, c]
         return result





    def __neg__(      self):
         lowercase__    :   List[Any]      =       Matrix(self.row						,   self.column)
         for r in range(self.row):
              for c in range(self.column):
                   lowercase__    :   int      =       -self[r, c]
         return result





    def __sub__(      self						,   a):
         return self + (-another)





    def __mul__(      self						,   a):

         if isinstance(a						,   (int, float)):  # Scalar multiplication
              lowercase__    :   Optional[Any]      =       Matrix(self.row						,   self.column)
              for r in range(self.row):
                   for c in range(self.column):
                        lowercase__    :   Union[str, Any]      =       self[r, c] * another
              return result
         elif isinstance(a						,   a):  # Matrix multiplication
              assert self.column == another.row
              lowercase__    :   List[Any]      =       Matrix(self.row						,   another.column)
              for r in range(self.row):
                   for c in range(another.column):
                        for i in range(self.column):
                             result[r, c] += self[r, i] * another[i, c]
              return result
         else:
              lowercase__    :   Optional[Any]      =       f"""Unsupported type given for another ({type(a)})"""
              raise TypeError(a)





    def       snake_case_				(      self):
         lowercase__    :   Optional[int]      =       Matrix(self.column						,   self.row)
         for r in range(self.row):
              for c in range(self.column):
                   lowercase__    :   str      =       self[r, c]
         return result





    def       snake_case_				(      self						,   a						,   a):
         assert isinstance(a						,   a) and isinstance(a						,   a)
         assert self.row == self.column == u.row == v.row  # u, v should be column vector
         assert u.column == v.column == 1  # u, v should be column vector

         # Calculate
         lowercase__    :   int      =       v.transpose()
         lowercase__    :   Tuple      =       (v_t * self * u)[0, 0] + 1
         if numerator_factor == 0:
              return None  # It's not invertable
         return self - ((self * u) * (v_t * self) * (1.0 / numerator_factor))


# Testing
if __name__ == "__main__":

       def 	snake_case__			(    ):



            '''simple docstring'''





            lowercase__    :   Any      =       Matrix(3	,     3	,     0			)
            for i in range(3			):
                 lowercase__    :   str      =       1
            print(f"""a^(-1) is {ainv}"""			)
            # u, v
            lowercase__    :   Optional[Any]      =       Matrix(3	,     1	,     0			)
            lowercase__      , lowercase__      , lowercase__    :   List[Any]      =       1, 2, -3
            lowercase__    :   Union[str, Any]      =       Matrix(3	,     1	,     0			)
            lowercase__      , lowercase__      , lowercase__    :   Any      =       4, -2, 5
            print(f"""u is {u}"""			)
            print(f"""v is {v}"""			)
            print(f"""uv^T is {u * v.transpose()}"""			)
            # Sherman Morrison
            print(f"""(a + uv^T)^(-1) is {ainv.sherman_morrison(SCREAMING_SNAKE_CASE_	,     SCREAMING_SNAKE_CASE_			)}"""			)

       def 	snake_case__			(    ):



            '''simple docstring'''





            import doctest

            doctest.testmod()

       testa()

