
import os

# Precomputes a list of the 100 first triangular numbers
__lowerCAmelCase    :	List[Any]						=						[int(0.5 * n * (n + 1)) for n in range(1, 101)]


def 			UpperCAmelCase_     (  )       ->  int:
    __lowercase						:	Optional[int]					=				os.path.dirname(os.path.realpath(SCREAMING_SNAKE_CASE__		)		)
    __lowercase						:	Tuple					=				os.path.join(SCREAMING_SNAKE_CASE__		,    '''words.txt'''		)

    __lowercase						:	Optional[Any]					=				''''''
    with open(SCREAMING_SNAKE_CASE__		) as f:
        __lowercase						:	Union[str, Any]					=				f.readline()

    __lowercase						:	List[Any]					=				[word.strip('''"'''		) for word in words.strip('''\r\n'''		).split(''','''		)]
    __lowercase						:	Any					=				[
        word
        for word in [sum(ord(SCREAMING_SNAKE_CASE__		) - 64 for x in word		) for word in words]
        if word in TRIANGULAR_NUMBERS
    ]
    return len(SCREAMING_SNAKE_CASE__		)


if __name__ == "__main__":
 print(solution())





from typing import Dict

from .base import GenericTensor, Pipeline


class  A						(							_UpperCAmelCase ):







    """simple docstring"""





    def 						snake_case__     (      self :       int,lowercase_ :       Dict=None,lowercase_ :       Tuple=None,lowercase_ :       List[Any]=None,**lowercase_ :       Any		)->    Optional[Any]:





        '''simple docstring'''







        if tokenize_kwargs is None:
            A__          =   {}

        if truncation is not None:
            if "truncation" in tokenize_kwargs:
                raise ValueError(
                    'truncation parameter defined twice (given as keyword argument as well as in tokenize_kwargs)'		)
            A__          =   truncation

        A__          =   tokenize_kwargs

        A__          =   {}
        if return_tensors is not None:
            A__          =   return_tensors

        return preprocess_params, {}, postprocess_params


    def 						snake_case__     (      self :       Dict,lowercase_ :       List[Any],**lowercase_ :       Tuple		)->    Dict[str, GenericTensor]:





        '''simple docstring'''







        A__          =   self.framework
        A__          =   self.tokenizer(lowercase_,return_tensors=lowercase_,**lowercase_		)
        return model_inputs


    def 						snake_case__     (      self :       Tuple,lowercase_ :       int		)->    Optional[Any]:





        '''simple docstring'''







        A__          =   self.model(**lowercase_		)
        return model_outputs


    def 						snake_case__     (      self :       Tuple,lowercase_ :       Tuple,lowercase_ :       List[str]=False		)->    Any:





        '''simple docstring'''







        if return_tensors:
            return model_outputs[0]
        if self.framework == "pt":
            return model_outputs[0].tolist()
        elif self.framework == "tf":
            return model_outputs[0].numpy().tolist()


    def __call__(      self :       List[Any],*lowercase_ :       int,**lowercase_ :       Optional[Any]		)->    int:





        '''simple docstring'''







        return super().__call__(*lowercase_,**lowercase_		)

