


'''simple docstring'''
def      a (     __a					,   __a = False  )    ->      bool:



					'''simple docstring'''






					if n == 2:
										return True
					if not n % 2 or n < 2:
										return False
					if n > 5 and n % 10 not in (1, 3, 7, 9):  # can quickly check last digit
										return False
					if n > 3317044064679887385961981 and not allow_probable:
										raise ValueError(
										    '''Warning: upper bound of deterministic test is exceeded. '''
										    '''Pass allow_probable=True to allow probabilistic test. '''
										    '''A return value of True indicates a probable prime.'''  )
					# array bounds provided by analysis
					UpperCamelCase__  :str				   =					[
					    2047,
					    1373653,
					    25326001,
					    3215031751,
					    2152302898747,
					    3474749660383,
					    341550071728321,
					    1,
					    3825123056546413051,
					    1,
					    1,
					    318665857834031151167461,
					    3317044064679887385961981,
					]

					UpperCamelCase__  :Union[str, Any]				   =					[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41]
					for idx, _p in enumerate(__a					,   1  ):
										if n < _p:
															# then we have our last prime to check
															UpperCamelCase__  :Tuple				   =					primes[:idx]
															break
					UpperCamelCase__   ,							UpperCamelCase__  :Tuple				   =					n - 1, 0
					# break up n -1 into a power of 2 (s) and
					# remaining odd component
					# essentially, solve for d * 2 ** s == n - 1
					while d % 2 == 0:
										d //= 2
										s += 1
					for prime in plist:
										UpperCamelCase__  :Any				   =					False
										for r in range(__a  ):
															UpperCamelCase__  :Tuple				   =					pow(__a					,   d * 2**r					,   __a  )
															# see article for analysis explanation for m
															if (r == 0 and m == 1) or ((m + 1) % n == 0):
																				UpperCamelCase__  :Union[str, Any]				   =					True
																				# this loop will not determine compositeness
																				break
										if pr:
															continue
										# if pr is False, then the above loop never evaluated to true,
										# and the n MUST be composite
										return False
					return True


def      a (     )    ->      None:



					'''simple docstring'''






					assert not miller_rabin(561  )
					assert miller_rabin(563  )
					# 2047

					assert not miller_rabin(838201  )
					assert miller_rabin(838207  )
					# 1_373_653

					assert not miller_rabin(17316001  )
					assert miller_rabin(17316017  )
					# 25_326_001

					assert not miller_rabin(3078386641  )
					assert miller_rabin(3078386653  )
					# 3_215_031_751

					assert not miller_rabin(1713045574801  )
					assert miller_rabin(1713045574819  )
					# 2_152_302_898_747

					assert not miller_rabin(2779799728307  )
					assert miller_rabin(2779799728327  )
					# 3_474_749_660_383

					assert not miller_rabin(113850023909441  )
					assert miller_rabin(113850023909527  )
					# 341_550_071_728_321

					assert not miller_rabin(1275041018848804351  )
					assert miller_rabin(1275041018848804391  )
					# 3_825_123_056_546_413_051

					assert not miller_rabin(79666464458507787791867  )
					assert miller_rabin(79666464458507787791951  )
					# 318_665_857_834_031_151_167_461

					assert not miller_rabin(552840677446647897660333  )
					assert miller_rabin(552840677446647897660359  )
					# 3_317_044_064_679_887_385_961_981
					# upper limit for probabilistic test


if __name__ == "__main__":
		test_miller_rabin()



'''simple docstring'''
import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow


if is_torch_available():
		import torch

		from transformers import XLMRobertaModel
@require_sentencepiece
@require_tokenizers
@require_torch
class   lowercase      (				unittest.TestCase   ):

		"""simple docstring"""

		@slow
		def        lowerCAmelCase__							(						self				):

							'''simple docstring'''


							UpperCamelCase__  :Optional[Any]				   =					XLMRobertaModel.from_pretrained('''xlm-roberta-base'''				)
							UpperCamelCase__  :List[str]				   =					torch.tensor([[0, 581, 10269, 83, 99942, 136, 60742, 23, 70, 80583, 18276, 2]]				)
							# The dog is cute and lives in the garden house

							UpperCamelCase__  :Union[str, Any]				   =					torch.Size((1, 12, 768)				)  # batch_size, sequence_length, embedding_vector_dim
							UpperCamelCase__  :Union[str, Any]				   =					torch.tensor(
							    [[-0.0101, 0.1218, -0.0803, 0.0801, 0.1327, 0.0776, -0.1215, 0.2383, 0.3338, 0.3106, 0.0300, 0.0252]]				)
							#  xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.base')
							#  xlmr.eval()
							#  expected_output_values_last_dim = xlmr.extract_features(input_ids[0])[:, :, -1]
							with torch.no_grad():
												UpperCamelCase__  :Any				   =					model(UpperCamelCase_				)['''last_hidden_state'''].detach()
							self.assertEqual(output.shape       ,  UpperCamelCase_				)
							# compare the actual values for a slice of last dim
							self.assertTrue(torch.allclose(output[:, :, -1]       ,  UpperCamelCase_       ,  atol=1e-3				)				)




		@slow
		def        lowerCAmelCase__							(						self				):

							'''simple docstring'''


							UpperCamelCase__  :int				   =					XLMRobertaModel.from_pretrained('''xlm-roberta-large'''				)
							UpperCamelCase__  :List[str]				   =					torch.tensor([[0, 581, 10269, 83, 99942, 136, 60742, 23, 70, 80583, 18276, 2]]				)
							# The dog is cute and lives in the garden house

							UpperCamelCase__  :Any				   =					torch.Size((1, 12, 1024)				)  # batch_size, sequence_length, embedding_vector_dim
							UpperCamelCase__  :List[Any]				   =					torch.tensor(
							    [[-0.0699, -0.0318, 0.0705, -0.1241, 0.0999, -0.0520, 0.1004, -0.1838, -0.4704, 0.1437, 0.0821, 0.0126]]				)
							#  xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.large')
							#  xlmr.eval()
							#  expected_output_values_last_dim = xlmr.extract_features(input_ids[0])[:, :, -1]
							with torch.no_grad():
												UpperCamelCase__  :Optional[int]				   =					model(UpperCamelCase_				)['''last_hidden_state'''].detach()
							self.assertEqual(output.shape       ,  UpperCamelCase_				)
							# compare the actual values for a slice of last dim
							self.assertTrue(torch.allclose(output[:, :, -1]       ,  UpperCamelCase_       ,  atol=1e-3				)				)