






def   snake_case (UpperCAmelCase__     ,   UpperCAmelCase__  )	->    list:
  UpperCamelCase_: List[str]   				=    word.split()

  def justify(UpperCAmelCase__     ,   UpperCAmelCase__     ,   UpperCAmelCase__  ) -> str:
    UpperCamelCase_: Optional[Any]   				=    max_width - width
    UpperCamelCase_: Tuple   				=    len(_UpperCAmelCase  )
    if len(_UpperCAmelCase  ) == 1:
      # if there is only word in line
      # just insert overall_spaces_count for the remainder of line
      return line[0] + " " * overall_spaces_count
    else:
      UpperCamelCase_: List[str]   				=    words_count - 1
      # num_spaces_between_words_list[i] : tells you to insert
      # num_spaces_between_words_list[i] spaces
      # after word on line[i]
      UpperCamelCase_: Dict   				=    spaces_to_insert_between_words * [
          overall_spaces_count // spaces_to_insert_between_words
      ]
      UpperCamelCase_: Tuple   				=    (
          overall_spaces_count % spaces_to_insert_between_words
      )
      # distribute spaces via round robin to the left words
      for i in range(_UpperCAmelCase  ):
        num_spaces_between_words_list[i] += 1
      UpperCamelCase_: int   				=    []
      for i in range(_UpperCAmelCase  ):
        # add the word
        aligned_words_list.append(line[i]  )
        # add the spaces to insert
        aligned_words_list.append(num_spaces_between_words_list[i] * ' '  )
      # just add the last word to the sentence
      aligned_words_list.append(line[-1]  )
      # join the aligned words list to form a justified line
      return "".join(_UpperCAmelCase  )

  UpperCamelCase_: int   				=    []
  UpperCamelCase_: list[str]   				=    []
  UpperCamelCase_: Optional[int]   				=    0
  for word in words:
    if width + len(_UpperCAmelCase  ) + len(_UpperCAmelCase  ) <= max_width:
      # keep adding words until we can fill out max_width
      # width = sum of length of all words (without overall_spaces_count)
      # len(word) = length of current word
      # len(line) = number of overall_spaces_count to insert between words
      line.append(_UpperCAmelCase  )
      width += len(_UpperCAmelCase  )
    else:
      # justify the line and add it to result
      answer.append(justify(_UpperCAmelCase     ,   _UpperCAmelCase     ,   _UpperCAmelCase  )  )
      # reset new line and new width
      UpperCamelCase_: Optional[int]   				=    [word], len(_UpperCAmelCase  )
  UpperCamelCase_: Tuple   				=    max_width - width - len(_UpperCAmelCase  )
  answer.append(' '.join(_UpperCAmelCase  ) + (remaining_spaces + 1) * ' '  )
  return answer


if __name__ == "__main__":
   from doctest import testmod

   testmod()











def   snake_case (UpperCAmelCase__     ,   UpperCAmelCase__  )	->    int:
  while b:
    UpperCamelCase_				,UpperCamelCase_: int   				=    b, a % b
  return a

def   snake_case (UpperCAmelCase__     ,   UpperCAmelCase__  )	->    int:
  return a if b == 0 else euclidean_gcd_recursive(UpperCAmelCase__     ,   a % b  )

def   snake_case ()	->    int:
  print(F'''euclidean_gcd(3, 5) = {euclidean_gcd(3     ,   5  )}'''  )
  print(F'''euclidean_gcd(5, 3) = {euclidean_gcd(5     ,   3  )}'''  )
  print(F'''euclidean_gcd(1, 3) = {euclidean_gcd(1     ,   3  )}'''  )
  print(F'''euclidean_gcd(3, 6) = {euclidean_gcd(3     ,   6  )}'''  )
  print(F'''euclidean_gcd(6, 3) = {euclidean_gcd(6     ,   3  )}'''  )

  print(F'''euclidean_gcd_recursive(3, 5) = {euclidean_gcd_recursive(3     ,   5  )}'''  )
  print(F'''euclidean_gcd_recursive(5, 3) = {euclidean_gcd_recursive(5     ,   3  )}'''  )
  print(F'''euclidean_gcd_recursive(1, 3) = {euclidean_gcd_recursive(1     ,   3  )}'''  )
  print(F'''euclidean_gcd_recursive(3, 6) = {euclidean_gcd_recursive(3     ,   6  )}'''  )
  print(F'''euclidean_gcd_recursive(6, 3) = {euclidean_gcd_recursive(6     ,   3  )}'''  )


if __name__ == "__main__":
   main()