



'''simple docstring'''



import tempfile
import unittest

import transformers
from transformers import XGLMConfig, XGLMTokenizer, is_flax_available, is_torch_available
from transformers.testing_utils import is_pt_flax_cross_test, require_flax, require_sentencepiece, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_flax_available():
				import jax
				import jax.numpy as jnp
				import numpy as np

				from transformers.modeling_flax_pytorch_utils import (
				    convert_pytorch_state_dict_to_flax,
				    load_flax_weights_in_pytorch_model,
				)
				from transformers.models.xglm.modeling_flax_xglm import FlaxXGLMForCausalLM, FlaxXGLMModel


if is_torch_available():
				import torch






@require_flax
class 			_SCREAMING_SNAKE_CASE				:



			def __init__(     self		:						Optional[int]    ,			__UpperCamelCase		:						List[str]    ,			__UpperCamelCase		:						int=14    ,			__UpperCamelCase		:						List[str]=7    ,			__UpperCamelCase		:						Tuple=True    ,			__UpperCamelCase		:						List[str]=True    ,			__UpperCamelCase		:						str=True    ,			__UpperCamelCase		:						Union[str, Any]=99    ,			__UpperCamelCase		:						Tuple=32    ,			__UpperCamelCase		:						Union[str, Any]=5    ,			__UpperCamelCase		:						Tuple=4    ,			__UpperCamelCase		:						Optional[int]=37    ,			__UpperCamelCase		:						Tuple="gelu"    ,			__UpperCamelCase		:						str=0.1    ,			__UpperCamelCase		:						Dict=0.1    ,			__UpperCamelCase		:						Any=512    ,			__UpperCamelCase		:						List[str]=0.02    ,			__UpperCamelCase		:						Dict=None    ,			)      ->      Tuple:
							"""simple docstring"""





							snake_case__      :   List[str]      =    parent
							snake_case__      :   Tuple      =    batch_size
							snake_case__      :   List[str]      =    seq_length
							snake_case__      :   str      =    is_training
							snake_case__      :   Optional[Any]      =    use_input_mask
							snake_case__      :   str      =    use_labels
							snake_case__      :   int      =    vocab_size
							snake_case__      :   Optional[int]      =    d_model
							snake_case__      :   Union[str, Any]      =    num_hidden_layers
							snake_case__      :   Any      =    num_attention_heads
							snake_case__      :   List[Any]      =    ffn_dim
							snake_case__      :   Tuple      =    activation_function
							snake_case__      :   int      =    activation_dropout
							snake_case__      :   Optional[Any]      =    attention_dropout
							snake_case__      :   Tuple      =    max_position_embeddings
							snake_case__      :   Optional[int]      =    initializer_range
							snake_case__      :   Tuple      =    None
							snake_case__      :   Optional[int]      =    0
							snake_case__      :   str      =    2
							snake_case__      :   List[str]      =    1



			def 				lowerCAmelCase (     self		:						Optional[int]			)      ->      Union[str, Any]:
							"""simple docstring"""





							snake_case__      :   Dict      =    np.clip(ids_tensor([self.batch_size, self.seq_length]    ,			self.vocab_size			)    ,			3    ,			self.vocab_size			)

							snake_case__      :   Union[str, Any]      =    None
							if self.use_input_mask:
											snake_case__      :   int      =    random_attention_mask([self.batch_size, self.seq_length]			)

							snake_case__      :   List[Any]      =    XGLMConfig(
							    vocab_size=self.vocab_size    ,			d_model=self.hidden_size    ,			num_layers=self.num_hidden_layers    ,			attention_heads=self.num_attention_heads    ,			ffn_dim=self.ffn_dim    ,			activation_function=self.activation_function    ,			activation_dropout=self.activation_dropout    ,			attention_dropout=self.attention_dropout    ,			max_position_embeddings=self.max_position_embeddings    ,			initializer_range=self.initializer_range    ,			use_cache=__UpperCamelCase    ,			bos_token_id=self.bos_token_id    ,			eos_token_id=self.eos_token_id    ,			pad_token_id=self.pad_token_id    ,			)

							return (config, input_ids, input_mask)



			def 				lowerCAmelCase (     self		:						List[str]			)      ->      str:
							"""simple docstring"""





							snake_case__      :   Optional[Any]      =    self.prepare_config_and_inputs()
							snake_case__  ,      snake_case__  ,      snake_case__      :   int      =    config_and_inputs
							snake_case__      :   str      =    {'''input_ids''': input_ids, '''attention_mask''': attention_mask}
							return config, inputs_dict



			def 				lowerCAmelCase (     self		:						Optional[int]			)      ->      Dict:
							"""simple docstring"""





							snake_case__  ,      snake_case__  ,      snake_case__      :   Optional[Any]      =    self.prepare_config_and_inputs()

							snake_case__      :   str      =    floats_tensor([self.batch_size, self.seq_length, self.hidden_size]			)
							snake_case__      :   Dict      =    ids_tensor([self.batch_size, self.seq_length]    ,			vocab_size=2			)

							return (
							    config,
							    input_ids,
							    attention_mask,
							    encoder_hidden_states,
							    encoder_attention_mask,
							)



			def 				lowerCAmelCase (     self		:						Tuple    ,			__UpperCamelCase		:						Tuple    ,			__UpperCamelCase		:						Optional[int]    ,			__UpperCamelCase		:						Optional[Any]    ,			__UpperCamelCase		:						Union[str, Any]			)      ->      str:
							"""simple docstring"""





							snake_case__      :   Tuple      =    20
							snake_case__      :   Any      =    model_class_name(__UpperCamelCase			)

							snake_case__      :   List[str]      =    model.init_cache(input_ids.shape[0]    ,			__UpperCamelCase			)
							snake_case__      :   str      =    jnp.ones((input_ids.shape[0], max_decoder_length)    ,			dtype='''i4'''			)

							snake_case__      :   Any      =    jnp.broadcast_to(
							    jnp.arange(input_ids.shape[-1] - 1			)[None, :]    ,			(input_ids.shape[0], input_ids.shape[-1] - 1)			)
							snake_case__      :   Optional[int]      =    model(
							    input_ids[:, :-1]    ,			attention_mask=__UpperCamelCase    ,			past_key_values=__UpperCamelCase    ,			position_ids=__UpperCamelCase    ,			)

							snake_case__      :   Tuple      =    jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]    ,			dtype='''i4'''			)
							snake_case__      :   Tuple      =    model(
							    input_ids[:, -1:]    ,			attention_mask=__UpperCamelCase    ,			past_key_values=outputs_cache.past_key_values    ,			position_ids=__UpperCamelCase    ,			)

							snake_case__      :   List[Any]      =    model(__UpperCamelCase			)

							snake_case__      :   List[str]      =    np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])			)			)
							self.parent.assertTrue(diff < 1e-3    ,			msg=F'''Max diff is {diff}'''			)







			def 				lowerCAmelCase (     self		:						List[str]    ,			__UpperCamelCase		:						Dict    ,			__UpperCamelCase		:						str    ,			__UpperCamelCase		:						Optional[Any]    ,			__UpperCamelCase		:						List[Any]			)      ->      Union[str, Any]:
							"""simple docstring"""





							snake_case__      :   Optional[Any]      =    20
							snake_case__      :   List[Any]      =    model_class_name(__UpperCamelCase			)

							snake_case__      :   Dict      =    jnp.concatenate(
							    [attention_mask, jnp.zeros((attention_mask.shape[0], max_decoder_length - attention_mask.shape[1])			)]    ,			axis=-1    ,			)

							snake_case__      :   Any      =    model.init_cache(input_ids.shape[0]    ,			__UpperCamelCase			)
							snake_case__      :   Union[str, Any]      =    jnp.broadcast_to(
							    jnp.arange(input_ids.shape[-1] - 1			)[None, :]    ,			(input_ids.shape[0], input_ids.shape[-1] - 1)			)

							snake_case__      :   Any      =    model(
							    input_ids[:, :-1]    ,			attention_mask=__UpperCamelCase    ,			past_key_values=__UpperCamelCase    ,			position_ids=__UpperCamelCase    ,			)
							snake_case__      :   Union[str, Any]      =    jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]    ,			dtype='''i4'''			)
							snake_case__      :   List[Any]      =    model(
							    input_ids[:, -1:]    ,			past_key_values=outputs_cache.past_key_values    ,			attention_mask=__UpperCamelCase    ,			position_ids=__UpperCamelCase    ,			)

							snake_case__      :   str      =    model(__UpperCamelCase    ,			attention_mask=__UpperCamelCase			)
							snake_case__      :   Any      =    np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])			)			)
							self.parent.assertTrue(diff < 1e-3    ,			msg=F'''Max diff is {diff}'''			)






