





def    __UpperCamelCase      (    a,     a) ->list:
					lowerCamelCase__       =       word.split()

					def justify(a,     a,     a) -> str:
										lowerCamelCase__       =       max_width - width
										lowerCamelCase__       =       len(a)
										if len(a) == 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(a):
																				num_spaces_between_words_list[i] += 1
															lowerCamelCase__       =       []
															for i in range(a):
																				# 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(a)

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


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

						testmod()








A_												=     {str(digit): digit**5 for digit in range(1_0)}





def    __UpperCamelCase      (    a) ->int:
					return sum(DIGITS_FIFTH_POWER[digit] for digit in str(a))





def    __UpperCamelCase      (    ) ->int:
					return sum(
					    number
					    for number in range(1000,     1000000)
					    if number == digits_fifth_powers_sum(a))


if __name__ == "__main__":
						print(solution())

