



from math import ceil




def      __UpperCamelCase     (  _lowerCAmelCase = 1001		)	->  int:



    """simple docstring"""






    A			:	Any										=       1

    for i in range(1				,					int(ceil(n / 2.0		)		)		):
        A			:	Dict										=       2 * i + 1
        A			:	Union[str, Any]										=       2 * i
        A			:	Optional[Any]										=       total + 4 * odd**2 - 6 * even

    return total


if __name__ == "__main__":
     import sys

     if len(sys.argv) == 1:
          print(solution())
     else:
          try:
               SCREAMING_SNAKE_CASE_:Tuple					=						int(sys.argv[1])
               print(solution(n))
          except ValueError:
               print("""Invalid entry - please enter a number""")







import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import BertTokenizer, BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import FEATURE_EXTRACTOR_NAME, is_vision_available


if is_vision_available():
     from PIL import Image

     from transformers import ChineseCLIPImageProcessor, ChineseCLIPProcessor






@require_vision
class SCREAMING_SNAKE_CASE__					(		unittest.TestCase   ):




    '''simple docstring'''






    def       _lowerCAmelCase (	self		):
        A			:	str										=       tempfile.mkdtemp()

        A			:	Any										=       [
            """[UNK]""",
            """[CLS]""",
            """[SEP]""",
            """[PAD]""",
            """[MASK]""",
            """的""",
            """价""",
            """格""",
            """是""",
            """15""",
            """便""",
            """alex""",
            """##andra""",
            """，""",
            """。""",
            """-""",
            """t""",
            """shirt""",
        ]
        A			:	Any										=       os.path.join(self.tmpdirname,		VOCAB_FILES_NAMES["""vocab_file"""]		)
        with open(self.vocab_file,		"""w""",		encoding="""utf-8"""		) as vocab_writer:
            vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens]		)		)

        A			:	Any										=       {
            """do_resize""": True,
            """size""": {"""height""": 224, """width""": 224},
            """do_center_crop""": True,
            """crop_size""": {"""height""": 18, """width""": 18},
            """do_normalize""": True,
            """image_mean""": [0.4814_5466, 0.457_8275, 0.4082_1073],
            """image_std""": [0.2686_2954, 0.2613_0258, 0.2757_7711],
            """do_convert_rgb""": True,
        }
        A			:	int										=       os.path.join(self.tmpdirname,		lowerCamelCase__		)
        with open(self.image_processor_file,		"""w""",		encoding="""utf-8"""		) as fp:
            json.dump(lowerCamelCase__,		lowerCamelCase__		)






    def       _lowerCAmelCase (	self,		**lowerCamelCase__		):
        return BertTokenizer.from_pretrained(self.tmpdirname,		**lowerCamelCase__		)






    def       _lowerCAmelCase (	self,		**lowerCamelCase__		):
        return BertTokenizerFast.from_pretrained(self.tmpdirname,		**lowerCamelCase__		)






    def       _lowerCAmelCase (	self,		**lowerCamelCase__		):
        return ChineseCLIPImageProcessor.from_pretrained(self.tmpdirname,		**lowerCamelCase__		)






    def       _lowerCAmelCase (	self		):
        shutil.rmtree(self.tmpdirname		)






    def       _lowerCAmelCase (	self		):
        A			:	Optional[int]										=       [np.random.randint(255,		size=(3, 30, 400),		dtype=np.uinta		)]

        A			:	List[Any]										=       [Image.fromarray(np.moveaxis(lowerCamelCase__,		0,		-1		)		) for x in image_inputs]

        return image_inputs






    def       _lowerCAmelCase (	self		):
        A			:	List[Any]										=       self.get_tokenizer()
        A			:	Dict										=       self.get_rust_tokenizer()
        A			:	List[Any]										=       self.get_image_processor()

        A			:	int										=       ChineseCLIPProcessor(tokenizer=lowerCamelCase__,		image_processor=lowerCamelCase__		)
        processor_slow.save_pretrained(self.tmpdirname		)
        A			:	Optional[Any]										=       ChineseCLIPProcessor.from_pretrained(self.tmpdirname,		use_fast=lowerCamelCase__		)

        A			:	str										=       ChineseCLIPProcessor(tokenizer=lowerCamelCase__,		image_processor=lowerCamelCase__		)
        processor_fast.save_pretrained(self.tmpdirname		)
        A			:	Tuple										=       ChineseCLIPProcessor.from_pretrained(self.tmpdirname		)

        self.assertEqual(processor_slow.tokenizer.get_vocab(),		tokenizer_slow.get_vocab()		)
        self.assertEqual(processor_fast.tokenizer.get_vocab(),		tokenizer_fast.get_vocab()		)
        self.assertEqual(tokenizer_slow.get_vocab(),		tokenizer_fast.get_vocab()		)
        self.assertIsInstance(processor_slow.tokenizer,		lowerCamelCase__		)
        self.assertIsInstance(processor_fast.tokenizer,		lowerCamelCase__		)

        self.assertEqual(processor_slow.image_processor.to_json_string(),		image_processor.to_json_string()		)
        self.assertEqual(processor_fast.image_processor.to_json_string(),		image_processor.to_json_string()		)
        self.assertIsInstance(processor_slow.image_processor,		lowerCamelCase__		)
        self.assertIsInstance(processor_fast.image_processor,		lowerCamelCase__		)






    def       _lowerCAmelCase (	self		):
        A			:	str										=       ChineseCLIPProcessor(tokenizer=self.get_tokenizer(),		image_processor=self.get_image_processor()		)
        processor.save_pretrained(self.tmpdirname		)

        A			:	Optional[int]										=       self.get_tokenizer(cls_token="""(CLS)""",		sep_token="""(SEP)"""		)
        A			:	Optional[int]										=       self.get_image_processor(do_normalize=lowerCamelCase__		)

        A			:	Optional[int]										=       ChineseCLIPProcessor.from_pretrained(
            self.tmpdirname,		cls_token="""(CLS)""",		sep_token="""(SEP)""",		do_normalize=lowerCamelCase__		)

        self.assertEqual(processor.tokenizer.get_vocab(),		tokenizer_add_kwargs.get_vocab()		)
        self.assertIsInstance(processor.tokenizer,		lowerCamelCase__		)

        self.assertEqual(processor.image_processor.to_json_string(),		image_processor_add_kwargs.to_json_string()		)
        self.assertIsInstance(processor.image_processor,		lowerCamelCase__		)






    def       _lowerCAmelCase (	self		):
        A			:	Tuple										=       self.get_image_processor()
        A			:	List[str]										=       self.get_tokenizer()

        A			:	List[str]										=       ChineseCLIPProcessor(tokenizer=lowerCamelCase__,		image_processor=lowerCamelCase__		)

        A			:	Any										=       self.prepare_image_inputs()

        A			:	Union[str, Any]										=       image_processor(lowerCamelCase__,		return_tensors="""np"""		)
        A			:	str										=       processor(images=lowerCamelCase__,		return_tensors="""np"""		)

        for key in input_feat_extract.keys():
            self.assertAlmostEqual(input_feat_extract[key].sum(),		input_processor[key].sum(),		delta=1e-2		)






    def       _lowerCAmelCase (	self		):
        A			:	List[str]										=       self.get_image_processor()
        A			:	Tuple										=       self.get_tokenizer()

        A			:	str										=       ChineseCLIPProcessor(tokenizer=lowerCamelCase__,		image_processor=lowerCamelCase__		)

        A			:	Any										=       """Alexandra，T-shirt的价格是15便士。"""

        A			:	Optional[Any]										=       processor(text=lowerCamelCase__		)

        A			:	int										=       tokenizer(lowerCamelCase__		)

        for key in encoded_tok.keys():
            self.assertListEqual(encoded_tok[key],		encoded_processor[key]		)






    def       _lowerCAmelCase (	self		):
        A			:	Dict										=       self.get_image_processor()
        A			:	List[str]										=       self.get_tokenizer()

        A			:	int										=       ChineseCLIPProcessor(tokenizer=lowerCamelCase__,		image_processor=lowerCamelCase__		)

        A			:	str										=       """Alexandra，T-shirt的价格是15便士。"""
        A			:	Dict										=       self.prepare_image_inputs()

        A			:	Optional[int]										=       processor(text=lowerCamelCase__,		images=lowerCamelCase__		)

        self.assertListEqual(list(inputs.keys()		),		["""input_ids""", """token_type_ids""", """attention_mask""", """pixel_values"""]		)

        # test if it raises when no input is passed
        with pytest.raises(lowerCamelCase__		):
            processor()






    def       _lowerCAmelCase (	self		):
        A			:	Union[str, Any]										=       self.get_image_processor()
        A			:	List[str]										=       self.get_tokenizer()

        A			:	List[str]										=       ChineseCLIPProcessor(tokenizer=lowerCamelCase__,		image_processor=lowerCamelCase__		)

        A			:	int										=       [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

        A			:	List[Any]										=       processor.batch_decode(lowerCamelCase__		)
        A			:	str										=       tokenizer.batch_decode(lowerCamelCase__		)

        self.assertListEqual(lowerCamelCase__,		lowerCamelCase__		)






    def       _lowerCAmelCase (	self		):
        A			:	List[str]										=       self.get_image_processor()
        A			:	List[str]										=       self.get_tokenizer()

        A			:	Any										=       ChineseCLIPProcessor(tokenizer=lowerCamelCase__,		image_processor=lowerCamelCase__		)

        A			:	List[Any]										=       """Alexandra，T-shirt的价格是15便士。"""
        A			:	Optional[Any]										=       self.prepare_image_inputs()

        A			:	str										=       processor(text=lowerCamelCase__,		images=lowerCamelCase__		)

        self.assertListEqual(list(inputs.keys()		),		processor.model_input_names		)


