



import collections
import inspect
import unittest

from transformers import SwinvaConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch
			from torch import nn

			from transformers import SwinvaForImageClassification, SwinvaForMaskedImageModeling, SwinvaModel
			from transformers.models.swinva.modeling_swinva import SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
			from PIL import Image

			from transformers import AutoImageProcessor


class 						lowercase    :
						'''simple docstring'''


						def __init__(  self    :				int       ,	snake_case    :				Union[str, Any]       ,	snake_case    :				List[Any]=13       ,	snake_case    :				str=32       ,	snake_case    :				Tuple=2       ,	snake_case    :				Tuple=3       ,	snake_case    :				Any=16       ,	snake_case    :				Optional[int]=[1, 2, 1]       ,	snake_case    :				Union[str, Any]=[2, 2, 4]       ,	snake_case    :				Optional[Any]=2       ,	snake_case    :				Optional[int]=2.0       ,	snake_case    :				Any=True       ,	snake_case    :				int=0.0       ,	snake_case    :				List[str]=0.0       ,	snake_case    :				List[str]=0.1       ,	snake_case    :				Optional[Any]="gelu"       ,	snake_case    :				Dict=False       ,	snake_case    :				Optional[int]=True       ,	snake_case    :				Optional[int]=0.02       ,	snake_case    :				int=1E-5       ,	snake_case    :				List[Any]=True       ,	snake_case    :				int=None       ,	snake_case    :				List[str]=True       ,	snake_case    :				int=10       ,	snake_case    :				Optional[Any]=8       ,	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     List[Any]						=				parent
											SCREAMING_SNAKE_CASE							:     int						=				batch_size
											SCREAMING_SNAKE_CASE							:     Optional[int]						=				image_size
											SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				patch_size
											SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				num_channels
											SCREAMING_SNAKE_CASE							:     str						=				embed_dim
											SCREAMING_SNAKE_CASE							:     Dict						=				depths
											SCREAMING_SNAKE_CASE							:     List[str]						=				num_heads
											SCREAMING_SNAKE_CASE							:     List[str]						=				window_size
											SCREAMING_SNAKE_CASE							:     Any						=				mlp_ratio
											SCREAMING_SNAKE_CASE							:     Optional[Any]						=				qkv_bias
											SCREAMING_SNAKE_CASE							:     Any						=				hidden_dropout_prob
											SCREAMING_SNAKE_CASE							:     Tuple						=				attention_probs_dropout_prob
											SCREAMING_SNAKE_CASE							:     List[str]						=				drop_path_rate
											SCREAMING_SNAKE_CASE							:     int						=				hidden_act
											SCREAMING_SNAKE_CASE							:     List[str]						=				use_absolute_embeddings
											SCREAMING_SNAKE_CASE							:     Optional[Any]						=				patch_norm
											SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				layer_norm_eps
											SCREAMING_SNAKE_CASE							:     Tuple						=				initializer_range
											SCREAMING_SNAKE_CASE							:     Optional[Any]						=				is_training
											SCREAMING_SNAKE_CASE							:     int						=				scope
											SCREAMING_SNAKE_CASE							:     int						=				use_labels
											SCREAMING_SNAKE_CASE							:     List[str]						=				type_sequence_label_size
											SCREAMING_SNAKE_CASE							:     Optional[int]						=				encoder_stride







						def       lowerCamelCase_				(  self    :				Union[str, Any]	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     List[str]						=				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

											SCREAMING_SNAKE_CASE							:     Dict						=				None
											if self.use_labels:
																SCREAMING_SNAKE_CASE							:     str						=				ids_tensor([self.batch_size]       ,	self.type_sequence_label_size	)

											SCREAMING_SNAKE_CASE							:     int						=				self.get_config()

											return config, pixel_values, labels







						def       lowerCamelCase_				(  self    :				Optional[Any]	):



											'''simple docstring'''


											return SwinvaConfig(
											    image_size=self.image_size       ,	patch_size=self.patch_size       ,	num_channels=self.num_channels       ,	embed_dim=self.embed_dim       ,	depths=self.depths       ,	num_heads=self.num_heads       ,	window_size=self.window_size       ,	mlp_ratio=self.mlp_ratio       ,	qkv_bias=self.qkv_bias       ,	hidden_dropout_prob=self.hidden_dropout_prob       ,	attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,	drop_path_rate=self.drop_path_rate       ,	hidden_act=self.hidden_act       ,	use_absolute_embeddings=self.use_absolute_embeddings       ,	path_norm=self.patch_norm       ,	layer_norm_eps=self.layer_norm_eps       ,	initializer_range=self.initializer_range       ,	encoder_stride=self.encoder_stride       ,	)







						def       lowerCamelCase_				(  self    :				Any       ,	snake_case    :				Dict       ,	snake_case    :				Union[str, Any]       ,	snake_case    :				List[Any]	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     Optional[Any]						=				SwinvaModel(config=snake_case	)
											model.to(snake_case	)
											model.eval()
											SCREAMING_SNAKE_CASE							:     List[Any]						=				model(snake_case	)

											SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths	) - 1))
											SCREAMING_SNAKE_CASE							:     int						=				int(config.embed_dim * 2 ** (len(config.depths	) - 1)	)

											self.parent.assertEqual(result.last_hidden_state.shape       ,	(self.batch_size, expected_seq_len, expected_dim)	)







						def       lowerCamelCase_				(  self    :				List[str]       ,	snake_case    :				Tuple       ,	snake_case    :				int       ,	snake_case    :				Optional[int]	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     Dict						=				SwinvaForMaskedImageModeling(config=snake_case	)
											model.to(snake_case	)
											model.eval()
											SCREAMING_SNAKE_CASE							:     str						=				model(snake_case	)
											self.parent.assertEqual(
											    result.logits.shape       ,	(self.batch_size, self.num_channels, self.image_size, self.image_size)	)

											# test greyscale images
											SCREAMING_SNAKE_CASE							:     List[Any]						=				1
											SCREAMING_SNAKE_CASE							:     Tuple						=				SwinvaForMaskedImageModeling(snake_case	)
											model.to(snake_case	)
											model.eval()

											SCREAMING_SNAKE_CASE							:     Optional[Any]						=				floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
											SCREAMING_SNAKE_CASE							:     List[str]						=				model(snake_case	)
											self.parent.assertEqual(result.logits.shape       ,	(self.batch_size, 1, self.image_size, self.image_size)	)







						def       lowerCamelCase_				(  self    :				int       ,	snake_case    :				Any       ,	snake_case    :				Dict       ,	snake_case    :				int	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     Optional[int]						=				self.type_sequence_label_size
											SCREAMING_SNAKE_CASE							:     int						=				SwinvaForImageClassification(snake_case	)
											model.to(snake_case	)
											model.eval()
											SCREAMING_SNAKE_CASE							:     Dict						=				model(snake_case       ,	labels=snake_case	)
											self.parent.assertEqual(result.logits.shape       ,	(self.batch_size, self.type_sequence_label_size)	)







						def       lowerCamelCase_				(  self    :				List[Any]	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     int						=				self.prepare_config_and_inputs()
											SCREAMING_SNAKE_CASE					,  SCREAMING_SNAKE_CASE					,  SCREAMING_SNAKE_CASE							:     Tuple						=				config_and_inputs
											SCREAMING_SNAKE_CASE							:     Any						=				{'pixel_values': pixel_values}
											return config, inputs_dict


@require_torch
class 						lowercase    (							SCREAMING_SNAKE_CASE_      ,    SCREAMING_SNAKE_CASE_      ,    unittest.TestCase):
						'''simple docstring'''


						UpperCAmelCase			:		List[Any]		=		(
						    (SwinvaModel, SwinvaForImageClassification, SwinvaForMaskedImageModeling) if is_torch_available() else ()
						)
						UpperCAmelCase			:		str		=		(
						    {'feature-extraction': SwinvaModel, 'image-classification': SwinvaForImageClassification}
						    if is_torch_available()
						    else {}
						)

						UpperCAmelCase			:		Dict		=		False
						UpperCAmelCase			:		str		=		False
						UpperCAmelCase			:		int		=		False
						UpperCAmelCase			:		str		=		False







						def       lowerCamelCase_				(  self    :				Optional[int]	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     List[str]						=				SwinvaModelTester(self	)
											SCREAMING_SNAKE_CASE							:     int						=				ConfigTester(self       ,	config_class=snake_case       ,	embed_dim=37	)







						def       lowerCamelCase_				(  self    :				List[str]	):



											'''simple docstring'''


											self.config_tester.create_and_test_config_to_json_string()
											self.config_tester.create_and_test_config_to_json_file()
											self.config_tester.create_and_test_config_from_and_save_pretrained()
											self.config_tester.create_and_test_config_with_num_labels()
											self.config_tester.check_config_can_be_init_without_params()
											self.config_tester.check_config_arguments_init()







						def       lowerCamelCase_				(  self    :				Union[str, Any]	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     str						=				self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*snake_case	)







						@unittest.skip(reason='Got `CUDA error: misaligned address` with PyTorch 2.0.0.'	)
						def       lowerCamelCase_				(  self    :				Union[str, Any]	):



											'''simple docstring'''


											pass







						@unittest.skip(reason='Swinv2 does not use inputs_embeds'	)
						def       lowerCamelCase_				(  self    :				str	):



											'''simple docstring'''


											pass







						def       lowerCamelCase_				(  self    :				List[Any]	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE					,  SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				model_class(snake_case	)
																self.assertIsInstance(model.get_input_embeddings()       ,	(nn.Module)	)
																SCREAMING_SNAKE_CASE							:     int						=				model.get_output_embeddings()
																self.assertTrue(x is None or isinstance(snake_case       ,	nn.Linear	)	)







						def       lowerCamelCase_				(  self    :				List[Any]	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE					,  SCREAMING_SNAKE_CASE							:     Any						=				self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																SCREAMING_SNAKE_CASE							:     List[Any]						=				model_class(snake_case	)
																SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				inspect.signature(model.forward	)
																# signature.parameters is an OrderedDict => so arg_names order is deterministic
																SCREAMING_SNAKE_CASE							:     List[Any]						=				[*signature.parameters.keys()]

																SCREAMING_SNAKE_CASE							:     Optional[int]						=				['pixel_values']
																self.assertListEqual(arg_names[:1]       ,	snake_case	)







						def       lowerCamelCase_				(  self    :				Tuple	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE					,  SCREAMING_SNAKE_CASE							:     Any						=				self.model_tester.prepare_config_and_inputs_for_common()
											SCREAMING_SNAKE_CASE							:     List[str]						=				True

											for model_class in self.all_model_classes:
																SCREAMING_SNAKE_CASE							:     Optional[int]						=				True
																SCREAMING_SNAKE_CASE							:     Any						=				False
																SCREAMING_SNAKE_CASE							:     Optional[int]						=				True
																SCREAMING_SNAKE_CASE							:     str						=				model_class(snake_case	)
																model.to(snake_case	)
																model.eval()
																with torch.no_grad():
																					SCREAMING_SNAKE_CASE							:     Dict						=				model(**self._prepare_for_class(snake_case       ,	snake_case	)	)
																SCREAMING_SNAKE_CASE							:     Any						=				outputs.attentions
																SCREAMING_SNAKE_CASE							:     Any						=				len(self.model_tester.depths	)
																self.assertEqual(len(snake_case	)       ,	snake_case	)

																# check that output_attentions also work using config
																del inputs_dict["output_attentions"]
																SCREAMING_SNAKE_CASE							:     int						=				True
																SCREAMING_SNAKE_CASE							:     Tuple						=				config.window_size**2
																SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				model_class(snake_case	)
																model.to(snake_case	)
																model.eval()
																with torch.no_grad():
																					SCREAMING_SNAKE_CASE							:     int						=				model(**self._prepare_for_class(snake_case       ,	snake_case	)	)
																SCREAMING_SNAKE_CASE							:     Optional[Any]						=				outputs.attentions
																self.assertEqual(len(snake_case	)       ,	snake_case	)

																self.assertListEqual(
																    list(attentions[0].shape[-3:]	)       ,	[self.model_tester.num_heads[0], window_size_squared, window_size_squared]       ,	)
																SCREAMING_SNAKE_CASE							:     Dict						=				len(snake_case	)

																# Check attention is always last and order is fine
																SCREAMING_SNAKE_CASE							:     int						=				True
																SCREAMING_SNAKE_CASE							:     Optional[Any]						=				True
																SCREAMING_SNAKE_CASE							:     int						=				model_class(snake_case	)
																model.to(snake_case	)
																model.eval()
																with torch.no_grad():
																					SCREAMING_SNAKE_CASE							:     Optional[Any]						=				model(**self._prepare_for_class(snake_case       ,	snake_case	)	)

																if hasattr(self.model_tester       ,	'num_hidden_states_types'	):
																					SCREAMING_SNAKE_CASE							:     int						=				self.model_tester.num_hidden_states_types
																else:
																					# also another +1 for reshaped_hidden_states
																					SCREAMING_SNAKE_CASE							:     Optional[Any]						=				2
																self.assertEqual(out_len + added_hidden_states       ,	len(snake_case	)	)

																SCREAMING_SNAKE_CASE							:     List[Any]						=				outputs.attentions

																self.assertEqual(len(snake_case	)       ,	snake_case	)

																self.assertListEqual(
																    list(self_attentions[0].shape[-3:]	)       ,	[self.model_tester.num_heads[0], window_size_squared, window_size_squared]       ,	)







						def       lowerCamelCase_				(  self    :				int       ,	snake_case    :				List[str]       ,	snake_case    :				List[Any]       ,	snake_case    :				Union[str, Any]       ,	snake_case    :				List[str]	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     Optional[Any]						=				model_class(snake_case	)
											model.to(snake_case	)
											model.eval()

											with torch.no_grad():
																SCREAMING_SNAKE_CASE							:     Dict						=				model(**self._prepare_for_class(snake_case       ,	snake_case	)	)

											SCREAMING_SNAKE_CASE							:     Optional[int]						=				outputs.hidden_states

											SCREAMING_SNAKE_CASE							:     Tuple						=				getattr(
											    self.model_tester       ,	'expected_num_hidden_layers'       ,	len(self.model_tester.depths	) + 1	)
											self.assertEqual(len(snake_case	)       ,	snake_case	)

											# Swinv2 has a different seq_length
											SCREAMING_SNAKE_CASE							:     List[Any]						=				(
											    config.patch_size
											    if isinstance(config.patch_size       ,	collections.abc.Iterable	)
											    else (config.patch_size, config.patch_size)
											)

											SCREAMING_SNAKE_CASE							:     int						=				(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

											self.assertListEqual(
											    list(hidden_states[0].shape[-2:]	)       ,	[num_patches, self.model_tester.embed_dim]       ,	)

											SCREAMING_SNAKE_CASE							:     int						=				outputs.reshaped_hidden_states
											self.assertEqual(len(snake_case	)       ,	snake_case	)

											SCREAMING_SNAKE_CASE					,  SCREAMING_SNAKE_CASE					,  SCREAMING_SNAKE_CASE					,  SCREAMING_SNAKE_CASE							:     Any						=				reshaped_hidden_states[0].shape
											SCREAMING_SNAKE_CASE							:     int						=				(
											    reshaped_hidden_states[0].view(snake_case       ,	snake_case       ,	height * width	).permute(0       ,	2       ,	1	)
											)
											self.assertListEqual(
											    list(reshaped_hidden_states.shape[-2:]	)       ,	[num_patches, self.model_tester.embed_dim]       ,	)







						def       lowerCamelCase_				(  self    :				str	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE					,  SCREAMING_SNAKE_CASE							:     Optional[int]						=				self.model_tester.prepare_config_and_inputs_for_common()

											SCREAMING_SNAKE_CASE							:     List[Any]						=				(
											    self.model_tester.image_size
											    if isinstance(self.model_tester.image_size       ,	collections.abc.Iterable	)
											    else (self.model_tester.image_size, self.model_tester.image_size)
											)

											for model_class in self.all_model_classes:
																SCREAMING_SNAKE_CASE							:     Any						=				True
																self.check_hidden_states_output(snake_case       ,	snake_case       ,	snake_case       ,	snake_case	)

																# check that output_hidden_states also work using config
																del inputs_dict["output_hidden_states"]
																SCREAMING_SNAKE_CASE							:     List[str]						=				True

																self.check_hidden_states_output(snake_case       ,	snake_case       ,	snake_case       ,	snake_case	)







						def       lowerCamelCase_				(  self    :				Optional[Any]	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE					,  SCREAMING_SNAKE_CASE							:     Optional[Any]						=				self.model_tester.prepare_config_and_inputs_for_common()
											SCREAMING_SNAKE_CASE							:     List[Any]						=				3

											SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				(
											    self.model_tester.image_size
											    if isinstance(self.model_tester.image_size       ,	collections.abc.Iterable	)
											    else (self.model_tester.image_size, self.model_tester.image_size)
											)
											SCREAMING_SNAKE_CASE							:     List[Any]						=				(
											    config.patch_size
											    if isinstance(config.patch_size       ,	collections.abc.Iterable	)
											    else (config.patch_size, config.patch_size)
											)

											SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
											SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

											for model_class in self.all_model_classes:
																SCREAMING_SNAKE_CASE							:     Any						=				True
																self.check_hidden_states_output(snake_case       ,	snake_case       ,	snake_case       ,	(padded_height, padded_width)	)

																# check that output_hidden_states also work using config
																del inputs_dict["output_hidden_states"]
																SCREAMING_SNAKE_CASE							:     List[str]						=				True
																self.check_hidden_states_output(snake_case       ,	snake_case       ,	snake_case       ,	(padded_height, padded_width)	)







						def       lowerCamelCase_				(  self    :				str	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     int						=				self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_masked_image_modeling(*snake_case	)







						def       lowerCamelCase_				(  self    :				Optional[Any]	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*snake_case	)







						@slow
						def       lowerCamelCase_				(  self    :				Any	):



											'''simple docstring'''


											for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																SCREAMING_SNAKE_CASE							:     Optional[Any]						=				SwinvaModel.from_pretrained(snake_case	)
																self.assertIsNotNone(snake_case	)







						def       lowerCamelCase_				(  self    :				Dict	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE					,  SCREAMING_SNAKE_CASE							:     Optional[int]						=				self.model_tester.prepare_config_and_inputs_for_common()

											SCREAMING_SNAKE_CASE							:     Optional[int]						=				_config_zero_init(snake_case	)
											for model_class in self.all_model_classes:
																SCREAMING_SNAKE_CASE							:     Any						=				model_class(config=snake_case	)
																for name, param in model.named_parameters():
																					if "embeddings" not in name and "logit_scale" not in name and param.requires_grad:
																										self.assertIn(
																										    ((param.data.mean() * 1E9).round() / 1E9).item()       ,	[0.0, 1.0]       ,	msg=f'''Parameter {name} of model {model_class} seems not properly initialized'''       ,	)


@require_vision
@require_torch
class 						lowercase    (							unittest.TestCase):
						'''simple docstring'''


						@cached_property
						def       lowerCamelCase_				(  self    :				Any	):



											'''simple docstring'''


											return (
											    AutoImageProcessor.from_pretrained('microsoft/swinv2-tiny-patch4-window8-256'	)
											    if is_vision_available()
											    else None
											)







						@slow
						def       lowerCamelCase_				(  self    :				int	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     Tuple						=				SwinvaForImageClassification.from_pretrained('microsoft/swinv2-tiny-patch4-window8-256'	).to(
											    snake_case	)
											SCREAMING_SNAKE_CASE							:     List[str]						=				self.default_image_processor

											SCREAMING_SNAKE_CASE							:     Optional[Any]						=				Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'	)
											SCREAMING_SNAKE_CASE							:     List[str]						=				image_processor(images=snake_case       ,	return_tensors='pt'	).to(snake_case	)

											# forward pass
											with torch.no_grad():
																SCREAMING_SNAKE_CASE							:     Dict						=				model(**snake_case	)

											# verify the logits
											SCREAMING_SNAKE_CASE							:     Tuple						=				torch.Size((1, 1000)	)
											self.assertEqual(outputs.logits.shape       ,	snake_case	)
											SCREAMING_SNAKE_CASE							:     Optional[int]						=				torch.tensor([-0.3947, -0.4306, 0.0026]	).to(snake_case	)
											self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,	snake_case       ,	atol=1E-4	)	)




def        __a			(   __lowerCAmelCase   )     ->     List[str]:
					stooge(__lowerCAmelCase      ,	0      ,	len(__lowerCAmelCase   ) - 1   )
					return arr

def        __a			(   __lowerCAmelCase      ,	__lowerCAmelCase      ,	__lowerCAmelCase   )     ->     int:
					if i >= h:
										return

					# If first element is smaller than the last then swap them
					if arr[i] > arr[h]:
										SCREAMING_SNAKE_CASE					,  SCREAMING_SNAKE_CASE							:     Any						=				arr[h], arr[i]

					# If there are more than 2 elements in the array
					if h - i + 1 > 2:
										SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				(int)((h - i + 1) / 3   )

										# Recursively sort first 2/3 elements
										stooge(__lowerCAmelCase      ,	__lowerCAmelCase      ,	(h - t)   )

										# Recursively sort last 2/3 elements
										stooge(__lowerCAmelCase      ,	i + t      ,	(__lowerCAmelCase)   )

										# Recursively sort first 2/3 elements
										stooge(__lowerCAmelCase      ,	__lowerCAmelCase      ,	(h - t)   )


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