


UpperCAmelCase_   :				Dict						      = {
    'meter': 'm',
    'kilometer': 'km',
    'megametre': 'Mm',
    'gigametre': 'Gm',
    'terametre': 'Tm',
    'petametre': 'Pm',
    'exametre': 'Em',
    'zettametre': 'Zm',
    'yottametre': 'Ym',
}
# Exponent of the factor(meter)
UpperCAmelCase_   :				Optional[int]						      = {
    'm': 0,
    'km': 3,
    'Mm': 6,
    'Gm': 9,
    'Tm': 12,
    'Pm': 15,
    'Em': 18,
    'Zm': 21,
    'Ym': 24,
}







def  SCREAMING_SNAKE_CASE_		(    __A				:    float						,					__A				:    str						,					__A				:    str       )			->	float:

       """simple docstring"""

       a_      :	int							=						from_type.lower().strip('s'       )
       a_      :	List[Any]							=						to_type.lower().strip('s'       )

       a_      :	Any							=						UNIT_SYMBOL.get(__A						,					__A       )
       a_      :	Optional[int]							=						UNIT_SYMBOL.get(__A						,					__A       )

       if from_sanitized not in METRIC_CONVERSION:
              a_      :	List[Any]							=						(
                  F"""Invalid 'from_type' value: {from_type!r}.\n"""
                  F"""Conversion abbreviations are: {", ".join(__A       )}"""
              )
              raise ValueError(__A       )
       if to_sanitized not in METRIC_CONVERSION:
              a_      :	Tuple							=						(
                  F"""Invalid 'to_type' value: {to_type!r}.\n"""
                  F"""Conversion abbreviations are: {", ".join(__A       )}"""
              )
              raise ValueError(__A       )
       a_      :	Union[str, Any]							=						METRIC_CONVERSION[from_sanitized]
       a_      :	List[Any]							=						METRIC_CONVERSION[to_sanitized]
       a_      :	List[str]							=						1

       if from_exponent > to_exponent:
              a_      :	Tuple							=						from_exponent - to_exponent
       else:
              a_      :	Dict							=						-(to_exponent - from_exponent)

       return value * pow(10						,					__A       )


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

   testmod()






def  SCREAMING_SNAKE_CASE_		(    __A				:    list       )			->	list:

       """simple docstring"""

       if len(__A       ) <= 1:
              return [tuple(__A       )]

       a_      :	Optional[Any]							=						[]

       def generate(__A				:    int						,					__A				:    list       ):
              a_      :	str							=						[0] * n
              res.append(tuple(__A       )       )

              a_      :	Optional[int]							=						0
              while i < n:
                     if c[i] < i:
                            if i % 2 == 0:
                                   a_							,	a_      :	Dict							=						arr[i], arr[0]
                            else:
                                   a_							,	a_      :	Union[str, Any]							=						arr[i], arr[c[i]]
                            res.append(tuple(__A       )       )
                            c[i] += 1
                            a_      :	Dict							=						0
                     else:
                            a_      :	Optional[Any]							=						0
                            i += 1

       generate(len(__A       )						,					__A       )
       return res


if __name__ == "__main__":
   UpperCAmelCase_   :				Union[str, Any]						      = input('Enter numbers separated by a comma:\n').strip()
   UpperCAmelCase_   :				Optional[Any]						      = [int(item) for item in user_input.split(',')]
   print(heaps(arr))


