import unittest
from functools import partial

import torch

from accelerate import Accelerator, debug_launcher
from accelerate.state import AcceleratorState, GradientState
from accelerate.test_utils import require_cpu, require_huggingface_suite
from accelerate.utils import GradientAccumulationPlugin






def 			__lowercase     (				a__=2							,     a__=True							,     a__=False     )       ->				int:
							__SCREAMING_SNAKE_CASE								=      Accelerator(step_scheduler_with_optimizer=a__							,     split_batches=a__     )
							__SCREAMING_SNAKE_CASE								=      torch.nn.Linear(2							,     4     )
							__SCREAMING_SNAKE_CASE								=      torch.optim.AdamW(model.parameters()							,     lr=1.0     )
							__SCREAMING_SNAKE_CASE								=      torch.optim.lr_scheduler.OneCycleLR(a__							,     max_lr=0.01							,     steps_per_epoch=2							,     epochs=1     )
							__SCREAMING_SNAKE_CASE							, __SCREAMING_SNAKE_CASE							, __SCREAMING_SNAKE_CASE								=      accelerator.prepare(a__							,     a__							,     a__     )

							# Optimizer has stepped
							scheduler.step()
							if step_scheduler_with_optimizer or (num_processes == 1):
														assert (
														    scheduler.scheduler.last_epoch == num_processes
														), f"""Last Epoch ({scheduler.scheduler.last_epoch}) != Num Processes ({num_processes})"""
							else:
														assert (
														    scheduler.scheduler.last_epoch != num_processes
														), f"""Last Epoch ({scheduler.scheduler.last_epoch}) == Num Processes ({num_processes})"""






def 			__lowercase     (				a__=2							,     a__=True							,     a__=False     )       ->				Optional[Any]:
							__SCREAMING_SNAKE_CASE								=      Accelerator(step_scheduler_with_optimizer=a__							,     split_batches=a__     )
							__SCREAMING_SNAKE_CASE								=      torch.nn.Linear(2							,     4     )
							__SCREAMING_SNAKE_CASE								=      torch.optim.AdamW(model.parameters()							,     lr=1.0     )
							__SCREAMING_SNAKE_CASE								=      torch.optim.lr_scheduler.LambdaLR(a__							,     lr_lambda=lambda a__     : 1 - n / 10     )
							__SCREAMING_SNAKE_CASE							, __SCREAMING_SNAKE_CASE							, __SCREAMING_SNAKE_CASE								=      accelerator.prepare(a__							,     a__							,     a__     )

							# Optimizer has stepped
							__SCREAMING_SNAKE_CASE								=      False
							scheduler.step()
							__SCREAMING_SNAKE_CASE								=      1 - (num_processes if (step_scheduler_with_optimizer and not split_batches) else 1) / 10
							assert (
							    scheduler.get_last_lr()[0] == expected_lr
							), f"""Wrong lr found at first step, expected {expected_lr}, got {scheduler.get_last_lr()[0]}"""

							# Optimizer has not stepped
							__SCREAMING_SNAKE_CASE								=      True
							scheduler.step()
							if not step_scheduler_with_optimizer:
														__SCREAMING_SNAKE_CASE								=      1 - 2 / 10
							assert (
							    scheduler.get_last_lr()[0] == expected_lr
							), f"""Wrong lr found at second step, expected {expected_lr}, got {scheduler.get_last_lr()[0]}"""






def 			__lowercase     (				a__ = 2     )       ->				Optional[Any]:
							from transformers import get_linear_schedule_with_warmup

							__SCREAMING_SNAKE_CASE								=      [1, 2, 4]
							for num_steps in steps:
														__SCREAMING_SNAKE_CASE								=      GradientAccumulationPlugin(num_steps=a__							,     adjust_scheduler=num_steps > 1     )
														__SCREAMING_SNAKE_CASE								=      Accelerator(gradient_accumulation_plugin=a__     )
														__SCREAMING_SNAKE_CASE								=      torch.nn.Linear(2							,     4     )
														__SCREAMING_SNAKE_CASE								=      torch.optim.AdamW(model.parameters()							,     lr=10.0     )
														__SCREAMING_SNAKE_CASE								=      get_linear_schedule_with_warmup(optimizer=a__							,     num_warmup_steps=0							,     num_training_steps=20     )

														__SCREAMING_SNAKE_CASE							, __SCREAMING_SNAKE_CASE							, __SCREAMING_SNAKE_CASE								=      accelerator.prepare(a__							,     a__							,     a__     )

														for i in range(10 * num_steps     ):
																					with accelerator.accumulate(a__     ):
																												optimizer.step()
																												scheduler.step()

																					if i == (10 * num_steps - 2):
																												assert (
																												    scheduler.get_last_lr()[0] != 0
																												), f"""Wrong lr found at second-to-last step, expected non-zero, got {scheduler.get_last_lr()[0]}. num_steps: {num_steps}"""
														assert (
														    scheduler.get_last_lr()[0] == 0
														), f"""Wrong lr found at last step, expected 0, got {scheduler.get_last_lr()[0]}"""
														GradientState._reset_state()

