


import unittest
from unittest.util import safe_repr

from transformers import AutoTokenizer, RwkvConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch

		from transformers import (
		    RWKV_PRETRAINED_MODEL_ARCHIVE_LIST,
		    RwkvForCausalLM,
		    RwkvModel,
		)
		from transformers.pytorch_utils import is_torch_greater_or_equal_than_2_0
else:
		lowerCamelCase		=						False





class    _a				:




	def __init__(   self		:						List[Any]						,   _SCREAMING_SNAKE_CASE		:						Dict						,   _SCREAMING_SNAKE_CASE		:						List[str]=14						,   _SCREAMING_SNAKE_CASE		:						List[Any]=7						,   _SCREAMING_SNAKE_CASE		:						Optional[int]=True						,   _SCREAMING_SNAKE_CASE		:						Optional[Any]=False						,   _SCREAMING_SNAKE_CASE		:						Optional[Any]=True						,   _SCREAMING_SNAKE_CASE		:						Dict=True						,   _SCREAMING_SNAKE_CASE		:						List[str]=True						,   _SCREAMING_SNAKE_CASE		:						Union[str, Any]=99						,   _SCREAMING_SNAKE_CASE		:						Tuple=32						,   _SCREAMING_SNAKE_CASE		:						int=5						,   _SCREAMING_SNAKE_CASE		:						str=37						,   _SCREAMING_SNAKE_CASE		:						List[Any]="gelu"						,   _SCREAMING_SNAKE_CASE		:						List[Any]=0.1						,   _SCREAMING_SNAKE_CASE		:						Tuple=0.1						,   _SCREAMING_SNAKE_CASE		:						Any=512						,   _SCREAMING_SNAKE_CASE		:						Tuple=16						,   _SCREAMING_SNAKE_CASE		:						List[Any]=2						,   _SCREAMING_SNAKE_CASE		:						str=3						,   _SCREAMING_SNAKE_CASE		:						Union[str, Any]=4						,   _SCREAMING_SNAKE_CASE		:						int=None						,   )->			List[str]:
			lowerCAmelCase__  :     str       	=   parent
			lowerCAmelCase__  :     int       	=   batch_size
			lowerCAmelCase__  :     Dict       	=   seq_length
			lowerCAmelCase__  :     Dict       	=   is_training
			lowerCAmelCase__  :     Optional[Any]       	=   use_token_type_ids
			lowerCAmelCase__  :     str       	=   use_input_mask
			lowerCAmelCase__  :     List[str]       	=   use_labels
			lowerCAmelCase__  :     Optional[int]       	=   use_mc_token_ids
			lowerCAmelCase__  :     Dict       	=   vocab_size
			lowerCAmelCase__  :     List[Any]       	=   hidden_size
			lowerCAmelCase__  :     Union[str, Any]       	=   num_hidden_layers
			lowerCAmelCase__  :     List[Any]       	=   intermediate_size
			lowerCAmelCase__  :     Any       	=   hidden_act
			lowerCAmelCase__  :     Dict       	=   hidden_dropout_prob
			lowerCAmelCase__  :     Dict       	=   attention_probs_dropout_prob
			lowerCAmelCase__  :     Any       	=   max_position_embeddings
			lowerCAmelCase__  :     List[Any]       	=   type_vocab_size
			lowerCAmelCase__  :     List[Any]       	=   type_sequence_label_size
			lowerCAmelCase__  :     int       	=   num_labels
			lowerCAmelCase__  :     Tuple       	=   num_choices
			lowerCAmelCase__  :     Union[str, Any]       	=   scope
			lowerCAmelCase__  :     Any       	=   vocab_size - 1
			lowerCAmelCase__  :     str       	=   vocab_size - 1
			lowerCAmelCase__  :     Tuple       	=   vocab_size - 1




	def 				UpperCAmelCase__(   self		:						Optional[Any]						)->			int:
			return RwkvConfig.from_pretrained('''sgugger/rwkv-4-pile-7b'''						)




	def 				UpperCAmelCase__(   self		:						str						,   _SCREAMING_SNAKE_CASE		:						Tuple=False						,   _SCREAMING_SNAKE_CASE		:						List[Any]=False						,   _SCREAMING_SNAKE_CASE		:						Optional[int]=False						)->			Optional[int]:
			lowerCAmelCase__  :     Optional[int]       	=   ids_tensor([self.batch_size, self.seq_length]						,   self.vocab_size						)

			lowerCAmelCase__  :     Tuple       	=   None
			if self.use_input_mask:
					lowerCAmelCase__  :     Any       	=   random_attention_mask([self.batch_size, self.seq_length]						)

			lowerCAmelCase__  :     Union[str, Any]       	=   None
			if self.use_token_type_ids:
					lowerCAmelCase__  :     Optional[int]       	=   ids_tensor([self.batch_size, self.seq_length]						,   self.type_vocab_size						)

			lowerCAmelCase__  :     Dict       	=   None
			if self.use_mc_token_ids:
					lowerCAmelCase__  :     Optional[Any]       	=   ids_tensor([self.batch_size, self.num_choices]						,   self.seq_length						)

			lowerCAmelCase__  :     str       	=   None
			lowerCAmelCase__  :     int       	=   None
			lowerCAmelCase__  :     Optional[Any]       	=   None
			if self.use_labels:
					lowerCAmelCase__  :     Optional[Any]       	=   ids_tensor([self.batch_size]						,   self.type_sequence_label_size						)
					lowerCAmelCase__  :     Optional[int]       	=   ids_tensor([self.batch_size, self.seq_length]						,   self.num_labels						)
					lowerCAmelCase__  :     Optional[Any]       	=   ids_tensor([self.batch_size]						,   self.num_choices						)

			lowerCAmelCase__  :     Union[str, Any]       	=   self.get_config(
			    gradient_checkpointing=A_						,   scale_attn_by_inverse_layer_idx=A_						,   reorder_and_upcast_attn=A_						,   )

			return (
			    config,
			    input_ids,
			    input_mask,
			    None,
			    token_type_ids,
			    mc_token_ids,
			    sequence_labels,
			    token_labels,
			    choice_labels,
			)




	def 				UpperCAmelCase__(   self		:						Optional[int]						,   _SCREAMING_SNAKE_CASE		:						List[Any]=False						,   _SCREAMING_SNAKE_CASE		:						Tuple=False						,   _SCREAMING_SNAKE_CASE		:						int=False						)->			str:
			return RwkvConfig(
			    vocab_size=self.vocab_size						,   hidden_size=self.hidden_size						,   num_hidden_layers=self.num_hidden_layers						,   intermediate_size=self.intermediate_size						,   activation_function=self.hidden_act						,   resid_pdrop=self.hidden_dropout_prob						,   attn_pdrop=self.attention_probs_dropout_prob						,   n_positions=self.max_position_embeddings						,   type_vocab_size=self.type_vocab_size						,   use_cache=A_						,   bos_token_id=self.bos_token_id						,   eos_token_id=self.eos_token_id						,   pad_token_id=self.pad_token_id						,   gradient_checkpointing=A_						,   scale_attn_by_inverse_layer_idx=A_						,   reorder_and_upcast_attn=A_						,   )




	def 				UpperCAmelCase__(   self		:						Any						)->			List[Any]:
			lowerCAmelCase__  :     Tuple       	=   self.get_config()
			lowerCAmelCase__  :     Dict       	=   300
			return config




	def 				UpperCAmelCase__(   self		:						List[str]						)->			Union[str, Any]:
			(
			    (
			    lowerCAmelCase__     
			)	,      (
			    lowerCAmelCase__     
			)	,      (
			    lowerCAmelCase__     
			)	,      (
			    lowerCAmelCase__     
			)	,      (
			    lowerCAmelCase__     
			)	,      (
			    lowerCAmelCase__     
			)	,      (
			    lowerCAmelCase__     
			)	,      (
			    lowerCAmelCase__     
			)	,      (
			    lowerCAmelCase__     
			)	,           
			)  :     Optional[Any]       	=   self.prepare_config_and_inputs()

			lowerCAmelCase__  :     List[Any]       	=   floats_tensor([self.batch_size, self.seq_length, self.hidden_size]						)
			lowerCAmelCase__  :     int       	=   ids_tensor([self.batch_size, self.seq_length]						,   vocab_size=2						)

			return (
			    config,
			    input_ids,
			    input_mask,
			    head_mask,
			    token_type_ids,
			    sequence_labels,
			    token_labels,
			    choice_labels,
			    encoder_hidden_states,
			    encoder_attention_mask,
			)




	def 				UpperCAmelCase__(   self		:						Any						,   _SCREAMING_SNAKE_CASE		:						str						,   _SCREAMING_SNAKE_CASE		:						Any						,   _SCREAMING_SNAKE_CASE		:						Tuple						,   _SCREAMING_SNAKE_CASE		:						List[Any]						,   _SCREAMING_SNAKE_CASE		:						List[Any]						,   *_SCREAMING_SNAKE_CASE		:						List[str]						)->			Any:
			lowerCAmelCase__  :     Optional[int]       	=   True
			lowerCAmelCase__  :     Union[str, Any]       	=   RwkvModel(config=A_						)
			model.to(A_						)
			model.eval()

			lowerCAmelCase__  :     str       	=   model(A_						)

			self.parent.assertEqual(result.last_hidden_state.shape						,   (self.batch_size, self.seq_length, self.hidden_size)						)
			self.parent.assertEqual(len(result.hidden_states						)						,   config.num_hidden_layers + 1						)




	def 				UpperCAmelCase__(   self		:						Tuple						,   _SCREAMING_SNAKE_CASE		:						Any						,   _SCREAMING_SNAKE_CASE		:						str						,   _SCREAMING_SNAKE_CASE		:						Optional[Any]						,   _SCREAMING_SNAKE_CASE		:						Optional[int]						,   _SCREAMING_SNAKE_CASE		:						Dict						,   *_SCREAMING_SNAKE_CASE		:						str						)->			List[Any]:
			lowerCAmelCase__  :     List[Any]       	=   RwkvForCausalLM(A_						)
			model.to(A_						)
			model.eval()

			lowerCAmelCase__  :     List[Any]       	=   model(A_						,   labels=A_						)
			self.parent.assertEqual(result.loss.shape						,   ()						)
			self.parent.assertEqual(result.logits.shape						,   (self.batch_size, self.seq_length, self.vocab_size)						)




	def 				UpperCAmelCase__(   self		:						Optional[int]						,   _SCREAMING_SNAKE_CASE		:						Any						,   _SCREAMING_SNAKE_CASE		:						List[str]						,   _SCREAMING_SNAKE_CASE		:						List[str]						,   _SCREAMING_SNAKE_CASE		:						Tuple						,   _SCREAMING_SNAKE_CASE		:						Optional[int]						,   *_SCREAMING_SNAKE_CASE		:						str						)->			Any:
			lowerCAmelCase__  :     List[str]       	=   RwkvModel(config=A_						)
			model.to(A_						)
			model.eval()

			lowerCAmelCase__  :     str       	=   model(A_						)
			lowerCAmelCase__  :     Any       	=   outputs.last_hidden_state

			lowerCAmelCase__  :     int       	=   model(input_ids[:, :2]						)
			lowerCAmelCase__  :     Union[str, Any]       	=   outputs.last_hidden_state

			# Using the state computed on the first inputs, we will get the same output
			lowerCAmelCase__  :     Optional[Any]       	=   model(input_ids[:, 2:]						,   state=outputs.state						)
			lowerCAmelCase__  :     Dict       	=   outputs.last_hidden_state

			self.parent.assertTrue(torch.allclose(torch.cat([output_one, output_two]						,   dim=1						)						,   A_						,   atol=1E-5						)						)




	def 				UpperCAmelCase__(   self		:						Optional[Any]						,   _SCREAMING_SNAKE_CASE		:						List[Any]						,   _SCREAMING_SNAKE_CASE		:						Union[str, Any]						,   _SCREAMING_SNAKE_CASE		:						int						,   _SCREAMING_SNAKE_CASE		:						Tuple						,   _SCREAMING_SNAKE_CASE		:						str						,   *_SCREAMING_SNAKE_CASE		:						Any						,   _SCREAMING_SNAKE_CASE		:						Tuple=False						)->			Tuple:
			lowerCAmelCase__  :     List[str]       	=   RwkvForCausalLM(A_						)
			model.to(A_						)
			if gradient_checkpointing:
					model.gradient_checkpointing_enable()

			lowerCAmelCase__  :     Optional[Any]       	=   model(A_						,   labels=A_						)
			self.parent.assertEqual(result.loss.shape						,   ()						)
			self.parent.assertEqual(result.logits.shape						,   (self.batch_size, self.seq_length, self.vocab_size)						)
			result.loss.backward()




	def 				UpperCAmelCase__(   self		:						Optional[int]						)->			Union[str, Any]:
			lowerCAmelCase__  :     int       	=   self.prepare_config_and_inputs()

			(
			    (
			    lowerCAmelCase__     
			)	,      (
			    lowerCAmelCase__     
			)	,      (
			    lowerCAmelCase__     
			)	,      (
			    lowerCAmelCase__     
			)	,      (
			    lowerCAmelCase__     
			)	,      (
			    lowerCAmelCase__     
			)	,      (
			    lowerCAmelCase__     
			)	,      (
			    lowerCAmelCase__     
			)	,      (
			    lowerCAmelCase__     
			)	,           
			)  :     Optional[int]       	=   config_and_inputs

			lowerCAmelCase__  :     Tuple       	=   {'''input_ids''': input_ids}

			return config, inputs_dict