@require_sentencepiece
@require_flax
class 			_SCREAMING_SNAKE_CASE				(lowercase__,	lowercase__,	unittest.TestCase      ):
			A__								=  (FlaxXGLMModel, FlaxXGLMForCausalLM) if is_flax_available() else ()
			A__								=  (FlaxXGLMForCausalLM,) if is_flax_available() else ()



			def 				lowerCAmelCase (     self		:						Optional[int]			)      ->      List[str]:
							"""simple docstring"""





							snake_case__      :   str      =    FlaxXGLMModelTester(self			)



			def 				lowerCAmelCase (     self		:						Any			)      ->      str:
							"""simple docstring"""





							for model_class_name in self.all_model_classes:
											snake_case__  ,      snake_case__  ,      snake_case__      :   List[str]      =    self.model_tester.prepare_config_and_inputs()
											self.model_tester.check_use_cache_forward(__UpperCamelCase    ,			__UpperCamelCase    ,			__UpperCamelCase    ,			__UpperCamelCase			)



			def 				lowerCAmelCase (     self		:						List[Any]			)      ->      List[Any]:
							"""simple docstring"""





							for model_class_name in self.all_model_classes:
											snake_case__  ,      snake_case__  ,      snake_case__      :   List[str]      =    self.model_tester.prepare_config_and_inputs()
											self.model_tester.check_use_cache_forward_with_attn_mask(
											    __UpperCamelCase    ,			__UpperCamelCase    ,			__UpperCamelCase    ,			__UpperCamelCase			)



			@slow
			def 				lowerCAmelCase (     self		:						str			)      ->      Any:
							"""simple docstring"""





							snake_case__      :   str      =    XGLMTokenizer.from_pretrained('''XGLM'''    ,			padding_side='''left'''			)
							snake_case__      :   Dict      =    tokenizer(['''Hello this is a long string''', '''Hey''']    ,			return_tensors='''np'''    ,			padding=__UpperCamelCase    ,			truncation=__UpperCamelCase			)

							snake_case__      :   Optional[int]      =    FlaxXGLMForCausalLM.from_pretrained('''facebook/xglm-564M'''			)
							snake_case__      :   Any      =    1
							snake_case__      :   Optional[int]      =    False

							snake_case__      :   Dict      =    jax.jit(model.generate			)

							snake_case__      :   int      =    jit_generate(inputs['''input_ids''']    ,			attention_mask=inputs['''attention_mask''']			).sequences

							snake_case__      :   int      =    tokenizer.batch_decode(__UpperCamelCase    ,			skip_special_tokens=__UpperCamelCase			)

							snake_case__      :   Any      =    [
							    '''Hello this is a long string of questions, but I\'m not sure if I\'m''',
							    '''Hey, I\'m a newbie to the forum and I\'''',
							]

							self.assertListEqual(__UpperCamelCase    ,			__UpperCamelCase			)



			@is_pt_flax_cross_test
			def 				lowerCAmelCase (     self		:						Optional[Any]			)      ->      str:
							"""simple docstring"""





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

							for model_class in self.all_model_classes:
											with self.subTest(model_class.__name__			):
															# prepare inputs
															snake_case__      :   Any      =    self._prepare_for_class(__UpperCamelCase    ,			__UpperCamelCase			)
															snake_case__      :   Any      =    {k: torch.tensor(v.tolist()			) for k, v in prepared_inputs_dict.items()}

															# load corresponding PyTorch class
															snake_case__      :   List[Any]      =    model_class.__name__[4:]  # Skip the "Flax" at the beginning
															snake_case__      :   Any      =    getattr(__UpperCamelCase    ,			__UpperCamelCase			)

															snake_case__  ,      snake_case__      :   Tuple      =    pt_inputs['''input_ids'''].shape
															snake_case__      :   List[Any]      =    np.random.randint(0    ,			seq_length - 1    ,			size=(batch_size,)			)
															for batch_idx, start_index in enumerate(__UpperCamelCase			):
																			snake_case__      :   Dict      =    0
																			snake_case__      :   Optional[int]      =    1
																			snake_case__      :   Any      =    0
																			snake_case__      :   Dict      =    1
															snake_case__      :   str      =    pt_model_class(__UpperCamelCase			).eval()
															# Flax models don't use the `use_cache` option and cache is not returned as a default.
															# So we disable `use_cache` here for PyTorch model.
															snake_case__      :   Optional[int]      =    False
															snake_case__      :   List[Any]      =    model_class(__UpperCamelCase    ,			dtype=jnp.floataa			)
															snake_case__      :   Optional[int]      =    convert_pytorch_state_dict_to_flax(pt_model.state_dict()    ,			__UpperCamelCase			)
															snake_case__      :   Any      =    fx_state

															with torch.no_grad():
																			snake_case__      :   Dict      =    pt_model(**__UpperCamelCase			).to_tuple()

															snake_case__      :   Any      =    fx_model(**__UpperCamelCase			).to_tuple()
															self.assertEqual(len(__UpperCamelCase			)    ,			len(__UpperCamelCase			)    ,			'''Output lengths differ between Flax and PyTorch'''			)
															for fx_output, pt_output in zip(__UpperCamelCase    ,			__UpperCamelCase			):
																			self.assert_almost_equals(fx_output[:, -1]    ,			pt_output[:, -1].numpy()    ,			4e-2			)

															with tempfile.TemporaryDirectory() as tmpdirname:
																			pt_model.save_pretrained(__UpperCamelCase			)
																			snake_case__      :   List[Any]      =    model_class.from_pretrained(__UpperCamelCase    ,			from_pt=__UpperCamelCase			)

															snake_case__      :   str      =    fx_model_loaded(**__UpperCamelCase			).to_tuple()
															self.assertEqual(
															    len(__UpperCamelCase			)    ,			len(__UpperCamelCase			)    ,			'''Output lengths differ between Flax and PyTorch'''			)
															for fx_output_loaded, pt_output in zip(__UpperCamelCase    ,			__UpperCamelCase			):
																			self.assert_almost_equals(fx_output_loaded[:, -1]    ,			pt_output[:, -1].numpy()    ,			4e-2			)



			@is_pt_flax_cross_test
			def 				lowerCAmelCase (     self		:						Optional[Any]			)      ->      Tuple:
							"""simple docstring"""





							snake_case__  ,      snake_case__      :   str      =    self.model_tester.prepare_config_and_inputs_for_common()
							for model_class in self.all_model_classes:
											with self.subTest(model_class.__name__			):
															# prepare inputs
															snake_case__      :   str      =    self._prepare_for_class(__UpperCamelCase    ,			__UpperCamelCase			)
															snake_case__      :   Dict      =    {k: torch.tensor(v.tolist()			) for k, v in prepared_inputs_dict.items()}

															# load corresponding PyTorch class
															snake_case__      :   Tuple      =    model_class.__name__[4:]  # Skip the "Flax" at the beginning
															snake_case__      :   Tuple      =    getattr(__UpperCamelCase    ,			__UpperCamelCase			)

															snake_case__      :   Optional[Any]      =    pt_model_class(__UpperCamelCase			).eval()
															snake_case__      :   Optional[int]      =    False
															snake_case__      :   Optional[Any]      =    model_class(__UpperCamelCase    ,			dtype=jnp.floataa			)

															snake_case__      :   Any      =    load_flax_weights_in_pytorch_model(__UpperCamelCase    ,			fx_model.params			)
															snake_case__  ,      snake_case__      :   List[Any]      =    pt_inputs['''input_ids'''].shape
															snake_case__      :   Optional[Any]      =    np.random.randint(0    ,			seq_length - 1    ,			size=(batch_size,)			)
															for batch_idx, start_index in enumerate(__UpperCamelCase			):
																			snake_case__      :   Union[str, Any]      =    0
																			snake_case__      :   Optional[int]      =    1
																			snake_case__      :   int      =    0
																			snake_case__      :   Any      =    1

															# make sure weights are tied in PyTorch
															pt_model.tie_weights()

															with torch.no_grad():
																			snake_case__      :   Any      =    pt_model(**__UpperCamelCase			).to_tuple()

															snake_case__      :   str      =    fx_model(**__UpperCamelCase			).to_tuple()
															self.assertEqual(len(__UpperCamelCase			)    ,			len(__UpperCamelCase			)    ,			'''Output lengths differ between Flax and PyTorch'''			)
															for fx_output, pt_output in zip(__UpperCamelCase    ,			__UpperCamelCase			):
																			self.assert_almost_equals(fx_output[:, -1]    ,			pt_output[:, -1].numpy()    ,			4e-2			)

															with tempfile.TemporaryDirectory() as tmpdirname:
																			fx_model.save_pretrained(__UpperCamelCase			)
																			snake_case__      :   str      =    pt_model_class.from_pretrained(__UpperCamelCase    ,			from_flax=__UpperCamelCase			)

															with torch.no_grad():
																			snake_case__      :   Optional[int]      =    pt_model_loaded(**__UpperCamelCase			).to_tuple()

															self.assertEqual(
															    len(__UpperCamelCase			)    ,			len(__UpperCamelCase			)    ,			'''Output lengths differ between Flax and PyTorch'''			)
															for fx_output, pt_output in zip(__UpperCamelCase    ,			__UpperCamelCase			):
																			self.assert_almost_equals(fx_output[:, -1]    ,			pt_output[:, -1].numpy()    ,			4e-2			)







			@slow
			def 				lowerCAmelCase (     self		:						Optional[int]			)      ->      List[Any]:
							"""simple docstring"""





							for model_class_name in self.all_model_classes:
											snake_case__      :   Optional[int]      =    model_class_name.from_pretrained('''facebook/xglm-564M'''			)
											snake_case__      :   List[str]      =    model(np.ones((1, 1)			)			)
											self.assertIsNotNone(__UpperCamelCase			)











from __future__ import annotations




def 			lowerCAmelCase_			(				UpperCamelCase_	)  ->		int | None:
       for r in range(1       ,		UpperCamelCase_	):
              UpperCamelCase_ 							=	[]
              for x in range(n - 1	):
                     UpperCamelCase_ 							=	pow(UpperCamelCase_       ,		UpperCamelCase_       ,		UpperCamelCase_	)
                     if val in li:
                            break
                     li.append(UpperCamelCase_	)
              else:
                     return r
       return None


if __name__ == "__main__":
     _UpperCAmelCase										=					int(input('Enter a prime number q: '))
     _UpperCAmelCase										=					find_primitive(q)
     if a is None:
          print(f'''Cannot find the primitive for the value: {a!r}''')
     else:
          _UpperCAmelCase										=					int(input('Enter private key of A: '))
          _UpperCAmelCase										=					pow(a, a_private, q)
          _UpperCAmelCase										=					int(input('Enter private key of B: '))
          _UpperCAmelCase										=					pow(a, b_private, q)

          _UpperCAmelCase										=					pow(b_public, a_private, q)
          _UpperCAmelCase										=					pow(a_public, b_private, q)

          print('The key value generated by A is: ', a_secret)
          print('The key value generated by B is: ', b_secret)