@require_cpu
class      UpperCAmelCase_						(     unittest.TestCase ):

						'''simple docstring'''




						def  _A			(					self	):







													'''simple docstring'''

													debug_launcher(partial(_A   ,							num_processes=1	)   ,							num_processes=1	)
													debug_launcher(partial(_A   ,							num_processes=1   ,							split_batches=_A	)   ,							num_processes=1	)






						def  _A			(					self	):







													'''simple docstring'''

													debug_launcher(partial(_A   ,							num_processes=1	)   ,							num_processes=1	)
													debug_launcher(partial(_A   ,							num_processes=1   ,							split_batches=_A	)   ,							num_processes=1	)






						def  _A			(					self	):







													'''simple docstring'''

													debug_launcher(partial(_A   ,							num_processes=1   ,							step_scheduler_with_optimizer=_A	)   ,							num_processes=1	)






						def  _A			(					self	):







													'''simple docstring'''

													debug_launcher(partial(_A   ,							num_processes=1   ,							step_scheduler_with_optimizer=_A	)   ,							num_processes=1	)






						def  _A			(					self	):







													'''simple docstring'''

													AcceleratorState._reset_state(_A	)
													debug_launcher(_A	)
													debug_launcher(partial(_A   ,							num_processes=1   ,							split_batches=_A	)   ,							num_processes=1	)






						def  _A			(					self	):







													'''simple docstring'''

													AcceleratorState._reset_state(_A	)
													debug_launcher(_A	)
													debug_launcher(partial(_A   ,							num_processes=1   ,							split_batches=_A	)   ,							num_processes=1	)






						def  _A			(					self	):







													'''simple docstring'''

													AcceleratorState._reset_state(_A	)
													debug_launcher(partial(_A   ,							step_scheduler_with_optimizer=_A	)	)






						def  _A			(					self	):







													'''simple docstring'''

													AcceleratorState._reset_state(_A	)
													debug_launcher(partial(_A   ,							step_scheduler_with_optimizer=_A	)	)






						@require_huggingface_suite
						def  _A			(					self	):







													'''simple docstring'''

													AcceleratorState._reset_state(_A	)
													debug_launcher(partial(_A   ,							num_processes=1	)	)
													debug_launcher(_A	)











def 			__lowercase     (				a__     )       ->				list:
							__SCREAMING_SNAKE_CASE								=      1.3
							__SCREAMING_SNAKE_CASE								=      len(a__     )
							__SCREAMING_SNAKE_CASE								=      False

							while not completed:
														# Update the gap value for a next comb
														__SCREAMING_SNAKE_CASE								=      int(gap / shrink_factor     )
														if gap <= 1:
																					__SCREAMING_SNAKE_CASE								=      True

														__SCREAMING_SNAKE_CASE								=      0
														while index + gap < len(a__     ):
																					if data[index] > data[index + gap]:
																												# Swap values
																												__SCREAMING_SNAKE_CASE							, __SCREAMING_SNAKE_CASE								=      data[index + gap], data[index]
																												__SCREAMING_SNAKE_CASE								=      False
																					index += 1

							return data


if __name__ == "__main__":
			import doctest

			doctest.testmod()

			lowerCAmelCase__	:  int 		=input('''Enter numbers separated by a comma:\n''').strip()
			lowerCAmelCase__	:  Dict 		=[int(item) for item in user_input.split(''',''')]
			print(comb_sort(unsorted))






