





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        _lowerCAmelCase    :


  '''simple docstring'''







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


    '''simple docstring'''





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







  def UpperCamelCase_ (      self      :					Optional[Any]							):


    '''simple docstring'''





    _snake_case   :				Union[str, Any]														=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

    _snake_case   :				str														=	None
    if self.use_labels:
      _snake_case   :				Union[str, Any]														=	ids_tensor([self.batch_size]      ,				self.type_sequence_label_size							)

    _snake_case   :				Tuple														=	self.get_config()

    return config, pixel_values, labels







  def UpperCamelCase_ (      self      :					List[str]							):


    '''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 UpperCamelCase_ (      self      :					Tuple      ,				UpperCamelCase      :					Dict      ,				UpperCamelCase      :					int      ,				UpperCamelCase      :					Tuple							):


    '''simple docstring'''





    _snake_case   :				List[Any]														=	SwinvaModel(config=UpperCamelCase							)
    model.to(UpperCamelCase							)
    model.eval()
    _snake_case   :				Optional[Any]														=	model(UpperCamelCase							)

    _snake_case   :				Any														=	((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths							) - 1))
    _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 UpperCamelCase_ (      self      :					Union[str, Any]      ,				UpperCamelCase      :					Optional[int]      ,				UpperCamelCase      :					int      ,				UpperCamelCase      :					Any							):


    '''simple docstring'''





    _snake_case   :				Any														=	SwinvaForMaskedImageModeling(config=UpperCamelCase							)
    model.to(UpperCamelCase							)
    model.eval()
    _snake_case   :				List[Any]														=	model(UpperCamelCase							)
    self.parent.assertEqual(
        result.logits.shape      ,				(self.batch_size, self.num_channels, self.image_size, self.image_size)							)

    # test greyscale images
    _snake_case   :				Tuple														=	1
    _snake_case   :				Optional[int]														=	SwinvaForMaskedImageModeling(UpperCamelCase							)
    model.to(UpperCamelCase							)
    model.eval()

    _snake_case   :				str														=	floats_tensor([self.batch_size, 1, self.image_size, self.image_size]							)
    _snake_case   :				str														=	model(UpperCamelCase							)
    self.parent.assertEqual(result.logits.shape      ,				(self.batch_size, 1, self.image_size, self.image_size)							)







  def UpperCamelCase_ (      self      :					Dict      ,				UpperCamelCase      :					str      ,				UpperCamelCase      :					Optional[Any]      ,				UpperCamelCase      :					Dict							):


    '''simple docstring'''





    _snake_case   :				List[str]														=	self.type_sequence_label_size
    _snake_case   :				Tuple														=	SwinvaForImageClassification(UpperCamelCase							)
    model.to(UpperCamelCase							)
    model.eval()
    _snake_case   :				Union[str, Any]														=	model(UpperCamelCase      ,				labels=UpperCamelCase							)
    self.parent.assertEqual(result.logits.shape      ,				(self.batch_size, self.type_sequence_label_size)							)







  def UpperCamelCase_ (      self      :					Optional[int]							):


    '''simple docstring'''





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




@require_torch
class        _lowerCAmelCase    (			UpperCAmelCase_							,    UpperCAmelCase_							,    unittest.TestCase							):


  '''simple docstring'''
  a_							:       str      					=(
      (SwinvaModel, SwinvaForImageClassification, SwinvaForMaskedImageModeling) if is_torch_available() else ()
  )
  a_							:       Optional[Any]      					=(
      {"""feature-extraction""": SwinvaModel, """image-classification""": SwinvaForImageClassification}
      if is_torch_available()
      else {}
  )

  a_							:       Optional[Any]      					=False
  a_							:       int      					=False
  a_							:       Optional[int]      					=False
  a_							:       int      					=False







  def UpperCamelCase_ (      self      :					str							):


    '''simple docstring'''





    _snake_case   :				Optional[Any]														=	SwinvaModelTester(self							)
    _snake_case   :				List[Any]														=	ConfigTester(self      ,				config_class=UpperCamelCase      ,				embed_dim=37							)







  def UpperCamelCase_ (      self      :					Tuple							):


    '''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 UpperCamelCase_ (      self      :					int							):


    '''simple docstring'''





    _snake_case   :				int														=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*UpperCamelCase							)







  @unittest.skip(reason='Got `CUDA error: misaligned address` with PyTorch 2.0.0.'							)
  def UpperCamelCase_ (      self      :					Tuple							):


    '''simple docstring'''





    pass







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


    '''simple docstring'''





    pass







  def UpperCamelCase_ (      self      :					Tuple							):


    '''simple docstring'''





    _snake_case							,					_snake_case   :				int														=	self.model_tester.prepare_config_and_inputs_for_common()

    for model_class in self.all_model_classes:
      _snake_case   :				int														=	model_class(UpperCamelCase							)
      self.assertIsInstance(model.get_input_embeddings()      ,				(nn.Module)							)
      _snake_case   :				Dict														=	model.get_output_embeddings()
      self.assertTrue(x is None or isinstance(UpperCamelCase      ,				nn.Linear							)							)







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


    '''simple docstring'''





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

    for model_class in self.all_model_classes:
      _snake_case   :				Dict														=	model_class(UpperCamelCase							)
      _snake_case   :				Dict														=	inspect.signature(model.forward							)
      # signature.parameters is an OrderedDict => so arg_names order is deterministic
      _snake_case   :				str														=	[*signature.parameters.keys()]

      _snake_case   :				List[str]														=	['pixel_values']
      self.assertListEqual(arg_names[:1]      ,				UpperCamelCase							)







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


    '''simple docstring'''





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

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

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

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

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

      if hasattr(self.model_tester      ,				'num_hidden_states_types'							):
        _snake_case   :				str														=	self.model_tester.num_hidden_states_types
      else:
        # also another +1 for reshaped_hidden_states
        _snake_case   :				List[Any]														=	2
      self.assertEqual(out_len + added_hidden_states      ,				len(UpperCamelCase							)							)

      _snake_case   :				Union[str, Any]														=	outputs.attentions

      self.assertEqual(len(UpperCamelCase							)      ,				UpperCamelCase							)

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







  def UpperCamelCase_ (      self      :					Optional[int]      ,				UpperCamelCase      :					Optional[int]      ,				UpperCamelCase      :					str      ,				UpperCamelCase      :					List[Any]      ,				UpperCamelCase      :					int							):


    '''simple docstring'''





    _snake_case   :				Optional[int]														=	model_class(UpperCamelCase							)
    model.to(UpperCamelCase							)
    model.eval()

    with torch.no_grad():
      _snake_case   :				Union[str, Any]														=	model(**self._prepare_for_class(UpperCamelCase      ,				UpperCamelCase							)							)

    _snake_case   :				Optional[int]														=	outputs.hidden_states

    _snake_case   :				Optional[int]														=	getattr(
        self.model_tester      ,				'expected_num_hidden_layers'      ,				len(self.model_tester.depths							) + 1							)
    self.assertEqual(len(UpperCamelCase							)      ,				UpperCamelCase							)

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

    _snake_case   :				Union[str, Any]														=	(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]      ,				)

    _snake_case   :				List[str]														=	outputs.reshaped_hidden_states
    self.assertEqual(len(UpperCamelCase							)      ,				UpperCamelCase							)

    _snake_case							,					_snake_case							,					_snake_case							,					_snake_case   :				Optional[int]														=	reshaped_hidden_states[0].shape
    _snake_case   :				List[str]														=	(
        reshaped_hidden_states[0].view(UpperCamelCase      ,				UpperCamelCase      ,				height * width							).permute(0      ,				2      ,				1							)
    )
    self.assertListEqual(
        list(reshaped_hidden_states.shape[-2:]							)      ,				[num_patches, self.model_tester.embed_dim]      ,				)







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


    '''simple docstring'''





    _snake_case							,					_snake_case   :				List[Any]														=	self.model_tester.prepare_config_and_inputs_for_common()

    _snake_case   :				Tuple														=	(
        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:
      _snake_case   :				Any														=	True
      self.check_hidden_states_output(UpperCamelCase      ,				UpperCamelCase      ,				UpperCamelCase      ,				UpperCamelCase							)

      # check that output_hidden_states also work using config
      del inputs_dict["output_hidden_states"]
      _snake_case   :				Union[str, Any]														=	True

      self.check_hidden_states_output(UpperCamelCase      ,				UpperCamelCase      ,				UpperCamelCase      ,				UpperCamelCase							)







  def UpperCamelCase_ (      self      :					str							):


    '''simple docstring'''





    _snake_case							,					_snake_case   :				Union[str, Any]														=	self.model_tester.prepare_config_and_inputs_for_common()
    _snake_case   :				Tuple														=	3

    _snake_case   :				List[str]														=	(
        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)
    )
    _snake_case   :				str														=	(
        config.patch_size
        if isinstance(config.patch_size      ,				collections.abc.Iterable							)
        else (config.patch_size, config.patch_size)
    )

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

    for model_class in self.all_model_classes:
      _snake_case   :				Tuple														=	True
      self.check_hidden_states_output(UpperCamelCase      ,				UpperCamelCase      ,				UpperCamelCase      ,				(padded_height, padded_width)							)

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







  def UpperCamelCase_ (      self      :					List[str]							):


    '''simple docstring'''





    _snake_case   :				Any														=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_masked_image_modeling(*UpperCamelCase							)







  def UpperCamelCase_ (      self      :					Optional[Any]							):


    '''simple docstring'''





    _snake_case   :				Optional[int]														=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_image_classification(*UpperCamelCase							)







  @slow
  def UpperCamelCase_ (      self      :					int							):


    '''simple docstring'''





    for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
      _snake_case   :				Tuple														=	SwinvaModel.from_pretrained(UpperCamelCase							)
      self.assertIsNotNone(UpperCamelCase							)







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


    '''simple docstring'''





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

    _snake_case   :				Tuple														=	_config_zero_init(UpperCamelCase							)
    for model_class in self.all_model_classes:
      _snake_case   :				Union[str, Any]														=	model_class(config=UpperCamelCase							)
      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        _lowerCAmelCase    (			unittest.TestCase							):


  '''simple docstring'''







  @cached_property
  def UpperCamelCase_ (      self      :					Union[str, Any]							):


    '''simple docstring'''





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







  @slow
  def UpperCamelCase_ (      self      :					List[str]							):


    '''simple docstring'''





    _snake_case   :				Union[str, Any]														=	SwinvaForImageClassification.from_pretrained('microsoft/swinv2-tiny-patch4-window8-256'							).to(
        UpperCamelCase							)
    _snake_case   :				Any														=	self.default_image_processor

    _snake_case   :				Dict														=	Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'							)
    _snake_case   :				List[str]														=	image_processor(images=UpperCamelCase      ,				return_tensors='pt'							).to(UpperCamelCase							)

    # forward pass
    with torch.no_grad():
      _snake_case   :				Any														=	model(**UpperCamelCase							)

    # verify the logits
    _snake_case   :				str														=	torch.Size((1, 10_00)							)
    self.assertEqual(outputs.logits.shape      ,				UpperCamelCase							)
    _snake_case   :				List[Any]														=	torch.tensor([-0.39_47, -0.43_06, 0.00_26]							).to(UpperCamelCase							)
    self.assertTrue(torch.allclose(outputs.logits[0, :3]      ,				UpperCamelCase      ,				atol=1e-4							)							)











# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import argparse
import os

from accelerate.utils import ComputeEnvironment

from .cluster import get_cluster_input
from .config_args import cache_dir, default_config_file, default_yaml_config_file, load_config_from_file  # noqa: F401
from .config_utils import _ask_field, _ask_options, _convert_compute_environment  # noqa: F401
from .sagemaker import get_sagemaker_input


lowerCAmelCase_						   =    """Launches a series of prompts to create and save a `default_config.yaml` configuration file for your training system. Should always be ran first on your machine"""


def     lowerCamelCase_	(      )->		Tuple:
  _snake_case   :				int														=	_ask_options(
      'In which compute environment are you running?'    ,							['This machine', 'AWS (Amazon SageMaker)']    ,							_convert_compute_environment    ,							)
  if compute_environment == ComputeEnvironment.AMAZON_SAGEMAKER:
    _snake_case   :				int														=	get_sagemaker_input()
  else:
    _snake_case   :				Any														=	get_cluster_input()
  return config


def     lowerCamelCase_	(      lowerCAmelCase:	str=None				)->		Any:
  if subparsers is not None:
    _snake_case   :				List[Any]														=	subparsers.add_parser('config'    ,							description=lowerCAmelCase				)
  else:
    _snake_case   :				Dict														=	argparse.ArgumentParser('Accelerate config command'    ,							description=lowerCAmelCase				)

  parser.add_argument(
      '--config_file'    ,							default=lowerCAmelCase    ,							help=(
          'The path to use to store the config file. Will default to a file named default_config.yaml in the cache '
          'location, which is the content of the environment `HF_HOME` suffixed with \'accelerate\', or if you don\'t have '
          'such an environment variable, your cache directory (\'~/.cache\' or the content of `XDG_CACHE_HOME`) suffixed '
          'with \'huggingface\'.'
      )    ,							)

  if subparsers is not None:
    parser.set_defaults(func=lowerCAmelCase				)
  return parser


def     lowerCamelCase_	(      lowerCAmelCase:	Any				)->		Any:
  _snake_case   :				Dict														=	get_user_input()
  if args.config_file is not None:
    _snake_case   :				List[str]														=	args.config_file
  else:
    if not os.path.isdir(lowerCAmelCase				):
      os.makedirs(lowerCAmelCase				)
    _snake_case   :				Union[str, Any]														=	default_yaml_config_file

  if config_file.endswith('.json'				):
    config.to_json_file(lowerCAmelCase				)
  else:
    config.to_yaml_file(lowerCAmelCase				)
  print(F"""accelerate configuration saved at {config_file}"""				)


def     lowerCamelCase_	(      )->		Dict:
  _snake_case   :				List[str]														=	config_command_parser()
  _snake_case   :				str														=	parser.parse_args()
  config_command(lowerCAmelCase				)


if __name__ == "__main__":
      main()




