






"""simple docstring"""





def 	lowerCAmelCase_(			SCREAMING_SNAKE_CASE       )       ->						str:
    """simple docstring"""

    UpperCamelCase__								=     1
    UpperCamelCase__								=     0
    UpperCamelCase__								=     1
    UpperCamelCase__								=     1
    UpperCamelCase__								=     3
    UpperCamelCase__								=     3
    UpperCamelCase__								=     limit
    UpperCamelCase__								=     0

    UpperCamelCase__								=     ''
    while counter != decimal + 1:
        if 4 * q + r - t < n * t:
            result += str(SCREAMING_SNAKE_CASE       )
            if counter == 0:
                result += "."

            if decimal == counter:
                break

            counter += 1
            UpperCamelCase__								=     10 * (r - n * t)
            UpperCamelCase__								=     ((10 * (3 * q + r)) // t) - 10 * n
            q *= 10
            UpperCamelCase__								=     nr
        else:
            UpperCamelCase__								=     (2 * q + r) * l
            UpperCamelCase__								=     (q * (7 * k) + 2 + (r * l)) // (t * l)
            q *= k
            t *= l
            l += 2
            k += 1
            UpperCamelCase__								=     nn
            UpperCamelCase__								=     nr
    return result







def 	lowerCAmelCase_(			)       ->						None:
    """simple docstring"""

    print(F'{calculate_pi(50       ) = }'       )
    import doctest

    doctest.testmod()


if __name__ == "__main__":
  main()












"""simple docstring"""





import torch

from transformers import PreTrainedModel

from .custom_configuration import CustomConfig, NoSuperInitConfig
class  __lowerCamelCase     (	_a	):
   a   :					List[Any]			    =CustomConfig

   def __init__(       self			,					snake_case_   )		->							str:
       super().__init__(snake_case_   )
       UpperCamelCase__								=     torch.nn.Linear(config.hidden_size			,					config.hidden_size   )

   def     SCREAMING_SNAKE_CASE__			(       self			,					snake_case_   )		->							Optional[int]:
       return self.linear(snake_case_   )







   def     SCREAMING_SNAKE_CASE__			(       self			,					snake_case_   )		->							Union[str, Any]:
       pass







class  __lowerCamelCase     (	_a	):
   a   :					Optional[int]			    =NoSuperInitConfig

   def __init__(       self			,					snake_case_   )		->							Optional[int]:
       super().__init__(snake_case_   )
       UpperCamelCase__								=     torch.nn.Linear(config.attribute			,					config.attribute   )

   def     SCREAMING_SNAKE_CASE__			(       self			,					snake_case_   )		->							int:
       return self.linear(snake_case_   )







   def     SCREAMING_SNAKE_CASE__			(       self			,					snake_case_   )		->							Union[str, Any]:
       pass




