



def 				A			(		__UpperCAmelCase	)       ->       str:



						'''simple docstring'''






						UpperCAmelCase_     							=     len(__UpperCAmelCase	)
						for _ in range(
						    0							,					int(((no_of_elements - 1) / 2) + 1	)	):  # we don't need to traverse to end of list as
												for j in range(0							,					no_of_elements - 1	):
																		if (
																		    lst[j + 1] < lst[j]
																		):  # applying bubble sort algorithm from left to right (or forwards)
																								UpperCAmelCase_     							=     lst[j + 1]
																								UpperCAmelCase_     							=     lst[j]
																								UpperCAmelCase_     							=     temp
																		if (
																		    lst[no_of_elements - 1 - j] < lst[no_of_elements - 2 - j]
																		):  # applying bubble sort algorithm from right to left (or backwards)
																								UpperCAmelCase_     							=     lst[no_of_elements - 1 - j]
																								UpperCAmelCase_     							=     lst[no_of_elements - 2 - j]
																								UpperCAmelCase_     							=     temp
						return lst


if __name__ == "__main__":
							print("enter the list to be sorted")
							UpperCamelCase_	       =   [int(x) for x in input().split()]  # inputing elements of the list in one line
							UpperCamelCase_	       =   double_sort(lst)
							print("the sorted list is")
							print(sorted_lst)










from dataclasses import dataclass
from typing import Callable, Optional

import datasets







@dataclass
class 							a_  (		datasets.BuilderConfig				):
						UpperCamelCase__      :						Optional[Callable]				       =None
						UpperCamelCase__      :						Optional[dict]				       =None
						UpperCamelCase__      :						Optional[datasets.Features]				       =None

						def 	__a       (    self	:List[str])		->					List[str]:
												assert self.generator is not None, "generator must be specified"

												if self.gen_kwargs is None:
																		UpperCAmelCase_     							=     {}







class 							a_  (		datasets.GeneratorBasedBuilder				):
						UpperCamelCase__      :						List[str]				       =GeneratorConfig

						def 	__a       (    self	:List[str])		->					List[Any]:
												return datasets.DatasetInfo(features=self.config.features)

						def 	__a       (    self	:Optional[Any]   ,						_lowercase	:List[str])		->					Optional[Any]:
												return [datasets.SplitGenerator(name=datasets.Split.TRAIN   ,						gen_kwargs=self.config.gen_kwargs)]




						def 	__a       (    self	:Optional[int]   ,						**_lowercase	:str)		->					Union[str, Any]:
												for idx, ex in enumerate(self.config.generator(**_lowercase)):
																		yield idx, ex





