


from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
			import tensorflow as tf

			from transformers import (
			    TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
			    TFXLMForMultipleChoice,
			    TFXLMForQuestionAnsweringSimple,
			    TFXLMForSequenceClassification,
			    TFXLMForTokenClassification,
			    TFXLMModel,
			    TFXLMWithLMHeadModel,
			    XLMConfig,
			)

class  UpperCamelCase__ :






						def __init__(     self					:   int,		__lowerCamelCase					:   Optional[Any],		)  -> Any:
											UpperCamelCase__							:  Optional[Any]								=     parent
											UpperCamelCase__							:  Optional[int]								=     13
											UpperCamelCase__							:  int								=     7
											UpperCamelCase__							:  Optional[int]								=     True
											UpperCamelCase__							:  Any								=     True
											UpperCamelCase__							:  str								=     True
											UpperCamelCase__							:  Any								=     True
											UpperCamelCase__							:  Optional[int]								=     True
											UpperCamelCase__							:  List[Any]								=     False
											UpperCamelCase__							:  int								=     False
											UpperCamelCase__							:  List[str]								=     False
											UpperCamelCase__							:  List[Any]								=     2
											UpperCamelCase__							:  str								=     99
											UpperCamelCase__							:  Optional[int]								=     0
											UpperCamelCase__							:  str								=     32
											UpperCamelCase__							:  str								=     2
											UpperCamelCase__							:  Optional[Any]								=     4
											UpperCamelCase__							:  Any								=     0.1
											UpperCamelCase__							:  List[Any]								=     0.1
											UpperCamelCase__							:  List[Any]								=     5_12
											UpperCamelCase__							:  List[str]								=     16
											UpperCamelCase__							:  Optional[int]								=     2
											UpperCamelCase__							:  Dict								=     0.02
											UpperCamelCase__							:  Tuple								=     3
											UpperCamelCase__							:  Dict								=     4
											UpperCamelCase__							:  Dict								=     'last'
											UpperCamelCase__							:  Dict								=     True
											UpperCamelCase__							:  Optional[int]								=     None
											UpperCamelCase__							:  Tuple								=     0






						def 	__lowercase(     self					:   List[str]   )  -> int:
											UpperCamelCase__							:  Any								=     ids_tensor([self.batch_size, self.seq_length],		self.vocab_size   )
											UpperCamelCase__							:  Tuple								=     random_attention_mask([self.batch_size, self.seq_length],		dtype=tf.floataa   )

											UpperCamelCase__							:  Tuple								=     None
											if self.use_input_lengths:
																UpperCamelCase__							:  str								=     (
																    ids_tensor([self.batch_size],		vocab_size=2   ) + self.seq_length - 2
																)  # small variation of seq_length

											UpperCamelCase__							:  Optional[Any]								=     None
											if self.use_token_type_ids:
																UpperCamelCase__							:  Union[str, Any]								=     ids_tensor([self.batch_size, self.seq_length],		self.n_langs   )

											UpperCamelCase__							:  Optional[int]								=     None
											UpperCamelCase__							:  Optional[int]								=     None
											UpperCamelCase__							:  Dict								=     None
											if self.use_labels:
																UpperCamelCase__							:  Tuple								=     ids_tensor([self.batch_size],		self.type_sequence_label_size   )
																UpperCamelCase__							:  Any								=     ids_tensor([self.batch_size, self.seq_length],		self.num_labels   )
																UpperCamelCase__							:  Optional[Any]								=     ids_tensor([self.batch_size],		2,		dtype=tf.floataa   )
																UpperCamelCase__							:  Tuple								=     ids_tensor([self.batch_size],		self.num_choices   )

											UpperCamelCase__							:  Union[str, Any]								=     XLMConfig(
											    vocab_size=self.vocab_size,		n_special=self.n_special,		emb_dim=self.hidden_size,		n_layers=self.num_hidden_layers,		n_heads=self.num_attention_heads,		dropout=self.hidden_dropout_prob,		attention_dropout=self.attention_probs_dropout_prob,		gelu_activation=self.gelu_activation,		sinusoidal_embeddings=self.sinusoidal_embeddings,		asm=self.asm,		causal=self.causal,		n_langs=self.n_langs,		max_position_embeddings=self.max_position_embeddings,		initializer_range=self.initializer_range,		summary_type=self.summary_type,		use_proj=self.use_proj,		bos_token_id=self.bos_token_id,		)

											return (
											    config,
											    input_ids,
											    token_type_ids,
											    input_lengths,
											    sequence_labels,
											    token_labels,
											    is_impossible_labels,
											    choice_labels,
											    input_mask,
											)






						def 	__lowercase(     self					:   Any,		__lowerCamelCase					:   Any,		__lowerCamelCase					:   List[Any],		__lowerCamelCase					:   List[str],		__lowerCamelCase					:   Union[str, Any],		__lowerCamelCase					:   Dict,		__lowerCamelCase					:   List[str],		__lowerCamelCase					:   Tuple,		__lowerCamelCase					:   List[str],		__lowerCamelCase					:   List[Any],		)  -> Any:
											UpperCamelCase__							:  Union[str, Any]								=     TFXLMModel(config=__a   )
											UpperCamelCase__							:  Optional[int]								=     {'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
											UpperCamelCase__							:  int								=     model(__a   )

											UpperCamelCase__							:  Tuple								=     [input_ids, input_mask]
											UpperCamelCase__							:  Union[str, Any]								=     model(__a   )
											self.parent.assertEqual(result.last_hidden_state.shape,		(self.batch_size, self.seq_length, self.hidden_size)   )






						def 	__lowercase(     self					:   List[Any],		__lowerCamelCase					:   Dict,		__lowerCamelCase					:   Optional[int],		__lowerCamelCase					:   str,		__lowerCamelCase					:   Tuple,		__lowerCamelCase					:   Dict,		__lowerCamelCase					:   List[Any],		__lowerCamelCase					:   Union[str, Any],		__lowerCamelCase					:   Any,		__lowerCamelCase					:   int,		)  -> Dict:
											UpperCamelCase__							:  Any								=     TFXLMWithLMHeadModel(__a   )

											UpperCamelCase__							:  List[str]								=     {'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
											UpperCamelCase__							:  Dict								=     model(__a   )

											UpperCamelCase__							:  Tuple								=     outputs

											self.parent.assertEqual(result.logits.shape,		(self.batch_size, self.seq_length, self.vocab_size)   )






						def 	__lowercase(     self					:   Union[str, Any],		__lowerCamelCase					:   Any,		__lowerCamelCase					:   int,		__lowerCamelCase					:   Tuple,		__lowerCamelCase					:   str,		__lowerCamelCase					:   List[str],		__lowerCamelCase					:   str,		__lowerCamelCase					:   Optional[int],		__lowerCamelCase					:   List[Any],		__lowerCamelCase					:   Any,		)  -> int:
											UpperCamelCase__							:  Optional[Any]								=     TFXLMForQuestionAnsweringSimple(__a   )

											UpperCamelCase__							:  Any								=     {'input_ids': input_ids, 'lengths': input_lengths}

											UpperCamelCase__							:  List[str]								=     model(__a   )

											self.parent.assertEqual(result.start_logits.shape,		(self.batch_size, self.seq_length)   )
											self.parent.assertEqual(result.end_logits.shape,		(self.batch_size, self.seq_length)   )






						def 	__lowercase(     self					:   Optional[Any],		__lowerCamelCase					:   Tuple,		__lowerCamelCase					:   List[str],		__lowerCamelCase					:   Any,		__lowerCamelCase					:   Optional[Any],		__lowerCamelCase					:   int,		__lowerCamelCase					:   Optional[Any],		__lowerCamelCase					:   Tuple,		__lowerCamelCase					:   Any,		__lowerCamelCase					:   Optional[Any],		)  -> Any:
											UpperCamelCase__							:  Union[str, Any]								=     TFXLMForSequenceClassification(__a   )

											UpperCamelCase__							:  int								=     {'input_ids': input_ids, 'lengths': input_lengths}

											UpperCamelCase__							:  Dict								=     model(__a   )

											self.parent.assertEqual(result.logits.shape,		(self.batch_size, self.type_sequence_label_size)   )






						def 	__lowercase(     self					:   List[str],		__lowerCamelCase					:   Union[str, Any],		__lowerCamelCase					:   str,		__lowerCamelCase					:   List[Any],		__lowerCamelCase					:   str,		__lowerCamelCase					:   Optional[Any],		__lowerCamelCase					:   str,		__lowerCamelCase					:   Optional[Any],		__lowerCamelCase					:   int,		__lowerCamelCase					:   Any,		)  -> Optional[Any]:
											UpperCamelCase__							:  Union[str, Any]								=     self.num_labels
											UpperCamelCase__							:  int								=     TFXLMForTokenClassification(config=__a   )
											UpperCamelCase__							:  Optional[Any]								=     {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
											UpperCamelCase__							:  Tuple								=     model(__a   )
											self.parent.assertEqual(result.logits.shape,		(self.batch_size, self.seq_length, self.num_labels)   )






						def 	__lowercase(     self					:   Union[str, Any],		__lowerCamelCase					:   Dict,		__lowerCamelCase					:   List[Any],		__lowerCamelCase					:   Any,		__lowerCamelCase					:   Optional[int],		__lowerCamelCase					:   Union[str, Any],		__lowerCamelCase					:   int,		__lowerCamelCase					:   List[Any],		__lowerCamelCase					:   Tuple,		__lowerCamelCase					:   Union[str, Any],		)  -> str:
											UpperCamelCase__							:  Any								=     self.num_choices
											UpperCamelCase__							:  Dict								=     TFXLMForMultipleChoice(config=__a   )
											UpperCamelCase__							:  List[Any]								=     tf.tile(tf.expand_dims(__a,		1   ),		(1, self.num_choices, 1)   )
											UpperCamelCase__							:  Tuple								=     tf.tile(tf.expand_dims(__a,		1   ),		(1, self.num_choices, 1)   )
											UpperCamelCase__							:  int								=     tf.tile(tf.expand_dims(__a,		1   ),		(1, self.num_choices, 1)   )
											UpperCamelCase__							:  Dict								=     {
											    'input_ids': multiple_choice_inputs_ids,
											    'attention_mask': multiple_choice_input_mask,
											    'token_type_ids': multiple_choice_token_type_ids,
											}
											UpperCamelCase__							:  List[Any]								=     model(__a   )
											self.parent.assertEqual(result.logits.shape,		(self.batch_size, self.num_choices)   )






						def 	__lowercase(     self					:   Any   )  -> int:
											UpperCamelCase__							:  Dict								=     self.prepare_config_and_inputs()
											(
											    UpperCamelCase__       
											)							:  Dict								=     config_and_inputs
											UpperCamelCase__							:  Dict								=     {
											    'input_ids': input_ids,
											    'token_type_ids': token_type_ids,
											    'langs': token_type_ids,
											    'lengths': input_lengths,
											}
											return config, inputs_dict

@require_tf
class  UpperCamelCase__ ( lowerCAmelCase_							,						lowerCAmelCase_							,						unittest.TestCase			):
						a__   :     str								=						(
						    (
						        TFXLMModel,
						        TFXLMWithLMHeadModel,
						        TFXLMForSequenceClassification,
						        TFXLMForQuestionAnsweringSimple,
						        TFXLMForTokenClassification,
						        TFXLMForMultipleChoice,
						    )
						    if is_tf_available()
						    else ()
						)
						a__   :     Union[str, Any]								=						(
						    (TFXLMWithLMHeadModel,) if is_tf_available() else ()
						)  # TODO (PVP): Check other models whether language generation is also applicable
						a__   :     int								=						(
						    {
						        'feature-extraction': TFXLMModel,
						        'fill-mask': TFXLMWithLMHeadModel,
						        'question-answering': TFXLMForQuestionAnsweringSimple,
						        'text-classification': TFXLMForSequenceClassification,
						        'text-generation': TFXLMWithLMHeadModel,
						        'token-classification': TFXLMForTokenClassification,
						        'zero-shot': TFXLMForSequenceClassification,
						    }
						    if is_tf_available()
						    else {}
						)
						a__   :     List[Any]								=						False
						a__   :     str								=						False






						def 	__lowercase(     self					:   int,		__lowerCamelCase					:   Any,		__lowerCamelCase					:   Dict,		__lowerCamelCase					:   Optional[int],		__lowerCamelCase					:   Tuple,		__lowerCamelCase					:   List[str]   )  -> Any:





											if (
											    pipeline_test_casse_name == "QAPipelineTests"
											    and tokenizer_name is not None
											    and not tokenizer_name.endswith('''Fast'''   )
											):
																# `QAPipelineTests` fails for a few models when the slower tokenizer are used.
																# (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
																# TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
																return True

											return False






						def 	__lowercase(     self					:   Optional[int]   )  -> Dict:
											UpperCamelCase__							:  Optional[Any]								=     TFXLMModelTester(self   )
											UpperCamelCase__							:  Optional[int]								=     ConfigTester(self,		config_class=__a,		emb_dim=37   )






						def 	__lowercase(     self					:   Union[str, Any]   )  -> List[str]:
											self.config_tester.run_common_tests()






						def 	__lowercase(     self					:   int   )  -> str:
											UpperCamelCase__							:  List[str]								=     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_xlm_model(*__a   )






						def 	__lowercase(     self					:   int   )  -> Any:
											UpperCamelCase__							:  Union[str, Any]								=     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_xlm_lm_head(*__a   )






						def 	__lowercase(     self					:   Union[str, Any]   )  -> List[Any]:
											UpperCamelCase__							:  int								=     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_xlm_qa(*__a   )






						def 	__lowercase(     self					:   Union[str, Any]   )  -> Any:
											UpperCamelCase__							:  Tuple								=     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_xlm_sequence_classif(*__a   )






						def 	__lowercase(     self					:   Optional[int]   )  -> Optional[int]:
											UpperCamelCase__							:  str								=     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_xlm_for_token_classification(*__a   )






						def 	__lowercase(     self					:   Union[str, Any]   )  -> int:
											UpperCamelCase__							:  Dict								=     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_xlm_for_multiple_choice(*__a   )






						@slow
						def 	__lowercase(     self					:   Optional[int]   )  -> Optional[Any]:





											for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																UpperCamelCase__							:  Union[str, Any]								=     TFXLMModel.from_pretrained(__a   )
																self.assertIsNotNone(__a   )

@require_tf
class  UpperCamelCase__ ( unittest.TestCase			):






						@slow
						def 	__lowercase(     self					:   List[str]   )  -> Tuple:
											UpperCamelCase__							:  Tuple								=     TFXLMWithLMHeadModel.from_pretrained('''xlm-mlm-en-2048'''   )
											UpperCamelCase__							:  Any								=     tf.convert_to_tensor([[14, 4_47]],		dtype=tf.intaa   )  # the president
											UpperCamelCase__							:  Optional[int]								=     [
											    14,
											    4_47,
											    14,
											    4_47,
											    14,
											    4_47,
											    14,
											    4_47,
											    14,
											    4_47,
											    14,
											    4_47,
											    14,
											    4_47,
											    14,
											    4_47,
											    14,
											    4_47,
											    14,
											    4_47,
											]  # the president the president the president the president the president the president the president the president the president the president
											# TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
											UpperCamelCase__							:  List[str]								=     model.generate(__a,		do_sample=__a   )
											self.assertListEqual(output_ids[0].numpy().tolist(),		__a   )








from __future__ import annotations

from math import pi, pow







def 						_lowercase       (     __lowerCamelCase			:					int | float			)  ->   float:





     '''simple docstring'''





     if side_length < 0:
          raise ValueError('''vol_cube() only accepts non-negative values'''			)
     return pow(__lowerCamelCase		,3			)







def 						_lowercase       (     __lowerCamelCase			:					float		,__lowerCamelCase			:					float			)  ->   float:





     '''simple docstring'''





     if height < 0 or radius < 0:
          raise ValueError('''vol_spherical_cap() only accepts non-negative values'''			)
     # Volume is 1/3 pi * height squared * (3 * radius - height)
     return 1 / 3 * pi * pow(__lowerCamelCase		,2			) * (3 * radius - height)







def 						_lowercase       (     __lowerCamelCase			:					float		,__lowerCamelCase			:					float		,__lowerCamelCase			:					float			)  ->   float:





     '''simple docstring'''





     if radius_a < 0 or radius_a < 0 or centers_distance < 0:
          raise ValueError('''vol_spheres_intersect() only accepts non-negative values'''			)
     if centers_distance == 0:
          return vol_sphere(min(__lowerCamelCase		,__lowerCamelCase			)			)

     UpperCamelCase__							:  Dict								=     (
         (radius_a - radius_a + centers_distance)
         * (radius_a + radius_a - centers_distance)
         / (2 * centers_distance)
     )
     UpperCamelCase__							:  Tuple								=     (
         (radius_a - radius_a + centers_distance)
         * (radius_a + radius_a - centers_distance)
         / (2 * centers_distance)
     )

     return vol_spherical_cap(__lowerCamelCase		,__lowerCamelCase			) + vol_spherical_cap(__lowerCamelCase		,__lowerCamelCase			)







def 						_lowercase       (     __lowerCamelCase			:					float		,__lowerCamelCase			:					float		,__lowerCamelCase			:					float			)  ->   float:





     '''simple docstring'''





     if radius_a <= 0 or radius_a <= 0 or centers_distance < 0:
          raise ValueError(
              '''vol_spheres_union() only accepts non-negative values, non-zero radius'''			)

     if centers_distance == 0:
          return vol_sphere(max(__lowerCamelCase		,__lowerCamelCase			)			)

     return (
         vol_sphere(__lowerCamelCase			)
         + vol_sphere(__lowerCamelCase			)
         - vol_spheres_intersect(__lowerCamelCase		,__lowerCamelCase		,__lowerCamelCase			)
     )







def 						_lowercase       (     __lowerCamelCase			:					float		,__lowerCamelCase			:					float		,__lowerCamelCase			:					float			)  ->   float:





     '''simple docstring'''





     if width < 0 or height < 0 or length < 0:
          raise ValueError('''vol_cuboid() only accepts non-negative values'''			)
     return float(width * height * length			)







def 						_lowercase       (     __lowerCamelCase			:					float		,__lowerCamelCase			:					float			)  ->   float:





     '''simple docstring'''





     if height < 0 or area_of_base < 0:
          raise ValueError('''vol_cone() only accepts non-negative values'''			)
     return area_of_base * height / 3.0







def 						_lowercase       (     __lowerCamelCase			:					float		,__lowerCamelCase			:					float			)  ->   float:





     '''simple docstring'''





     if height < 0 or radius < 0:
          raise ValueError('''vol_right_circ_cone() only accepts non-negative values'''			)
     return pi * pow(__lowerCamelCase		,2			) * height / 3.0







def 						_lowercase       (     __lowerCamelCase			:					float		,__lowerCamelCase			:					float			)  ->   float:





     '''simple docstring'''





     if height < 0 or area_of_base < 0:
          raise ValueError('''vol_prism() only accepts non-negative values'''			)
     return float(area_of_base * height			)







def 						_lowercase       (     __lowerCamelCase			:					float		,__lowerCamelCase			:					float			)  ->   float:





     '''simple docstring'''





     if height < 0 or area_of_base < 0:
          raise ValueError('''vol_pyramid() only accepts non-negative values'''			)
     return area_of_base * height / 3.0







def 						_lowercase       (     __lowerCamelCase			:					float			)  ->   float:





     '''simple docstring'''





     if radius < 0:
          raise ValueError('''vol_sphere() only accepts non-negative values'''			)
     # Volume is 4/3 * pi * radius cubed
     return 4 / 3 * pi * pow(__lowerCamelCase		,3			)







def 						_lowercase       (     __lowerCamelCase			:					float			)  ->   float:





     '''simple docstring'''





     if radius < 0:
          raise ValueError('''vol_hemisphere() only accepts non-negative values'''			)
     # Volume is radius cubed * pi * 2/3
     return pow(__lowerCamelCase		,3			) * pi * 2 / 3







def 						_lowercase       (     __lowerCamelCase			:					float		,__lowerCamelCase			:					float			)  ->   float:





     '''simple docstring'''





     if height < 0 or radius < 0:
          raise ValueError('''vol_circular_cylinder() only accepts non-negative values'''			)
     # Volume is radius squared * height * pi
     return pow(__lowerCamelCase		,2			) * height * pi







def 						_lowercase       (     __lowerCamelCase			:					float		,__lowerCamelCase			:					float		,__lowerCamelCase			:					float			)  ->   float:





     '''simple docstring'''





     if inner_radius < 0 or outer_radius < 0 or height < 0:
          raise ValueError(
              '''vol_hollow_circular_cylinder() only accepts non-negative values'''			)
     if outer_radius <= inner_radius:
          raise ValueError('''outer_radius must be greater than inner_radius'''			)
     return pi * (pow(__lowerCamelCase		,2			) - pow(__lowerCamelCase		,2			)) * height







def 						_lowercase       (     __lowerCamelCase			:					float		,__lowerCamelCase			:					float		,__lowerCamelCase			:					float			)  ->   float:





     '''simple docstring'''





     if radius_a < 0 or radius_a < 0 or height < 0:
          raise ValueError('''vol_conical_frustum() only accepts non-negative values'''			)
     return (
         1
         / 3
         * pi
         * height
         * (pow(__lowerCamelCase		,2			) + pow(__lowerCamelCase		,2			) + radius_a * radius_a)
     )







def 						_lowercase       (     __lowerCamelCase			:					float		,__lowerCamelCase			:					float			)  ->   float:





     '''simple docstring'''





     if torus_radius < 0 or tube_radius < 0:
          raise ValueError('''vol_torus() only accepts non-negative values'''			)
     return 2 * pow(__lowerCamelCase		,2			) * torus_radius * pow(__lowerCamelCase		,2			)







def 						_lowercase       (     )  ->   Tuple:





     '''simple docstring'''





     print('''Volumes:'''			)
     print(F'Cube: {vol_cube(2			) = }'			)  # = 8
     print(F'Cuboid: {vol_cuboid(2		,2		,2			) = }'			)  # = 8
     print(F'Cone: {vol_cone(2		,2			) = }'			)  # ~= 1.33
     print(F'Right Circular Cone: {vol_right_circ_cone(2		,2			) = }'			)  # ~= 8.38
     print(F'Prism: {vol_prism(2		,2			) = }'			)  # = 4
     print(F'Pyramid: {vol_pyramid(2		,2			) = }'			)  # ~= 1.33
     print(F'Sphere: {vol_sphere(2			) = }'			)  # ~= 33.5
     print(F'Hemisphere: {vol_hemisphere(2			) = }'			)  # ~= 16.75
     print(F'Circular Cylinder: {vol_circular_cylinder(2		,2			) = }'			)  # ~= 25.1
     print(F'Torus: {vol_torus(2		,2			) = }'			)  # ~= 157.9
     print(F'Conical Frustum: {vol_conical_frustum(2		,2		,4			) = }'			)  # ~= 58.6
     print(F'Spherical cap: {vol_spherical_cap(1		,2			) = }'			)  # ~= 5.24
     print(F'Spheres intersetion: {vol_spheres_intersect(2		,2		,1			) = }'			)  # ~= 21.21
     print(F'Spheres union: {vol_spheres_union(2		,2		,1			) = }'			)  # ~= 45.81
     print(
         F'Hollow Circular Cylinder: {vol_hollow_circular_cylinder(1		,2		,3			) = }'			)  # ~= 28.3


if __name__ == "__main__":
   main()




