
def 						lowerCamelCase__							(      a	,	a   )   ->     int:
   _A:						Tuple	    = 1.0
   for i in range(1	,	r + 1   ):
      ret *= (n + 1 - i) / i
   return round(a   )






def 						lowerCamelCase__							(      a   )   ->     int:
   return choose(8 + n	,	a   ) + choose(9 + n	,	a   ) - 10






def 						lowerCamelCase__							(      a   )   ->     int:
   return sum(non_bouncy_exact(a   ) for i in range(1	,	n + 1   )   )






def 						lowerCamelCase__							(      a = 1_00   )   ->     int:
   return non_bouncy_upto(a   )


if __name__ == "__main__":
   print(F"""{solution() = }""")





from __future__ import annotations






def 						lowerCamelCase__							(      a	,	a   )   ->     Union[str, Any]:
   _A:						Any	    = 0
   _A:						str	    = len(a   ) - 1
   while left <= right:
      _A:						Any	    = (left + right) // 2
      if left == right:
         if sorted_list[middle] < item:
            _A:						Union[str, Any]	    = middle + 1
         break
      elif sorted_list[middle] < item:
         _A:						Optional[Any]	    = middle + 1
      else:
         _A:						str	    = middle - 1
   sorted_list.insert(a	,	a   )
   return sorted_list






def 						lowerCamelCase__							(      a	,	a   )   ->     int:
   _A:						List[Any]	    = []
   while left and right:
      if left[0][0] < right[0][0]:
         result.append(left.pop(0   )   )
      else:
         result.append(right.pop(0   )   )
   return result + left + right






def 						lowerCamelCase__							(      a   )   ->     List[Any]:
   _A:						Dict	    = len(a   )
   if length <= 1:
      return list_ad
   _A:						str	    = length // 2
   return merge(sortlist_ad(list_ad[:middle]   )	,	sortlist_ad(list_ad[middle:]   )   )






def 						lowerCamelCase__							(      a   )   ->     list[int]:

   if len(a   ) <= 1:
      return collection
   _A:						str	    = []
   _A:						Tuple	    = False
   for i in range(0	,	len(a   )	,	2   ):
      if i == len(a   ) - 1:
         _A:						Dict	    = True
      else:
         if collection[i] < collection[i + 1]:
            two_paired_list.append([collection[i], collection[i + 1]]   )
         else:
            two_paired_list.append([collection[i + 1], collection[i]]   )
   _A:						List[Any]	    = sortlist_ad(a   )
   _A:						Union[str, Any]	    = [i[0] for i in sorted_list_ad]
   result.append(sorted_list_ad[-1][1]   )
   if has_last_odd_item:
      _A:						List[Any]	    = collection[-1]
      _A:						Optional[Any]	    = binary_search_insertion(a	,	a   )
   _A:						Optional[int]	    = False
   for i in range(len(a   ) - 1   ):
      if result[i] == collection[-1] and has_last_odd_item:
         _A:						Tuple	    = True
      _A:						Optional[Any]	    = sorted_list_ad[i][1]
      # If last_odd_item is inserted before the item's index,
      # you should forward index one more.
      if is_last_odd_item_inserted_before_this_index:
         _A:						int	    = result[: i + 2] + binary_search_insertion(result[i + 2 :]	,	a   )
      else:
         _A:						Union[str, Any]	    = result[: i + 1] + binary_search_insertion(result[i + 1 :]	,	a   )

   return result


if __name__ == "__main__":
   UpperCAmelCase__	:  List[str]      =   input('Enter numbers separated by a comma:\n').strip()
   UpperCAmelCase__	:  List[Any]      =   [int(item) for item in user_input.split(',')]
   print(merge_insertion_sort(unsorted))



