





import unittest

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


if is_torch_available():
				import torch

				from transformers import CamembertModel



@require_torch
@require_sentencepiece
@require_tokenizers
class  _a  (					unittest.TestCase				):






							"""simple docstring"""

							@slow
							def   A_	(   self					:  List[Any]     )						->Dict:
													SCREAMING_SNAKE_CASE__  :					Optional[int] =       CamembertModel.from_pretrained("camembert-base"     )
													model.to(a     )

													SCREAMING_SNAKE_CASE__  :					Tuple =       torch.tensor(
													    [[5, 1_21, 11, 6_60, 16, 7_30, 2_55_43, 1_10, 83, 6]]				,						device=a				,						dtype=torch.long				,						)  # J'aime le camembert !
													with torch.no_grad():
																			SCREAMING_SNAKE_CASE__  :					Tuple =       model(a     )["last_hidden_state"]
													SCREAMING_SNAKE_CASE__  :					List[str] =       torch.Size((1, 10, 7_68)     )
													self.assertEqual(output.shape				,						a     )
													# compare the actual values for a slice.
													SCREAMING_SNAKE_CASE__  :					Optional[int] =       torch.tensor(
													    [[[-0.0254, 0.0235, 0.1027], [0.0606, -0.1811, -0.0418], [-0.1561, -0.1127, 0.2687]]]				,						device=a				,						dtype=torch.float				,						)
													# camembert = torch.hub.load('pytorch/fairseq', 'camembert.v0')
													# camembert.eval()
													# expected_slice = roberta.model.forward(input_ids)[0][:, :3, :3].detach()

													self.assertTrue(torch.allclose(output[:, :3, :3]				,						a				,						atol=1E-4     )     )






from itertools import combinations_with_replacement







def    UpperCAmelCase				(  _lowerCamelCase   :	int = 100  ):





						'''simple docstring'''


						SCREAMING_SNAKE_CASE__  :					list[int] =       [*list(range(1      , 21  )  ), 25]
						SCREAMING_SNAKE_CASE__  :					list[int] =       [2 * x for x in range(1      , 21  )] + [50]
						SCREAMING_SNAKE_CASE__  :					list[int] =       [3 * x for x in range(1      , 21  )]
						SCREAMING_SNAKE_CASE__  :					list[int] =       singles + doubles + triples + [0]

						SCREAMING_SNAKE_CASE__  :					int =       0
						SCREAMING_SNAKE_CASE__  :					int
						SCREAMING_SNAKE_CASE__  :					int
						SCREAMING_SNAKE_CASE__  :					int
						SCREAMING_SNAKE_CASE__  :					int

						for double in doubles:
												for throwa, throwa in combinations_with_replacement(_lowerCamelCase      , 2  ):
																		SCREAMING_SNAKE_CASE__  :					int =       double + throwa + throwa
																		if checkout_total < limit:
																								num_checkouts += 1

						return num_checkouts


if __name__ == "__main__":
				print(f"{solution() = }")