@unittest.skipIf(
    not is_torch_greater_or_equal_than_2_0	,		reason='''See https://github.com/huggingface/transformers/pull/24204''')
@require_torch
class    _a				(							__A	,		__A	,		__A	,		unittest.TestCase):
	_a    :    Tuple        =				(RwkvModel, RwkvForCausalLM) if is_torch_available() else ()
	_a    :    Optional[Any]        =				(
	    {'''feature-extraction''': RwkvModel, '''text-generation''': RwkvForCausalLM} if is_torch_available() else {}
	)
	# all_generative_model_classes = (RwkvForCausalLM,) if is_torch_available() else ()
	_a    :    Any        =				False
	_a    :    Tuple        =				False
	_a    :    List[str]        =				False
	_a    :    List[Any]        =				False
	_a    :    Union[str, Any]        =				False  # Rwkv does not support head masking




	def 				UpperCAmelCase__(   self		:						List[Any]						)->			Tuple:
			lowerCAmelCase__  :     Optional[int]       	=   RwkvModelTester(self						)
			lowerCAmelCase__  :     Dict       	=   ConfigTester(
			    self						,   config_class=A_						,   n_embd=37						,   common_properties=['''hidden_size''', '''num_hidden_layers''']						)




	def 				UpperCAmelCase__(   self		:						str						,   _SCREAMING_SNAKE_CASE		:						Dict						,   _SCREAMING_SNAKE_CASE		:						Optional[Any]						,   _SCREAMING_SNAKE_CASE		:						List[Any]=None						)->			int:



			if isinstance(A_						,   torch.Tensor						):
					lowerCAmelCase__	,      lowerCAmelCase__  :     List[str]       	=   member.max().item(), member.min().item()
			elif isinstance(A_						,   A_						) or isinstance(A_						,   A_						):
					lowerCAmelCase__	,      lowerCAmelCase__  :     Optional[int]       	=   max(A_						), min(A_						)

			if not isinstance(A_						,   A_						):
					raise TypeError('''container should be a list or tuple'''						)
			elif len(A_						) != 2:
					raise ValueError('''container should have 2 elements'''						)

			lowerCAmelCase__	,      lowerCAmelCase__  :     Optional[Any]       	=   container

			lowerCAmelCase__  :     Optional[Any]       	=   (min_value >= expected_min) and (max_value <= expected_max)

			if not is_inside_interval:
					lowerCAmelCase__  :     List[str]       	=   '''%s not found in %s''' % (safe_repr(A_						), safe_repr(A_						))
					self.fail(self._formatMessage(A_						,   A_						)						)




	def 				UpperCAmelCase__(   self		:						Tuple						)->			List[Any]:
			self.config_tester.run_common_tests()




	def 				UpperCAmelCase__(   self		:						List[Any]						)->			Optional[Any]:
			lowerCAmelCase__  :     Union[str, Any]       	=   self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_rwkv_model(*A_						)




	def 				UpperCAmelCase__(   self		:						List[str]						)->			int:
			lowerCAmelCase__  :     Optional[Any]       	=   self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_causl_lm(*A_						)




	def 				UpperCAmelCase__(   self		:						List[Any]						)->			List[Any]:
			lowerCAmelCase__  :     List[str]       	=   self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_state_equivalency(*A_						)




	def 				UpperCAmelCase__(   self		:						Optional[int]						)->			Optional[Any]:
			lowerCAmelCase__	,      lowerCAmelCase__  :     int       	=   self.model_tester.prepare_config_and_inputs_for_common()

			for model_class in self.all_model_classes:
					lowerCAmelCase__  :     List[str]       	=   model_class(config=A_						)
					for name, param in model.named_parameters():
							if "time_decay" in name:
									if param.requires_grad:
											self.assertTrue(param.data.max().item() == 3.0						)
											self.assertTrue(param.data.min().item() == -5.0						)
							elif "time_first" in name:
									if param.requires_grad:
											# check if it's a ones like
											self.assertTrue(torch.allclose(param.data						,   torch.ones_like(param.data						)						,   atol=1E-5						,   rtol=1E-5						)						)
							elif any(x in name for x in ['''time_mix_key''', '''time_mix_receptance''']						):
									if param.requires_grad:
											self.assertInterval(
											    param.data						,   [0.0, 1.0]						,   msg=F'Parameter {name} of model {model_class} seems not properly initialized'						,   )
							elif "time_mix_value" in name:
									if param.requires_grad:
											self.assertInterval(
											    param.data						,   [0.0, 1.3]						,   msg=F'Parameter {name} of model {model_class} seems not properly initialized'						,   )




	def 				UpperCAmelCase__(   self		:						List[Any]						)->			str:
			lowerCAmelCase__	,      lowerCAmelCase__  :     int       	=   self.model_tester.prepare_config_and_inputs_for_common()
			lowerCAmelCase__  :     Union[str, Any]       	=   True

			lowerCAmelCase__  :     Optional[Any]       	=   getattr(self.model_tester						,   '''seq_length'''						,   A_						)

			for model_class in self.all_model_classes:
					lowerCAmelCase__  :     Optional[Any]       	=   True
					lowerCAmelCase__  :     int       	=   False
					lowerCAmelCase__  :     Union[str, Any]       	=   True
					lowerCAmelCase__  :     Dict       	=   model_class(A_						)
					model.to(A_						)
					model.eval()

					lowerCAmelCase__  :     List[str]       	=   self._prepare_for_class(A_						,   A_						)
					lowerCAmelCase__  :     Tuple       	=   inputs['''input_ids'''].shape[0]
					with torch.no_grad():
							lowerCAmelCase__  :     Optional[int]       	=   model(**A_						)
					lowerCAmelCase__  :     Dict       	=   outputs.attentions
					self.assertEqual(len(A_						)						,   self.model_tester.num_hidden_layers						)

					# check that output_attentions also work using config
					del inputs_dict["output_attentions"]
					lowerCAmelCase__  :     List[Any]       	=   True
					lowerCAmelCase__  :     List[Any]       	=   model_class(A_						)
					model.to(A_						)
					model.eval()

					lowerCAmelCase__  :     str       	=   self._prepare_for_class(A_						,   A_						)
					lowerCAmelCase__  :     Optional[Any]       	=   inputs['''input_ids'''].shape[0]
					with torch.no_grad():
							lowerCAmelCase__  :     Dict       	=   model(**A_						)
					lowerCAmelCase__  :     Union[str, Any]       	=   outputs.attentions
					self.assertEqual(len(A_						)						,   self.model_tester.num_hidden_layers						)

					self.assertListEqual(
					    list(attentions[0].shape[-3:]						)						,   [batch_size, seq_len, config.hidden_size]						,   )
					lowerCAmelCase__  :     Dict       	=   len(A_						)

					# Check attention is always last and order is fine
					lowerCAmelCase__  :     Optional[int]       	=   True
					lowerCAmelCase__  :     Any       	=   True
					lowerCAmelCase__  :     Optional[int]       	=   model_class(A_						)
					model.to(A_						)
					model.eval()

					lowerCAmelCase__  :     Dict       	=   self._prepare_for_class(A_						,   A_						)
					lowerCAmelCase__  :     Optional[Any]       	=   inputs['''input_ids'''].shape[0]
					with torch.no_grad():
							lowerCAmelCase__  :     Any       	=   model(**A_						)

					lowerCAmelCase__  :     int       	=   1
					self.assertEqual(out_len + added_hidden_states						,   len(A_						)						)

					lowerCAmelCase__  :     str       	=   outputs.attentions

					self.assertEqual(len(A_						)						,   self.model_tester.num_hidden_layers						)
					self.assertListEqual(
					    list(self_attentions[0].shape[-3:]						)						,   [batch_size, seq_len, config.hidden_size]						,   )




	@slow
	def 				UpperCAmelCase__(   self		:						int						)->			List[str]:



			for model_name in RWKV_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					lowerCAmelCase__  :     Dict       	=   RwkvModel.from_pretrained(A_						)
					self.assertIsNotNone(A_						)





