
"""simple docstring"""



from __future__ import annotations

import unittest

from transformers import RoFormerConfig, 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 (
	    TFRoFormerForCausalLM,
	    TFRoFormerForMaskedLM,
	    TFRoFormerForMultipleChoice,
	    TFRoFormerForQuestionAnswering,
	    TFRoFormerForSequenceClassification,
	    TFRoFormerForTokenClassification,
	    TFRoFormerModel,
	)
	from transformers.models.roformer.modeling_tf_roformer import (
	    TFRoFormerSelfAttention,
	    TFRoFormerSinusoidalPositionalEmbedding,
	)
class        _SCREAMING_SNAKE_CASE  :






				'''simple docstring'''



				def __init__(					self	:			Union[str, Any]				,     UpperCAmelCase_	:			Dict				,     UpperCAmelCase_	:			Union[str, Any]=13				,     UpperCAmelCase_	:			Union[str, Any]=7				,     UpperCAmelCase_	:			str=True				,     UpperCAmelCase_	:			Union[str, Any]=True				,     UpperCAmelCase_	:			int=True				,     UpperCAmelCase_	:			Union[str, Any]=True				,     UpperCAmelCase_	:			Dict=99				,     UpperCAmelCase_	:			Dict=32				,     UpperCAmelCase_	:			Any=2				,     UpperCAmelCase_	:			Tuple=4				,     UpperCAmelCase_	:			str=37				,     UpperCAmelCase_	:			Optional[int]="gelu"				,     UpperCAmelCase_	:			str=0.1				,     UpperCAmelCase_	:			Tuple=0.1				,     UpperCAmelCase_	:			List[str]=512				,     UpperCAmelCase_	:			Tuple=16				,     UpperCAmelCase_	:			List[Any]=2				,     UpperCAmelCase_	:			Any=0.02				,     UpperCAmelCase_	:			List[Any]=3				,     UpperCAmelCase_	:			List[Any]=4				,     UpperCAmelCase_	:			List[Any]=None				,     )		->  Optional[int]:







											"""simple docstring"""




											_lowerCAmelCase  	=			parent
											_lowerCAmelCase  	=			13
											_lowerCAmelCase  	=			7
											_lowerCAmelCase  	=			True
											_lowerCAmelCase  	=			True
											_lowerCAmelCase  	=			True
											_lowerCAmelCase  	=			True
											_lowerCAmelCase  	=			99
											_lowerCAmelCase  	=			32
											_lowerCAmelCase  	=			2
											_lowerCAmelCase  	=			4
											_lowerCAmelCase  	=			37
											_lowerCAmelCase  	=			'gelu'
											_lowerCAmelCase  	=			0.1
											_lowerCAmelCase  	=			0.1
											_lowerCAmelCase  	=			512
											_lowerCAmelCase  	=			16
											_lowerCAmelCase  	=			2
											_lowerCAmelCase  	=			0.02
											_lowerCAmelCase  	=			3
											_lowerCAmelCase  	=			4
											_lowerCAmelCase  	=			None


				def 				__lowerCamelCase	(					self	:			Any  )		->  Optional[Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			ids_tensor([self.batch_size, self.seq_length]				,     self.vocab_size  )

											_lowerCAmelCase  	=			None
											if self.use_input_mask:
																		_lowerCAmelCase  	=			random_attention_mask([self.batch_size, self.seq_length]  )

											_lowerCAmelCase  	=			None
											if self.use_token_type_ids:
																		_lowerCAmelCase  	=			ids_tensor([self.batch_size, self.seq_length]				,     self.type_vocab_size  )

											_lowerCAmelCase  	=			None
											_lowerCAmelCase  	=			None
											_lowerCAmelCase  	=			None
											if self.use_labels:
																		_lowerCAmelCase  	=			ids_tensor([self.batch_size]				,     self.type_sequence_label_size  )
																		_lowerCAmelCase  	=			ids_tensor([self.batch_size, self.seq_length]				,     self.num_labels  )
																		_lowerCAmelCase  	=			ids_tensor([self.batch_size]				,     self.num_choices  )

											_lowerCAmelCase  	=			RoFormerConfig(
											    vocab_size=self.vocab_size				,     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				,     max_position_embeddings=self.max_position_embeddings				,     type_vocab_size=self.type_vocab_size				,     initializer_range=self.initializer_range				,     return_dict=UpperCAmelCase_				,     )

											return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels


				def 				__lowerCamelCase	(					self	:			Dict				,     UpperCAmelCase_	:			Optional[Any]				,     UpperCAmelCase_	:			Dict				,     UpperCAmelCase_	:			int				,     UpperCAmelCase_	:			Any				,     UpperCAmelCase_	:			int				,     UpperCAmelCase_	:			Dict				,     UpperCAmelCase_	:			Optional[Any]  )		->  Union[str, Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			TFRoFormerModel(config=UpperCAmelCase_  )
											_lowerCAmelCase  	=			{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}

											_lowerCAmelCase  	=			[input_ids, input_mask]
											_lowerCAmelCase  	=			model(UpperCAmelCase_  )

											_lowerCAmelCase  	=			model(UpperCAmelCase_  )

											self.parent.assertEqual(result.last_hidden_state.shape				,     (self.batch_size, self.seq_length, self.hidden_size)  )


				def 				__lowerCamelCase	(					self	:			Optional[Any]				,     UpperCAmelCase_	:			List[str]				,     UpperCAmelCase_	:			List[str]				,     UpperCAmelCase_	:			int				,     UpperCAmelCase_	:			Union[str, Any]				,     UpperCAmelCase_	:			int				,     UpperCAmelCase_	:			str				,     UpperCAmelCase_	:			List[Any]  )		->  int:







											"""simple docstring"""




											_lowerCAmelCase  	=			True
											_lowerCAmelCase  	=			TFRoFormerForCausalLM(config=UpperCAmelCase_  )
											_lowerCAmelCase  	=			{
											    'input_ids': input_ids,
											    'attention_mask': input_mask,
											    'token_type_ids': token_type_ids,
											}
											_lowerCAmelCase  	=			model(UpperCAmelCase_  )['logits']
											self.parent.assertListEqual(
											    list(prediction_scores.numpy().shape  )				,     [self.batch_size, self.seq_length, self.vocab_size]  )


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







											"""simple docstring"""




											_lowerCAmelCase  	=			TFRoFormerForMaskedLM(config=UpperCAmelCase_  )
											_lowerCAmelCase  	=			{
											    'input_ids': input_ids,
											    'attention_mask': input_mask,
											    'token_type_ids': token_type_ids,
											}
											_lowerCAmelCase  	=			model(UpperCAmelCase_  )
											self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.seq_length, self.vocab_size)  )


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







											"""simple docstring"""




											_lowerCAmelCase  	=			self.num_labels
											_lowerCAmelCase  	=			TFRoFormerForSequenceClassification(config=UpperCAmelCase_  )
											_lowerCAmelCase  	=			{
											    'input_ids': input_ids,
											    'attention_mask': input_mask,
											    'token_type_ids': token_type_ids,
											}

											_lowerCAmelCase  	=			model(UpperCAmelCase_  )
											self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.num_labels)  )


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







											"""simple docstring"""




											_lowerCAmelCase  	=			self.num_choices
											_lowerCAmelCase  	=			TFRoFormerForMultipleChoice(config=UpperCAmelCase_  )
											_lowerCAmelCase  	=			tf.tile(tf.expand_dims(UpperCAmelCase_				,     1  )				,     (1, self.num_choices, 1)  )
											_lowerCAmelCase  	=			tf.tile(tf.expand_dims(UpperCAmelCase_				,     1  )				,     (1, self.num_choices, 1)  )
											_lowerCAmelCase  	=			tf.tile(tf.expand_dims(UpperCAmelCase_				,     1  )				,     (1, self.num_choices, 1)  )
											_lowerCAmelCase  	=			{
											    'input_ids': multiple_choice_inputs_ids,
											    'attention_mask': multiple_choice_input_mask,
											    'token_type_ids': multiple_choice_token_type_ids,
											}
											_lowerCAmelCase  	=			model(UpperCAmelCase_  )
											self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.num_choices)  )


				def 				__lowerCamelCase	(					self	:			Dict				,     UpperCAmelCase_	:			Union[str, Any]				,     UpperCAmelCase_	:			List[Any]				,     UpperCAmelCase_	:			str				,     UpperCAmelCase_	:			Union[str, Any]				,     UpperCAmelCase_	:			List[Any]				,     UpperCAmelCase_	:			Union[str, Any]				,     UpperCAmelCase_	:			int  )		->  Dict:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.num_labels
											_lowerCAmelCase  	=			TFRoFormerForTokenClassification(config=UpperCAmelCase_  )
											_lowerCAmelCase  	=			{
											    'input_ids': input_ids,
											    'attention_mask': input_mask,
											    'token_type_ids': token_type_ids,
											}
											_lowerCAmelCase  	=			model(UpperCAmelCase_  )
											self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.seq_length, self.num_labels)  )


				def 				__lowerCamelCase	(					self	:			List[Any]				,     UpperCAmelCase_	:			Union[str, Any]				,     UpperCAmelCase_	:			Tuple				,     UpperCAmelCase_	:			str				,     UpperCAmelCase_	:			Tuple				,     UpperCAmelCase_	:			str				,     UpperCAmelCase_	:			List[str]				,     UpperCAmelCase_	:			Union[str, Any]  )		->  List[Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			TFRoFormerForQuestionAnswering(config=UpperCAmelCase_  )
											_lowerCAmelCase  	=			{
											    'input_ids': input_ids,
											    'attention_mask': input_mask,
											    'token_type_ids': token_type_ids,
											}

											_lowerCAmelCase  	=			model(UpperCAmelCase_  )
											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 				__lowerCamelCase	(					self	:			Any  )		->  List[Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.prepare_config_and_inputs()
											(
											    (
											    _lowerCAmelCase
											)	,		(
											    _lowerCAmelCase
											)	,		(
											    _lowerCAmelCase
											)	,		(
											    _lowerCAmelCase
											)	,		(
											    _lowerCAmelCase
											)	,		(
											    _lowerCAmelCase
											)	,		(
											    _lowerCAmelCase
											)	,		
											)  	=			config_and_inputs
											_lowerCAmelCase  	=			{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
											return config, inputs_dict






@require_tf
class        _SCREAMING_SNAKE_CASE  (  UpperCAmelCase      ,				UpperCAmelCase      ,				unittest.TestCase							):






				'''simple docstring'''



				SCREAMING_SNAKE_CASE_:							Any							=					(
				    (
				        TFRoFormerModel,
				        TFRoFormerForCausalLM,
				        TFRoFormerForMaskedLM,
				        TFRoFormerForQuestionAnswering,
				        TFRoFormerForSequenceClassification,
				        TFRoFormerForTokenClassification,
				        TFRoFormerForMultipleChoice,
				    )
				    if is_tf_available()
				    else ()
				)
				SCREAMING_SNAKE_CASE_:							Optional[Any]							=					(
				    {
				        "feature-extraction": TFRoFormerModel,
				        "fill-mask": TFRoFormerForMaskedLM,
				        "question-answering": TFRoFormerForQuestionAnswering,
				        "text-classification": TFRoFormerForSequenceClassification,
				        "text-generation": TFRoFormerForCausalLM,
				        "token-classification": TFRoFormerForTokenClassification,
				        "zero-shot": TFRoFormerForSequenceClassification,
				    }
				    if is_tf_available()
				    else {}
				)

				SCREAMING_SNAKE_CASE_:							List[Any]							=					False
				SCREAMING_SNAKE_CASE_:							Tuple							=					False


				def 				__lowerCamelCase	(					self	:			Optional[int]				,     UpperCAmelCase_	:			Optional[int]				,     UpperCAmelCase_	:			Any				,     UpperCAmelCase_	:			int				,     UpperCAmelCase_	:			Optional[int]				,     UpperCAmelCase_	:			Union[str, Any]  )		->  List[Any]:







											"""simple docstring"""




											if pipeline_test_casse_name == "TextGenerationPipelineTests":
																		return True

											return False


				def 				__lowerCamelCase	(					self	:			List[Any]  )		->  Tuple:







											"""simple docstring"""




											_lowerCAmelCase  	=			TFRoFormerModelTester(self  )
											_lowerCAmelCase  	=			ConfigTester(self				,     config_class=UpperCAmelCase_				,     hidden_size=37  )


				def 				__lowerCamelCase	(					self	:			Optional[int]  )		->  int:







											"""simple docstring"""




											self.config_tester.run_common_tests()


				def 				__lowerCamelCase	(					self	:			Tuple  )		->  str:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*UpperCAmelCase_  )


				def 				__lowerCamelCase	(					self	:			Optional[int]  )		->  List[Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_masked_lm(*UpperCAmelCase_  )


				def 				__lowerCamelCase	(					self	:			str  )		->  Optional[Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_lm_head(*UpperCAmelCase_  )


				def 				__lowerCamelCase	(					self	:			List[Any]  )		->  Union[str, Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_multiple_choice(*UpperCAmelCase_  )


				def 				__lowerCamelCase	(					self	:			Any  )		->  List[Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_question_answering(*UpperCAmelCase_  )


				def 				__lowerCamelCase	(					self	:			Optional[Any]  )		->  Any:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_sequence_classification(*UpperCAmelCase_  )


				def 				__lowerCamelCase	(					self	:			str  )		->  str:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_token_classification(*UpperCAmelCase_  )







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







											"""simple docstring"""




											_lowerCAmelCase  	=			TFRoFormerModel.from_pretrained('junnyu/roformer_chinese_base'  )
											self.assertIsNotNone(UpperCAmelCase_  )






@require_tf
class        _SCREAMING_SNAKE_CASE  (  unittest.TestCase							):






				'''simple docstring'''



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







											"""simple docstring"""




											_lowerCAmelCase  	=			TFRoFormerForMaskedLM.from_pretrained('junnyu/roformer_chinese_base'  )
											_lowerCAmelCase  	=			tf.constant([[0, 1, 2, 3, 4, 5]]  )
											_lowerCAmelCase  	=			model(UpperCAmelCase_  )[0]

											# TODO Replace vocab size
											_lowerCAmelCase  	=			50_000

											_lowerCAmelCase  	=			[1, 6, vocab_size]
											self.assertEqual(output.shape				,     UpperCAmelCase_  )

											print(output[:, :3, :3]  )

											# TODO Replace values below with what was printed above.
											_lowerCAmelCase  	=			tf.constant(
											    [
											        [
											            [-0.12053341, -1.0264901, 0.29221946],
											            [-1.5133783, 0.197433, 0.15190607],
											            [-5.0135403, -3.900256, -0.84038764],
											        ]
											    ]  )
											tf.debugging.assert_near(output[:, :3, :3]				,     UpperCAmelCase_				,     atol=1E-4  )






@require_tf
class        _SCREAMING_SNAKE_CASE  (  unittest.TestCase							):






				'''simple docstring'''



				SCREAMING_SNAKE_CASE_:							Any							=					1e-4


				def 				__lowerCamelCase	(					self	:			List[Any]  )		->  List[str]:







											"""simple docstring"""




											_lowerCAmelCase  	=			tf.constant([[4, 10]]  )
											_lowerCAmelCase  	=			TFRoFormerSinusoidalPositionalEmbedding(num_positions=6				,     embedding_dim=6  )

											_lowerCAmelCase  	=			emba(input_ids.shape  )
											_lowerCAmelCase  	=			tf.constant(
											    [[0.0000, 0.0000, 0.0000, 1.0000, 1.0000, 1.0000], [0.8415, 0.0464, 0.0022, 0.5403, 0.9989, 1.0000]]  )

											tf.debugging.assert_near(UpperCAmelCase_				,     UpperCAmelCase_				,     atol=self.tolerance  )







				def 				__lowerCamelCase	(					self	:			Optional[Any]  )		->  int:







											"""simple docstring"""




											_lowerCAmelCase  	=			tf.constant(
											    [
											        [0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
											        [0.8415, 0.8219, 0.8020, 0.7819, 0.7617],
											        [0.9093, 0.9364, 0.9581, 0.9749, 0.9870],
											    ]  )
											_lowerCAmelCase  	=			TFRoFormerSinusoidalPositionalEmbedding(num_positions=512				,     embedding_dim=512  )
											emba([2, 16, 512]  )
											_lowerCAmelCase  	=			emba.weight[:3, :5]

											tf.debugging.assert_near(UpperCAmelCase_				,     UpperCAmelCase_				,     atol=self.tolerance  )






@require_tf
class        _SCREAMING_SNAKE_CASE  (  unittest.TestCase							):






				'''simple docstring'''



				SCREAMING_SNAKE_CASE_:							Optional[Any]							=					1e-4


				def 				__lowerCamelCase	(					self	:			Any  )		->  Tuple:







											"""simple docstring"""




											_lowerCAmelCase  	=			tf.reshape(tf.range(2 * 12 * 16 * 64				,     dtype=tf.floataa  )				,     shape=(2, 12, 16, 64)  ) / 100

											_lowerCAmelCase  	=			-tf.reshape(tf.range(2 * 12 * 16 * 64				,     dtype=tf.floataa  )				,     shape=(2, 12, 16, 64)  ) / 100

											_lowerCAmelCase  	=			TFRoFormerSinusoidalPositionalEmbedding(num_positions=32				,     embedding_dim=64  )
											_lowerCAmelCase  	=			embed_positions([2, 16, 768]  )[None, None, :, :]

											_lowerCAmelCase	,		_lowerCAmelCase  	=			TFRoFormerSelfAttention.apply_rotary_position_embeddings(
											    UpperCAmelCase_				,     UpperCAmelCase_				,     UpperCAmelCase_  )

											_lowerCAmelCase  	=			tf.constant(
											    [
											        [0.0000, 0.0100, 0.0200, 0.0300, 0.0400, 0.0500, 0.0600, 0.0700],
											        [-0.2012, 0.8897, 0.0263, 0.9401, 0.2074, 0.9463, 0.3481, 0.9343],
											        [-1.7057, 0.6271, -1.2145, 1.3897, -0.6303, 1.7647, -0.1173, 1.8985],
											        [-2.1731, -1.6397, -2.7358, 0.2854, -2.1840, 1.7183, -1.3018, 2.4871],
											        [0.2717, -3.6173, -2.9206, -2.1988, -3.6638, 0.3858, -2.9155, 2.2980],
											        [3.9859, -2.1580, -0.7984, -4.4904, -4.1181, -2.0252, -4.4782, 1.1253],
											    ]  )
											_lowerCAmelCase  	=			tf.constant(
											    [
											        [0.0000, -0.0100, -0.0200, -0.0300, -0.0400, -0.0500, -0.0600, -0.0700],
											        [0.2012, -0.8897, -0.0263, -0.9401, -0.2074, -0.9463, -0.3481, -0.9343],
											        [1.7057, -0.6271, 1.2145, -1.3897, 0.6303, -1.7647, 0.1173, -1.8985],
											        [2.1731, 1.6397, 2.7358, -0.2854, 2.1840, -1.7183, 1.3018, -2.4871],
											        [-0.2717, 3.6173, 2.9206, 2.1988, 3.6638, -0.3858, 2.9155, -2.2980],
											        [-3.9859, 2.1580, 0.7984, 4.4904, 4.1181, 2.0252, 4.4782, -1.1253],
											    ]  )

											tf.debugging.assert_near(query_layer[0, 0, :6, :8]				,     UpperCAmelCase_				,     atol=self.tolerance  )
											tf.debugging.assert_near(key_layer[0, 0, :6, :8]				,     UpperCAmelCase_				,     atol=self.tolerance  )








"""simple docstring"""



def 	__snake_case  (    SCREAMING_SNAKE_CASE:					list[int]						):






							"""simple docstring"""



							_lowerCAmelCase  	=			[]
							if len(SCREAMING_SNAKE_CASE						) == 1:
														return [nums.copy()]
							for _ in range(len(SCREAMING_SNAKE_CASE						)						):
														_lowerCAmelCase  	=			nums.pop(0						)
														_lowerCAmelCase  	=			permute(SCREAMING_SNAKE_CASE						)
														for perm in permutations:
																					perm.append(SCREAMING_SNAKE_CASE						)
														result.extend(SCREAMING_SNAKE_CASE						)
														nums.append(SCREAMING_SNAKE_CASE						)
							return result






def 	__snake_case  (    SCREAMING_SNAKE_CASE:					Any						):






							"""simple docstring"""



							def backtrack(SCREAMING_SNAKE_CASE:					Tuple						):
														if start == len(SCREAMING_SNAKE_CASE						) - 1:
																					output.append(nums[:]						)
														else:
																					for i in range(SCREAMING_SNAKE_CASE     ,  len(SCREAMING_SNAKE_CASE						)						):
																												_lowerCAmelCase	,		_lowerCAmelCase  	=			nums[i], nums[start]
																												backtrack(start + 1						)
																												_lowerCAmelCase	,		_lowerCAmelCase  	=			nums[i], nums[start]  # backtrack

							_lowerCAmelCase  	=			[]
							backtrack(0						)
							return output


if __name__ == "__main__":
	import doctest

	# use res to print the data in permute2 function
	_snake_case          =						permutea([1, 2, 3])
	print(res)
	doctest.testmod()






