"""simple docstring"""






__lowerCAmelCase					: Any        ={
    """meter""": """m""",
    """kilometer""": """km""",
    """megametre""": """Mm""",
    """gigametre""": """Gm""",
    """terametre""": """Tm""",
    """petametre""": """Pm""",
    """exametre""": """Em""",
    """zettametre""": """Zm""",
    """yottametre""": """Ym""",
}
# Exponent of the factor(meter)
__lowerCAmelCase					: Union[str, Any]        ={
    """m""": 0,
    """km""": 3,
    """Mm""": 6,
    """Gm""": 9,
    """Tm""": 1_2,
    """Pm""": 1_5,
    """Em""": 1_8,
    """Zm""": 2_1,
    """Ym""": 2_4,
}


def     UpperCAmelCase__ (       lowerCAmelCase__  :float      ,	lowerCAmelCase__  :str      ,	lowerCAmelCase__  :str	)				->					float:
      '''simple docstring'''


      lowercase														=			from_type.lower().strip("""s"""	)
      lowercase														=			to_type.lower().strip("""s"""	)

      lowercase														=			UNIT_SYMBOL.get(lowerCAmelCase__      ,	lowerCAmelCase__	)
      lowercase														=			UNIT_SYMBOL.get(lowerCAmelCase__      ,	lowerCAmelCase__	)

      if from_sanitized not in METRIC_CONVERSION:
            lowercase														=			(
                f'Invalid \'from_type\' value: {from_type!r}.\n'
                f'Conversion abbreviations are: {", ".join(lowerCAmelCase__	)}'
            )
            raise ValueError(lowerCAmelCase__	)
      if to_sanitized not in METRIC_CONVERSION:
            lowercase														=			(
                f'Invalid \'to_type\' value: {to_type!r}.\n'
                f'Conversion abbreviations are: {", ".join(lowerCAmelCase__	)}'
            )
            raise ValueError(lowerCAmelCase__	)
      lowercase														=			METRIC_CONVERSION[from_sanitized]
      lowercase														=			METRIC_CONVERSION[to_sanitized]
      lowercase														=			1

      if from_exponent > to_exponent:
            lowercase														=			from_exponent - to_exponent
      else:
            lowercase														=			-(to_exponent - from_exponent)

      return value * pow(1_0      ,	lowerCAmelCase__	)


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

       testmod()




"""simple docstring"""






def     UpperCAmelCase__ (       lowerCAmelCase__  :str      ,	lowerCAmelCase__  :int	)				->					list:
      '''simple docstring'''


      lowercase														=			word.split()

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

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


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

       testmod()