@unittest.skipIf(
    not is_torch_greater_or_equal_than_2_0	,		reason='''See https://github.com/huggingface/transformers/pull/24204''')
@slow
class    _a				(							unittest.TestCase):




	def 				UpperCAmelCase__(   self		:						Optional[Any]						)->			List[Any]:
			lowerCAmelCase__  :     int       	=   '''RWKV/rwkv-4-169m-pile'''
			lowerCAmelCase__  :     List[Any]       	=   AutoTokenizer.from_pretrained(self.model_id						)




	def 				UpperCAmelCase__(   self		:						List[Any]						)->			List[Any]:
			lowerCAmelCase__  :     Optional[int]       	=   '''Hello my name is Jasmine and I am a newbie to the'''
			lowerCAmelCase__  :     Union[str, Any]       	=   RwkvForCausalLM.from_pretrained(self.model_id						).to(A_						)

			lowerCAmelCase__  :     List[Any]       	=   self.tokenizer('''Hello my name is'''						,   return_tensors='''pt'''						).input_ids.to(A_						)
			lowerCAmelCase__  :     str       	=   model.generate(A_						,   max_new_tokens=10						)
			lowerCAmelCase__  :     Optional[int]       	=   self.tokenizer.decode(output[0].tolist()						)

			self.assertEqual(A_						,   A_						)




	def 				UpperCAmelCase__(   self		:						Tuple						)->			Any:
			lowerCAmelCase__  :     Dict       	=   '''Hello my name is Jasmine and I am a newbie to the'''

			lowerCAmelCase__  :     Dict       	=   self.tokenizer('''Hello my name is'''						,   return_tensors='''pt'''						).input_ids.to(A_						)
			lowerCAmelCase__  :     Optional[int]       	=   RwkvForCausalLM.from_pretrained(self.model_id						,   torch_dtype=torch.bfloataa						).to(A_						)

			lowerCAmelCase__  :     str       	=   model.generate(A_						,   max_new_tokens=10						)
			lowerCAmelCase__  :     Optional[Any]       	=   self.tokenizer.decode(output[0].tolist()						)

			self.assertEqual(A_						,   A_						)









"""simple docstring"""






import math


def 							A__ (     UpperCamelCase__    ):


  '''simple docstring'''


  if not isinstance(UpperCamelCase__       ,							UpperCamelCase__    ):
    _SCREAMING_SNAKE_CASE        =			F'''Input value of [number={number}] must be an integer'''
    raise TypeError(UpperCamelCase__    )
  if number < 1:
    _SCREAMING_SNAKE_CASE        =			F'''Input value of [number={number}] must be a positive integer'''
    raise ValueError(UpperCamelCase__    )
  _SCREAMING_SNAKE_CASE        =			[number]
  while number != 1:
    if number % 2 == 0:
      _SCREAMING_SNAKE_CASE        =			math.floor(math.sqrt(UpperCamelCase__    )    )
    else:
      _SCREAMING_SNAKE_CASE        =			math.floor(
          math.sqrt(UpperCamelCase__    ) * math.sqrt(UpperCamelCase__    ) * math.sqrt(UpperCamelCase__    )    )
    sequence.append(UpperCamelCase__    )
  return sequence


if __name__ == "__main__":
    import doctest

    doctest.testmod()
