def lowerCamelCase  (       SCREAMING_SNAKE_CASE = 1_000     ):
				'''simple docstring'''







				return sum(2 * a * ((a - 1) // 2) for a in range(3  ,      n + 1     )     )


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






from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
    import numpy as np
    import tensorflow as tf

    from transformers import (
        TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        FlaubertConfig,
        TFFlaubertForMultipleChoice,
        TFFlaubertForQuestionAnsweringSimple,
        TFFlaubertForSequenceClassification,
        TFFlaubertForTokenClassification,
        TFFlaubertModel,
        TFFlaubertWithLMHeadModel,
    )


class      lowerCamelCase_					:






    '''simple docstring'''






    def __init__(     self			,			__lowercase			,			)	->     Optional[Any]:
        __UpperCamelCase					:Optional[int]        =		parent
        __UpperCamelCase					:Optional[int]        =		13
        __UpperCamelCase					:Dict        =		7
        __UpperCamelCase					:Optional[int]        =		True
        __UpperCamelCase					:List[str]        =		True
        __UpperCamelCase					:List[Any]        =		True
        __UpperCamelCase					:Union[str, Any]        =		True
        __UpperCamelCase					:Any        =		True
        __UpperCamelCase					:Optional[int]        =		False
        __UpperCamelCase					:Any        =		False
        __UpperCamelCase					:str        =		False
        __UpperCamelCase					:Optional[Any]        =		2
        __UpperCamelCase					:Optional[int]        =		99
        __UpperCamelCase					:Any        =		0
        __UpperCamelCase					:List[Any]        =		32
        __UpperCamelCase					:int        =		2
        __UpperCamelCase					:Optional[Any]        =		4
        __UpperCamelCase					:Dict        =		0.1
        __UpperCamelCase					:Optional[Any]        =		0.1
        __UpperCamelCase					:str        =		512
        __UpperCamelCase					:Any        =		16
        __UpperCamelCase					:str        =		2
        __UpperCamelCase					:Dict        =		0.02
        __UpperCamelCase					:List[Any]        =		3
        __UpperCamelCase					:Optional[int]        =		4
        __UpperCamelCase					:Tuple        =		'''last'''
        __UpperCamelCase					:Any        =		True
        __UpperCamelCase					:Union[str, Any]        =		None
        __UpperCamelCase					:Tuple        =		0







    def       UpperCamelCase__       (     self)	->     Dict:
        __UpperCamelCase					:List[str]        =		ids_tensor([self.batch_size, self.seq_length]			,			self.vocab_size)
        __UpperCamelCase					:Any        =		random_attention_mask([self.batch_size, self.seq_length]			,			dtype=tf.floataa)

        __UpperCamelCase					:Tuple        =		None
        if self.use_input_lengths:
            __UpperCamelCase					:List[str]        =		(
                ids_tensor([self.batch_size]			,			vocab_size=2) + self.seq_length - 2
            )  # small variation of seq_length

        __UpperCamelCase					:Any        =		None
        if self.use_token_type_ids:
            __UpperCamelCase					:int        =		ids_tensor([self.batch_size, self.seq_length]			,			self.n_langs)

        __UpperCamelCase					:Dict        =		None
        __UpperCamelCase					:List[str]        =		None
        __UpperCamelCase					:Union[str, Any]        =		None
        if self.use_labels:
            __UpperCamelCase					:Dict        =		ids_tensor([self.batch_size]			,			self.type_sequence_label_size)
            __UpperCamelCase					:int        =		ids_tensor([self.batch_size, self.seq_length]			,			self.num_labels)
            __UpperCamelCase					:List[str]        =		ids_tensor([self.batch_size]			,			2			,			dtype=tf.floataa)
            __UpperCamelCase					:Optional[Any]        =		ids_tensor([self.batch_size]			,			self.num_choices)

        __UpperCamelCase					:Optional[int]        =		FlaubertConfig(
            vocab_size=self.vocab_size			,			n_special=self.n_special			,			emb_dim=self.hidden_size			,			n_layers=self.num_hidden_layers			,			n_heads=self.num_attention_heads			,			dropout=self.hidden_dropout_prob			,			attention_dropout=self.attention_probs_dropout_prob			,			gelu_activation=self.gelu_activation			,			sinusoidal_embeddings=self.sinusoidal_embeddings			,			asm=self.asm			,			causal=self.causal			,			n_langs=self.n_langs			,			max_position_embeddings=self.max_position_embeddings			,			initializer_range=self.initializer_range			,			summary_type=self.summary_type			,			use_proj=self.use_proj			,			bos_token_id=self.bos_token_id			,			)

        return (
            config,
            input_ids,
            token_type_ids,
            input_lengths,
            sequence_labels,
            token_labels,
            is_impossible_labels,
            choice_labels,
            input_mask,
        )







    def       UpperCamelCase__       (     self			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			)	->     Optional[Any]:
        __UpperCamelCase					:str        =		TFFlaubertModel(config=__lowercase)
        __UpperCamelCase					:List[str]        =		{'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
        __UpperCamelCase					:Optional[int]        =		model(__lowercase)

        __UpperCamelCase					:Optional[int]        =		[input_ids, input_mask]
        __UpperCamelCase					:Union[str, Any]        =		model(__lowercase)
        self.parent.assertEqual(result.last_hidden_state.shape			,			(self.batch_size, self.seq_length, self.hidden_size))







    def       UpperCamelCase__       (     self			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			)	->     int:
        __UpperCamelCase					:str        =		TFFlaubertWithLMHeadModel(__lowercase)

        __UpperCamelCase					:List[str]        =		{'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
        __UpperCamelCase					:Optional[int]        =		model(__lowercase)

        self.parent.assertEqual(result.logits.shape			,			(self.batch_size, self.seq_length, self.vocab_size))







    def       UpperCamelCase__       (     self			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			)	->     Any:
        __UpperCamelCase					:Any        =		TFFlaubertForQuestionAnsweringSimple(__lowercase)

        __UpperCamelCase					:str        =		{'''input_ids''': input_ids, '''lengths''': input_lengths}

        __UpperCamelCase					:int        =		model(__lowercase)

        self.parent.assertEqual(result.start_logits.shape			,			(self.batch_size, self.seq_length))
        self.parent.assertEqual(result.end_logits.shape			,			(self.batch_size, self.seq_length))







    def       UpperCamelCase__       (     self			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			)	->     Any:
        __UpperCamelCase					:int        =		TFFlaubertForSequenceClassification(__lowercase)

        __UpperCamelCase					:List[Any]        =		{'''input_ids''': input_ids, '''lengths''': input_lengths}

        __UpperCamelCase					:Any        =		model(__lowercase)

        self.parent.assertEqual(result.logits.shape			,			(self.batch_size, self.type_sequence_label_size))







    def       UpperCamelCase__       (     self			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			)	->     Tuple:
        __UpperCamelCase					:Optional[int]        =		self.num_labels
        __UpperCamelCase					:int        =		TFFlaubertForTokenClassification(config=__lowercase)
        __UpperCamelCase					:Union[str, Any]        =		{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
        __UpperCamelCase					:Optional[Any]        =		model(__lowercase)
        self.parent.assertEqual(result.logits.shape			,			(self.batch_size, self.seq_length, self.num_labels))







    def       UpperCamelCase__       (     self			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			)	->     List[Any]:
        __UpperCamelCase					:Any        =		self.num_choices
        __UpperCamelCase					:Any        =		TFFlaubertForMultipleChoice(config=__lowercase)
        __UpperCamelCase					:List[str]        =		tf.tile(tf.expand_dims(__lowercase			,			1)			,			(1, self.num_choices, 1))
        __UpperCamelCase					:Optional[Any]        =		tf.tile(tf.expand_dims(__lowercase			,			1)			,			(1, self.num_choices, 1))
        __UpperCamelCase					:Tuple        =		tf.tile(tf.expand_dims(__lowercase			,			1)			,			(1, self.num_choices, 1))
        __UpperCamelCase					:Any        =		{
            '''input_ids''': multiple_choice_inputs_ids,
            '''attention_mask''': multiple_choice_input_mask,
            '''token_type_ids''': multiple_choice_token_type_ids,
        }
        __UpperCamelCase					:List[Any]        =		model(__lowercase)
        self.parent.assertEqual(result.logits.shape			,			(self.batch_size, self.num_choices))







    def       UpperCamelCase__       (     self)	->     Dict:
        __UpperCamelCase					:Optional[int]        =		self.prepare_config_and_inputs()
        (
            (
            __UpperCamelCase
        )  ,	(
            __UpperCamelCase
        )  ,	(
            __UpperCamelCase
        )  ,	(
            __UpperCamelCase
        )  ,	(
            __UpperCamelCase
        )  ,	(
            __UpperCamelCase
        )  ,	(
            __UpperCamelCase
        )  ,	(
            __UpperCamelCase
        )  ,	(
            __UpperCamelCase
        )  ,	
        )					:Any        =		config_and_inputs
        __UpperCamelCase					:int        =		{
            '''input_ids''': input_ids,
            '''token_type_ids''': token_type_ids,
            '''langs''': token_type_ids,
            '''lengths''': input_lengths,
        }
        return config, inputs_dict


@require_tf
class      lowerCamelCase_					(       UpperCAmelCase_						,     UpperCAmelCase_						,     unittest.TestCase			):






    '''simple docstring'''






    a__     :						List[Any]      =				(
        (
            TFFlaubertModel,
            TFFlaubertWithLMHeadModel,
            TFFlaubertForSequenceClassification,
            TFFlaubertForQuestionAnsweringSimple,
            TFFlaubertForTokenClassification,
            TFFlaubertForMultipleChoice,
        )
        if is_tf_available()
        else ()
    )
    a__     :						Tuple      =				(
        (TFFlaubertWithLMHeadModel,) if is_tf_available() else ()
    )  # TODO (PVP): Check other models whether language generation is also applicable
    a__     :						Tuple      =				(
        {
            """feature-extraction""": TFFlaubertModel,
            """fill-mask""": TFFlaubertWithLMHeadModel,
            """question-answering""": TFFlaubertForQuestionAnsweringSimple,
            """text-classification""": TFFlaubertForSequenceClassification,
            """token-classification""": TFFlaubertForTokenClassification,
            """zero-shot""": TFFlaubertForSequenceClassification,
        }
        if is_tf_available()
        else {}
    )
    a__     :						Tuple      =				False
    a__     :						Any      =				False







    def       UpperCamelCase__       (     self			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase)	->     Any:
        if (
            pipeline_test_casse_name == "QAPipelineTests"
            and tokenizer_name is not None
            and not tokenizer_name.endswith('''Fast''')
        ):
            # `QAPipelineTests` fails for a few models when the slower tokenizer are used.
            # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
            # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
            return True

        return False







    def       UpperCamelCase__       (     self)	->     Union[str, Any]:
        __UpperCamelCase					:int        =		TFFlaubertModelTester(self)
        __UpperCamelCase					:Dict        =		ConfigTester(self			,			config_class=__lowercase			,			emb_dim=37)







    def       UpperCamelCase__       (     self)	->     str:
        self.config_tester.run_common_tests()







    def       UpperCamelCase__       (     self)	->     Any:
        __UpperCamelCase					:int        =		self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_flaubert_model(*__lowercase)







    def       UpperCamelCase__       (     self)	->     Union[str, Any]:
        __UpperCamelCase					:Optional[int]        =		self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_flaubert_lm_head(*__lowercase)







    def       UpperCamelCase__       (     self)	->     Dict:
        __UpperCamelCase					:Optional[Any]        =		self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_flaubert_qa(*__lowercase)







    def       UpperCamelCase__       (     self)	->     Tuple:
        __UpperCamelCase					:Optional[Any]        =		self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_flaubert_sequence_classif(*__lowercase)







    def       UpperCamelCase__       (     self)	->     Optional[Any]:
        __UpperCamelCase					:Dict        =		self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_flaubert_for_token_classification(*__lowercase)







    def       UpperCamelCase__       (     self)	->     str:
        __UpperCamelCase					:Union[str, Any]        =		self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_flaubert_for_multiple_choice(*__lowercase)







    @slow
    def       UpperCamelCase__       (     self)	->     Union[str, Any]:
        for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            __UpperCamelCase					:Any        =		TFFlaubertModel.from_pretrained(__lowercase)
            self.assertIsNotNone(__lowercase)


@require_tf
@require_sentencepiece
@require_tokenizers
class      lowerCamelCase_					(       unittest.TestCase			):






    '''simple docstring'''






    @slow
    def       UpperCamelCase__       (     self)	->     Optional[Any]:
        __UpperCamelCase					:List[Any]        =		TFFlaubertModel.from_pretrained('''jplu/tf-flaubert-small-cased''')

        __UpperCamelCase					:Tuple        =		tf.convert_to_tensor(
            [[0, 158, 735, 2_592, 1_424, 6_727, 82, 1]]			,			dtype=tf.intaa			,			)  # "J'aime flaubert !"

        __UpperCamelCase					:Union[str, Any]        =		model(__lowercase)[0]
        __UpperCamelCase					:str        =		tf.TensorShape((1, 8, 512))
        self.assertEqual(output.shape			,			__lowercase)
        # compare the actual values for a slice.
        __UpperCamelCase					:Optional[int]        =		tf.convert_to_tensor(
            [
                [
                    [-1.8_76_87_73, -1.56_65_55, 0.27_07_24_18],
                    [-1.6_92_00_38, -0.5_87_35_05, 1.9_32_95_99],
                    [-2.9_56_39_85, -1.6_99_38_35, 1.7_97_20_52],
                ]
            ]			,			dtype=tf.floataa			,			)

        self.assertTrue(np.allclose(output[:, :3, :3].numpy()			,			expected_slice.numpy()			,			atol=1E-4))





