


'''simple docstring'''







import inspect
import unittest

from transformers import ViTConfig
from transformers.testing_utils import (
    require_accelerate,
    require_torch,
    require_torch_gpu,
    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, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
       import torch
       from torch import nn

       from transformers import ViTForImageClassification, ViTForMaskedImageModeling, ViTModel
       from transformers.models.vit.modeling_vit import VIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
       from PIL import Image

       from transformers import ViTImageProcessor
class 						UpperCamelCase__       :



     """simple docstring"""






     def __init__(			self   ,						snake_case__   ,						snake_case__=13   ,						snake_case__=30   ,						snake_case__=2   ,						snake_case__=3   ,						snake_case__=True   ,						snake_case__=True   ,						snake_case__=32   ,						snake_case__=5   ,						snake_case__=4   ,						snake_case__=37   ,						snake_case__="gelu"   ,						snake_case__=0.1   ,						snake_case__=0.1   ,						snake_case__=10   ,						snake_case__=0.02   ,						snake_case__=None   ,						snake_case__=2   ,						):

            '''simple docstring'''

            _lowerCAmelCase     :				str       =							parent
            _lowerCAmelCase     :				List[str]       =							batch_size
            _lowerCAmelCase     :				int       =							image_size
            _lowerCAmelCase     :				Dict       =							patch_size
            _lowerCAmelCase     :				Any       =							num_channels
            _lowerCAmelCase     :				List[str]       =							is_training
            _lowerCAmelCase     :				Any       =							use_labels
            _lowerCAmelCase     :				int       =							hidden_size
            _lowerCAmelCase     :				Any       =							num_hidden_layers
            _lowerCAmelCase     :				Tuple       =							num_attention_heads
            _lowerCAmelCase     :				Optional[Any]       =							intermediate_size
            _lowerCAmelCase     :				List[Any]       =							hidden_act
            _lowerCAmelCase     :				str       =							hidden_dropout_prob
            _lowerCAmelCase     :				Union[str, Any]       =							attention_probs_dropout_prob
            _lowerCAmelCase     :				Optional[Any]       =							type_sequence_label_size
            _lowerCAmelCase     :				List[str]       =							initializer_range
            _lowerCAmelCase     :				int       =							scope
            _lowerCAmelCase     :				List[Any]       =							encoder_stride

            # in ViT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
            _lowerCAmelCase     :				int       =							(image_size // patch_size) ** 2
            _lowerCAmelCase     :				str       =							num_patches + 1







     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				Optional[int]       =							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

            _lowerCAmelCase     :				List[str]       =							None
            if self.use_labels:
                   _lowerCAmelCase     :				int       =							ids_tensor([self.batch_size]   ,						self.type_sequence_label_size )

            _lowerCAmelCase     :				Tuple       =							self.get_config()

            return config, pixel_values, labels







     def a						(			self ):

            '''simple docstring'''

            return ViTConfig(
                image_size=self.image_size   ,						patch_size=self.patch_size   ,						num_channels=self.num_channels   ,						hidden_size=self.hidden_size   ,						num_hidden_layers=self.num_hidden_layers   ,						num_attention_heads=self.num_attention_heads   ,						intermediate_size=self.intermediate_size   ,						hidden_act=self.hidden_act   ,						hidden_dropout_prob=self.hidden_dropout_prob   ,						attention_probs_dropout_prob=self.attention_probs_dropout_prob   ,						is_decoder=snake_case__   ,						initializer_range=self.initializer_range   ,						encoder_stride=self.encoder_stride   ,						)







     def a						(			self   ,						snake_case__   ,						snake_case__   ,						snake_case__ ):

            '''simple docstring'''

            _lowerCAmelCase     :				int       =							ViTModel(config=snake_case__ )
            model.to(snake_case__ )
            model.eval()
            _lowerCAmelCase     :				Union[str, Any]       =							model(snake_case__ )
            self.parent.assertEqual(result.last_hidden_state.shape   ,						(self.batch_size, self.seq_length, self.hidden_size) )







     def a						(			self   ,						snake_case__   ,						snake_case__   ,						snake_case__ ):

            '''simple docstring'''

            _lowerCAmelCase     :				Dict       =							ViTForMaskedImageModeling(config=snake_case__ )
            model.to(snake_case__ )
            model.eval()
            _lowerCAmelCase     :				Tuple       =							model(snake_case__ )
            self.parent.assertEqual(
                result.reconstruction.shape   ,						(self.batch_size, self.num_channels, self.image_size, self.image_size) )

            # test greyscale images
            _lowerCAmelCase     :				Optional[int]       =							1
            _lowerCAmelCase     :				Optional[int]       =							ViTForMaskedImageModeling(snake_case__ )
            model.to(snake_case__ )
            model.eval()

            _lowerCAmelCase     :				Dict       =							floats_tensor([self.batch_size, 1, self.image_size, self.image_size] )
            _lowerCAmelCase     :				Dict       =							model(snake_case__ )
            self.parent.assertEqual(result.reconstruction.shape   ,						(self.batch_size, 1, self.image_size, self.image_size) )







     def a						(			self   ,						snake_case__   ,						snake_case__   ,						snake_case__ ):

            '''simple docstring'''

            _lowerCAmelCase     :				Optional[int]       =							self.type_sequence_label_size
            _lowerCAmelCase     :				Tuple       =							ViTForImageClassification(snake_case__ )
            model.to(snake_case__ )
            model.eval()
            _lowerCAmelCase     :				Tuple       =							model(snake_case__   ,						labels=snake_case__ )
            self.parent.assertEqual(result.logits.shape   ,						(self.batch_size, self.type_sequence_label_size) )

            # test greyscale images
            _lowerCAmelCase     :				List[str]       =							1
            _lowerCAmelCase     :				Any       =							ViTForImageClassification(snake_case__ )
            model.to(snake_case__ )
            model.eval()

            _lowerCAmelCase     :				Dict       =							floats_tensor([self.batch_size, 1, self.image_size, self.image_size] )
            _lowerCAmelCase     :				Dict       =							model(snake_case__ )
            self.parent.assertEqual(result.logits.shape   ,						(self.batch_size, self.type_sequence_label_size) )







     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				int       =							self.prepare_config_and_inputs()
            (
                (
                _lowerCAmelCase
            )      ,  (
                _lowerCAmelCase
            )      ,  (
                _lowerCAmelCase
            )      ,  
            )     :				List[str]       =							config_and_inputs
            _lowerCAmelCase     :				List[str]       =							{'pixel_values': pixel_values}
            return config, inputs_dict
@require_torch
class 						UpperCamelCase__       (			SCREAMING_SNAKE_CASE_     ,       SCREAMING_SNAKE_CASE_     ,       unittest.TestCase						):



     """simple docstring"""






     __magic_name__           =     (
         (
             ViTModel,
             ViTForImageClassification,
             ViTForMaskedImageModeling,
         )
         if is_torch_available()
         else ()
     )
     __magic_name__           =     (
         {"feature-extraction": ViTModel, "image-classification": ViTForImageClassification}
         if is_torch_available()
         else {}
     )
     __magic_name__           =     True

     __magic_name__           =     False
     __magic_name__           =     False
     __magic_name__           =     False







     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				List[Any]       =							ViTModelTester(self )
            _lowerCAmelCase     :				str       =							ConfigTester(self   ,						config_class=snake_case__   ,						has_text_modality=snake_case__   ,						hidden_size=37 )







     def a						(			self ):

            '''simple docstring'''

            self.config_tester.run_common_tests()







     @unittest.skip(reason='ViT does not use inputs_embeds' )
     def a						(			self ):

            '''simple docstring'''

            pass







     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase      ,  _lowerCAmelCase     :				List[str]       =							self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                   _lowerCAmelCase     :				Any       =							model_class(snake_case__ )
                   self.assertIsInstance(model.get_input_embeddings()   ,						(nn.Module) )
                   _lowerCAmelCase     :				Any       =							model.get_output_embeddings()
                   self.assertTrue(x is None or isinstance(snake_case__   ,						nn.Linear ) )







     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase      ,  _lowerCAmelCase     :				Tuple       =							self.model_tester.prepare_config_and_inputs_for_common()

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

                   _lowerCAmelCase     :				str       =							['pixel_values']
                   self.assertListEqual(arg_names[:1]   ,						snake_case__ )







     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				Union[str, Any]       =							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*snake_case__ )







     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				Any       =							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_masked_image_modeling(*snake_case__ )







     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				int       =							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_image_classification(*snake_case__ )







     @slow
     def a						(			self ):

            '''simple docstring'''

            for model_name in VIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                   _lowerCAmelCase     :				Optional[int]       =							ViTModel.from_pretrained(snake_case__ )
                   self.assertIsNotNone(snake_case__ )






def       lowercase					():







       """simple docstring"""







       _lowerCAmelCase     :				Union[str, Any]       =							Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'       )
       return image
@require_torch
@require_vision
class 						UpperCamelCase__       (			unittest.TestCase						):



     """simple docstring"""






     @cached_property
     def a						(			self ):

            '''simple docstring'''

            return ViTImageProcessor.from_pretrained('google/vit-base-patch16-224' ) if is_vision_available() else None







     @slow
     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				str       =							ViTForImageClassification.from_pretrained('google/vit-base-patch16-224' ).to(snake_case__ )

            _lowerCAmelCase     :				Dict       =							self.default_image_processor
            _lowerCAmelCase     :				Optional[int]       =							prepare_img()
            _lowerCAmelCase     :				List[str]       =							image_processor(images=snake_case__   ,						return_tensors='pt' ).to(snake_case__ )

            # forward pass
            with torch.no_grad():
                   _lowerCAmelCase     :				List[str]       =							model(**snake_case__ )

            # verify the logits
            _lowerCAmelCase     :				str       =							torch.Size((1, 1000) )
            self.assertEqual(outputs.logits.shape   ,						snake_case__ )

            _lowerCAmelCase     :				List[Any]       =							torch.tensor([-0.2744, 0.8215, -0.0836] ).to(snake_case__ )

            self.assertTrue(torch.allclose(outputs.logits[0, :3]   ,						snake_case__   ,						atol=1E-4 ) )







     @slow
     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				List[Any]       =							ViTModel.from_pretrained('facebook/dino-vits8' ).to(snake_case__ )

            _lowerCAmelCase     :				Any       =							ViTImageProcessor.from_pretrained('facebook/dino-vits8'   ,						size=480 )
            _lowerCAmelCase     :				Tuple       =							prepare_img()
            _lowerCAmelCase     :				Union[str, Any]       =							image_processor(images=snake_case__   ,						return_tensors='pt' )
            _lowerCAmelCase     :				str       =							inputs.pixel_values.to(snake_case__ )

            # forward pass
            with torch.no_grad():
                   _lowerCAmelCase     :				Optional[int]       =							model(snake_case__   ,						interpolate_pos_encoding=snake_case__ )

            # verify the logits
            _lowerCAmelCase     :				Union[str, Any]       =							torch.Size((1, 3601, 384) )
            self.assertEqual(outputs.last_hidden_state.shape   ,						snake_case__ )

            _lowerCAmelCase     :				Tuple       =							torch.tensor(
                [[4.2340, 4.3906, -6.6692], [4.5463, 1.8928, -6.7257], [4.4429, 0.8496, -5.8585]] ).to(snake_case__ )

            self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :3, :3]   ,						snake_case__   ,						atol=1E-4 ) )







     @slow
     @require_accelerate
     @require_torch_gpu
     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				int       =							ViTModel.from_pretrained('facebook/dino-vits8'   ,						torch_dtype=torch.floataa   ,						device_map='auto' )
            _lowerCAmelCase     :				Optional[Any]       =							self.default_image_processor

            _lowerCAmelCase     :				Union[str, Any]       =							prepare_img()
            _lowerCAmelCase     :				int       =							image_processor(images=snake_case__   ,						return_tensors='pt' )
            _lowerCAmelCase     :				str       =							inputs.pixel_values.to(snake_case__ )

            # forward pass to make sure inference works in fp16
            with torch.no_grad():
                   _lowerCAmelCase     :				Optional[Any]       =							model(snake_case__ )





'''simple docstring'''







def       lowercase					(_A       ):







       """simple docstring"""







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

       _lowerCAmelCase     :				List[str]       =							[]

       def generate(_A ,    _A       ):
              _lowerCAmelCase     :				Any       =							[0] * n
              res.append(tuple(_A       )       )

              _lowerCAmelCase     :				Any       =							0
              while i < n:
                     if c[i] < i:
                            if i % 2 == 0:
                                   _lowerCAmelCase      ,  _lowerCAmelCase     :				Tuple       =							arr[i], arr[0]
                            else:
                                   _lowerCAmelCase      ,  _lowerCAmelCase     :				List[str]       =							arr[i], arr[c[i]]
                            res.append(tuple(_A       )       )
                            c[i] += 1
                            _lowerCAmelCase     :				Optional[int]       =							0
                     else:
                            _lowerCAmelCase     :				Any       =							0
                            i += 1

       generate(len(_A       ) ,    _A       )
       return res


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

