




def      _SCREAMING_SNAKE_CASE     (				lowercase      :			str      ,				lowercase      :			int	):


      '''simple docstring'''



      lowerCamelCase_							=       word.split()

      def justify(lowercase      :			list      ,				lowercase      :			int      ,				lowercase      :			int	) -> str:
            lowerCamelCase_							=       max_width - width
            lowerCamelCase_							=       len(lowercase	)
            if len(lowercase	) == 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:
                  lowerCamelCase_							=       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]
                  lowerCamelCase_							=       spaces_to_insert_between_words * [
                      overall_spaces_count // spaces_to_insert_between_words
                  ]
                  lowerCamelCase_							=       (
                      overall_spaces_count % spaces_to_insert_between_words
                  )
                  # distribute spaces via round robin to the left words
                  for i in range(lowercase	):
                        num_spaces_between_words_list[i] += 1
                  lowerCamelCase_							=       []
                  for i in range(lowercase	):
                        # 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(lowercase	)

      lowerCamelCase_							=       []
      lowerCamelCase_							=       []
      lowerCamelCase_							=       0
      for word in words:
            if width + len(lowercase	) + len(lowercase	) <= 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(lowercase	)
                  width += len(lowercase	)
            else:
                  # justify the line and add it to result
                  answer.append(justify(lowercase      ,				lowercase      ,				lowercase	)	)
                  # reset new line and new width
                  lowerCamelCase_	,							lowerCamelCase_							=       [word], len(lowercase	)
      lowerCamelCase_							=       max_width - width - len(lowercase	)
      answer.append(' '.join(lowercase	) + (remaining_spaces + 1) * ' '	)
      return answer


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

 testmod()









'''simple docstring'''
def 			lowerCamelCase(							SCREAMING_SNAKE_CASE_       ,SCREAMING_SNAKE_CASE_     )		->		bool:
			A_									= len(SCREAMING_SNAKE_CASE_     ) + 1
			A_									= len(SCREAMING_SNAKE_CASE_     ) + 1

			# dp is a 2d matrix where dp[i][j] denotes whether prefix string of
			# length i of input_string matches with prefix string of length j of
			# given pattern.
			# "dp" stands for dynamic programming.
			A_									= [[0 for i in range(SCREAMING_SNAKE_CASE_     )] for j in range(SCREAMING_SNAKE_CASE_     )]

			# since string of zero length match pattern of zero length
			A_									= 1

			# since pattern of zero length will never match with string of non-zero length
			for i in range(1       ,SCREAMING_SNAKE_CASE_     ):
						A_									= 0

			# since string of zero length will match with pattern where there
			# is at least one * alternatively
			for j in range(1       ,SCREAMING_SNAKE_CASE_     ):
						A_									= dp[0][j - 2] if pattern[j - 1] == '*' else 0

			# now using bottom-up approach to find for all remaining lengths
			for i in range(1       ,SCREAMING_SNAKE_CASE_     ):
						for j in range(1       ,SCREAMING_SNAKE_CASE_     ):
									if input_string[i - 1] == pattern[j - 1] or pattern[j - 1] == ".":
												A_									= dp[i - 1][j - 1]

									elif pattern[j - 1] == "*":
												if dp[i][j - 2] == 1:
															A_									= 1
												elif pattern[j - 2] in (input_string[i - 1], "."):
															A_									= dp[i - 1][j]
												else:
															A_									= 0
									else:
												A_									= 0

			return bool(dp[-1][-1]     )


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							# inputing the strings
							# input_string = input("input a string :")
							# pattern = input("input a pattern :")

							_SCREAMING_SNAKE_CASE			=						"aab"
							_SCREAMING_SNAKE_CASE			=						"c*a*b"

							# using function to check whether given string matches the given pattern
							if match_pattern(input_string, pattern):
														print(f"""{input_string} matches the given pattern {pattern}""")
							else:
														print(f"""{input_string} does not match with the given pattern {pattern}""")




