



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  _snake_case	(    unittest.TestCase):




				@slow
				def 							A__					(  self    :  Any  ):
							lowercase__         = CamembertModel.from_pretrained("camembert-base"  )
							model.to(__lowercase  )

							lowercase__         = torch.tensor(
							    [[5, 121, 11, 660, 16, 730, 2_5543, 110, 83, 6]],    device=__lowercase,    dtype=torch.long,    )  # J'aime le camembert !
							with torch.no_grad():
										lowercase__         = model(__lowercase  )['last_hidden_state']
							lowercase__         = torch.Size((1, 10, 768)  )
							self.assertEqual(output.shape,    __lowercase  )
							# compare the actual values for a slice.
							lowercase__         = torch.tensor(
							    [[[-0.0254, 0.0235, 0.1027], [0.0606, -0.1811, -0.0418], [-0.1561, -0.1127, 0.2687]]],    device=__lowercase,    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],    __lowercase,    atol=1e-4  )  )








def       UpperCamelCase__     (  SCREAMING_SNAKE_CASE__ = 100						):
 __lowerCamelCase		:							List[Any]							=						[[0 for _ in range(SCREAMING_SNAKE_CASE__						)] for _ in range(m + 1						)]
 for i in range(m + 1						):
  __lowerCamelCase		:							Any							=						1

 for n in range(m + 1						):
  for k in range(1			,       SCREAMING_SNAKE_CASE__						):
   memo[n][k] += memo[n][k - 1]
   if n > k:
    memo[n][k] += memo[n - k - 1][k]

 return memo[m][m - 1] - 1


if __name__ == "__main__":
       print(solution(int(input('Enter a number: ').strip())))

