


'''simple docstring'''







from __future__ import annotations

from typing import TypedDict







class A__       (						UpperCAmelCase__      ):
      __UpperCamelCase       :  str
      __UpperCamelCase       :  int


def 	SCREAMING_SNAKE_CASE_					(  _UpperCAmelCase	:	str  )  ->			list[str]:
       if not isinstance(_UpperCAmelCase    ,_UpperCAmelCase  ):
              raise TypeError("""The parameter s type must be str."""  )

       return [s[i:] + s[:i] for i in range(len(_UpperCAmelCase  )  )]


def 	SCREAMING_SNAKE_CASE_					(  _UpperCAmelCase	:	str  )  ->			BWTTransformDict:
       if not isinstance(_UpperCAmelCase    ,_UpperCAmelCase  ):
              raise TypeError("""The parameter s type must be str."""  )
       if not s:
              raise ValueError("""The parameter s must not be empty."""  )

       _a    : List[Any]     					=all_rotations(_UpperCAmelCase  )
       rotations.sort()  # sort the list of rotations in alphabetically order
       # make a string composed of the last char of each rotation
       _a    : BWTTransformDict     					={
           "bwt_string": "".join([word[-1] for word in rotations]  ),
           "idx_original_string": rotations.index(_UpperCAmelCase  ),
       }
       return response


def 	SCREAMING_SNAKE_CASE_					(  _UpperCAmelCase	:	str    ,_UpperCAmelCase	:	int  )  ->			str:
       if not isinstance(_UpperCAmelCase    ,_UpperCAmelCase  ):
              raise TypeError("""The parameter bwt_string type must be str."""  )
       if not bwt_string:
              raise ValueError("""The parameter bwt_string must not be empty."""  )
       try:
              _a    : List[str]     					=int(_UpperCAmelCase  )
       except ValueError:
              raise TypeError(
                  """The parameter idx_original_string type must be int or passive"""
                  """ of cast to int."""  )
       if idx_original_string < 0:
              raise ValueError("""The parameter idx_original_string must not be lower than 0."""  )
       if idx_original_string >= len(_UpperCAmelCase  ):
              raise ValueError(
                  """The parameter idx_original_string must be lower than""" """ len(bwt_string)."""  )

       _a    : Optional[int]     					=[""""""] * len(_UpperCAmelCase  )
       for _ in range(len(_UpperCAmelCase  )  ):
              for i in range(len(_UpperCAmelCase  )  ):
                     _a    : int     					=bwt_string[i] + ordered_rotations[i]
              ordered_rotations.sort()
       return ordered_rotations[idx_original_string]


if __name__ == "__main__":
   A__:    Any					    =       '''Provide a string that I will generate its BWT transform: '''
   A__:    Union[str, Any]					    =       input(entry_msg).strip()
   A__:    Optional[int]					    =       bwt_transform(s)
   print(
       F"Burrows Wheeler transform for string '{s}' results "
       F"in '{result['bwt_string']}'"
   )
   A__:    Union[str, Any]					    =       reverse_bwt(result['''bwt_string'''], result['''idx_original_string'''])
   print(
       F"Reversing Burrows Wheeler transform for entry '{result['bwt_string']}' "
       F"we get original string '{original_string}'"
   )






'''simple docstring'''







A__:    Optional[int]					    =       [4, 1, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
A__:    Any					    =       [3, 7, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
A__:    int					    =       {
    0: '''Sunday''',
    1: '''Monday''',
    2: '''Tuesday''',
    3: '''Wednesday''',
    4: '''Thursday''',
    5: '''Friday''',
    6: '''Saturday''',
}


def 	SCREAMING_SNAKE_CASE_					(  _UpperCAmelCase	:	int    ,_UpperCAmelCase	:	int    ,_UpperCAmelCase	:	int  )  ->			str:
       assert len(str(_UpperCAmelCase  )  ) > 2, "year should be in YYYY format"
       assert 1 <= month <= 12, "month should be between 1 to 12"
       assert 1 <= day <= 31, "day should be between 1 to 31"

       # Doomsday algorithm:
       _a    : List[str]     					=year // 100
       _a    : List[str]     					=(5 * (century % 4) + 2) % 7
       _a    : Optional[int]     					=year % 100
       _a    : Any     					=centurian % 12
       _a    : int     					=(
           (centurian // 12) + centurian_m + (centurian_m // 4) + century_anchor
       ) % 7
       _a    : Optional[Any]     					=(
           DOOMSDAY_NOT_LEAP[month - 1]
           if (year % 4 != 0) or (centurian == 0 and (year % 400) == 0)
           else DOOMSDAY_LEAP[month - 1]
       )
       _a    : str     					=(dooms_day + day - day_anchor) % 7
       return WEEK_DAY_NAMES[week_day]


if __name__ == "__main__":
   import doctest

   doctest.testmod()


