"""simple docstring"""





def     a_					(				_lowerCAmelCase  :			int = 100					):





       '''simple docstring'''

       lowercase__      :		str          =     [[0 for _ in range(_lowerCAmelCase					)] for _ in range(m + 1					)]
       for i in range(m + 1					):
              lowercase__      :		int          =     1

       for n in range(m + 1					):
              for k in range(1       ,			_lowerCAmelCase					):
                     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())))


"""simple docstring"""





import torch

from transformers import PreTrainedModel

from .custom_configuration import CustomConfig, NoSuperInitConfig


class 					UpperCAmelCase_     (   _a):
      lowerCamelCase__		:   List[str]			  =  CustomConfig


      def __init__(       self		,      a							)	-> Optional[int]:
             super().__init__(a							)
             lowercase__      :		Any          =     torch.nn.Linear(config.hidden_size		,      config.hidden_size							)


      def 		_UpperCAmelCase	(       self		,      a							)	-> Union[str, Any]:
             return self.linear(a							)


      def 		_UpperCAmelCase	(       self		,      a							)	-> Tuple:
             pass





class 					UpperCAmelCase_     (   _a):
      lowerCamelCase__		:   Optional[int]			  =  NoSuperInitConfig


      def __init__(       self		,      a							)	-> int:
             super().__init__(a							)
             lowercase__      :		List[Any]          =     torch.nn.Linear(config.attribute		,      config.attribute							)


      def 		_UpperCAmelCase	(       self		,      a							)	-> Optional[int]:
             return self.linear(a							)


      def 		_UpperCAmelCase	(       self		,      a							)	-> Optional[Any]:
             pass

