



"""simple docstring"""
import gc
import unittest

from transformers import MODEL_FOR_MASKED_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, FillMaskPipeline, pipeline
from transformers.pipelines import PipelineException
from transformers.testing_utils import (
    is_pipeline_test,
    is_torch_available,
    nested_simplify,
    require_tf,
    require_torch,
    require_torch_gpu,
    slow,
)

from .test_pipelines_common import ANY
@is_pipeline_test
class 				lowerCamelCase  (			unittest.TestCase				):






					'''simple docstring'''





					_A		:			Union[str, Any]						=     MODEL_FOR_MASKED_LM_MAPPING
					_A		:			int						=     TF_MODEL_FOR_MASKED_LM_MAPPING






					def    lowerCAmelCase_				(       self:							Union[str, Any]						)   ->	Any:
											super().tearDown()
											# clean-up as much as possible GPU memory occupied by PyTorch
											gc.collect()
											if is_torch_available():
																	import torch

																	torch.cuda.empty_cache()






					@require_tf
					def    lowerCAmelCase_				(       self:							str						)   ->	Union[str, Any]:
											snake_case_ :Optional[Any]						=			pipeline(task="""fill-mask"""						,     model="""sshleifer/tiny-distilroberta-base"""						,     top_k=2						,     framework="""tf"""						)
											snake_case_ :str						=			unmasker("""My name is <mask>"""						)
											self.assertEqual(
											    nested_simplify(snake_case						,     decimals=6						)						,     [
											        {"""sequence""": """My name is grouped""", """score""": 2.1E-05, """token""": 38_015, """token_str""": """ grouped"""},
											        {"""sequence""": """My name is accuser""", """score""": 2.1E-05, """token""": 25_506, """token_str""": """ accuser"""},
											    ]						,     )

											snake_case_ :List[Any]						=			unmasker("""The largest city in France is <mask>"""						)
											self.assertEqual(
											    nested_simplify(snake_case						,     decimals=6						)						,     [
											        {
											            """sequence""": """The largest city in France is grouped""",
											            """score""": 2.1E-05,
											            """token""": 38_015,
											            """token_str""": """ grouped""",
											        },
											        {
											            """sequence""": """The largest city in France is accuser""",
											            """score""": 2.1E-05,
											            """token""": 25_506,
											            """token_str""": """ accuser""",
											        },
											    ]						,     )

											snake_case_ :Any						=			unmasker("""My name is <mask>"""						,     targets=[""" Patrick""", """ Clara""", """ Teven"""]						,     top_k=3						)
											self.assertEqual(
											    nested_simplify(snake_case						,     decimals=6						)						,     [
											        {"""sequence""": """My name is Clara""", """score""": 2E-05, """token""": 13_606, """token_str""": """ Clara"""},
											        {"""sequence""": """My name is Patrick""", """score""": 2E-05, """token""": 3_499, """token_str""": """ Patrick"""},
											        {"""sequence""": """My name is Te""", """score""": 1.9E-05, """token""": 2_941, """token_str""": """ Te"""},
											    ]						,     )






					@require_torch
					def    lowerCAmelCase_				(       self:							Union[str, Any]						)   ->	Union[str, Any]:
											snake_case_ :List[Any]						=			pipeline(task="""fill-mask"""						,     model="""sshleifer/tiny-distilroberta-base"""						,     top_k=2						,     framework="""pt"""						)

											snake_case_ :Optional[int]						=			unmasker("""My name is <mask>"""						)
											self.assertEqual(
											    nested_simplify(snake_case						,     decimals=6						)						,     [
											        {"""sequence""": """My name is Maul""", """score""": 2.2E-05, """token""": 35_676, """token_str""": """ Maul"""},
											        {"""sequence""": """My name isELS""", """score""": 2.2E-05, """token""": 16_416, """token_str""": """ELS"""},
											    ]						,     )

											snake_case_ :Union[str, Any]						=			unmasker("""The largest city in France is <mask>"""						)
											self.assertEqual(
											    nested_simplify(snake_case						,     decimals=6						)						,     [
											        {
											            """sequence""": """The largest city in France is Maul""",
											            """score""": 2.2E-05,
											            """token""": 35_676,
											            """token_str""": """ Maul""",
											        },
											        {"""sequence""": """The largest city in France isELS""", """score""": 2.2E-05, """token""": 16_416, """token_str""": """ELS"""},
											    ]						,     )

											snake_case_ :str						=			unmasker("""My name is <mask>"""						,     targets=[""" Patrick""", """ Clara""", """ Teven"""]						,     top_k=3						)
											self.assertEqual(
											    nested_simplify(snake_case						,     decimals=6						)						,     [
											        {"""sequence""": """My name is Patrick""", """score""": 2.1E-05, """token""": 3_499, """token_str""": """ Patrick"""},
											        {"""sequence""": """My name is Te""", """score""": 2E-05, """token""": 2_941, """token_str""": """ Te"""},
											        {"""sequence""": """My name is Clara""", """score""": 2E-05, """token""": 13_606, """token_str""": """ Clara"""},
											    ]						,     )

											snake_case_ :List[Any]						=			unmasker("""My name is <mask> <mask>"""						,     top_k=2						)

											self.assertEqual(
											    nested_simplify(snake_case						,     decimals=6						)						,     [
											        [
											            {
											                """score""": 2.2E-05,
											                """token""": 35_676,
											                """token_str""": """ Maul""",
											                """sequence""": """<s>My name is Maul<mask></s>""",
											            },
											            {"""score""": 2.2E-05, """token""": 16_416, """token_str""": """ELS""", """sequence""": """<s>My name isELS<mask></s>"""},
											        ],
											        [
											            {
											                """score""": 2.2E-05,
											                """token""": 35_676,
											                """token_str""": """ Maul""",
											                """sequence""": """<s>My name is<mask> Maul</s>""",
											            },
											            {"""score""": 2.2E-05, """token""": 16_416, """token_str""": """ELS""", """sequence""": """<s>My name is<mask>ELS</s>"""},
											        ],
											    ]						,     )






					@require_torch_gpu
					def    lowerCAmelCase_				(       self:							Any						)   ->	str:
											snake_case_ :Optional[int]						=			pipeline("""fill-mask"""						,     model="""hf-internal-testing/tiny-random-distilbert"""						,     device=0						,     framework="""pt"""						)

											# convert model to fp16
											pipe.model.half()

											snake_case_ :List[str]						=			pipe("""Paris is the [MASK] of France."""						)
											# We actually don't care about the result, we just want to make sure
											# it works, meaning the float16 tensor got casted back to float32
											# for postprocessing.
											self.assertIsInstance(snake_case						,     snake_case						)






					@slow
					@require_torch
					def    lowerCAmelCase_				(       self:							Dict						)   ->	Dict:
											snake_case_ :Any						=			pipeline(task="""fill-mask"""						,     model="""distilroberta-base"""						,     top_k=2						,     framework="""pt"""						)
											self.run_large_test(snake_case						)






					@slow
					@require_tf
					def    lowerCAmelCase_				(       self:							List[Any]						)   ->	Optional[int]:
											snake_case_ :Any						=			pipeline(task="""fill-mask"""						,     model="""distilroberta-base"""						,     top_k=2						,     framework="""tf"""						)
											self.run_large_test(snake_case						)






					def    lowerCAmelCase_				(       self:							Union[str, Any]						,     snake_case:							List[Any]						)   ->	Union[str, Any]:
											snake_case_ :Optional[Any]						=			unmasker("""My name is <mask>"""						)
											self.assertEqual(
											    nested_simplify(snake_case						)						,     [
											        {"""sequence""": """My name is John""", """score""": 0.0_0_8, """token""": 610, """token_str""": """ John"""},
											        {"""sequence""": """My name is Chris""", """score""": 0.0_0_7, """token""": 1_573, """token_str""": """ Chris"""},
											    ]						,     )
											snake_case_ :List[Any]						=			unmasker("""The largest city in France is <mask>"""						)
											self.assertEqual(
											    nested_simplify(snake_case						)						,     [
											        {
											            """sequence""": """The largest city in France is Paris""",
											            """score""": 0.2_5_1,
											            """token""": 2_201,
											            """token_str""": """ Paris""",
											        },
											        {
											            """sequence""": """The largest city in France is Lyon""",
											            """score""": 0.2_1_4,
											            """token""": 12_790,
											            """token_str""": """ Lyon""",
											        },
											    ]						,     )

											snake_case_ :int						=			unmasker("""My name is <mask>"""						,     targets=[""" Patrick""", """ Clara""", """ Teven"""]						,     top_k=3						)
											self.assertEqual(
											    nested_simplify(snake_case						)						,     [
											        {"""sequence""": """My name is Patrick""", """score""": 0.0_0_5, """token""": 3_499, """token_str""": """ Patrick"""},
											        {"""sequence""": """My name is Clara""", """score""": 0.0_0_0, """token""": 13_606, """token_str""": """ Clara"""},
											        {"""sequence""": """My name is Te""", """score""": 0.0_0_0, """token""": 2_941, """token_str""": """ Te"""},
											    ]						,     )






					@require_torch
					def    lowerCAmelCase_				(       self:							Dict						)   ->	Optional[int]:
											snake_case_ :str						=			pipeline(task="""fill-mask"""						,     model="""sshleifer/tiny-distilroberta-base"""						,     framework="""pt"""						)
											snake_case_ :Any						=			None
											snake_case_ :Tuple						=			None
											self.run_pipeline_test(snake_case						,     []						)






					@require_tf
					def    lowerCAmelCase_				(       self:							Optional[Any]						)   ->	Optional[int]:
											snake_case_ :int						=			pipeline(task="""fill-mask"""						,     model="""sshleifer/tiny-distilroberta-base"""						,     framework="""tf"""						)
											snake_case_ :List[str]						=			None
											snake_case_ :List[Any]						=			None
											self.run_pipeline_test(snake_case						,     []						)






					def    lowerCAmelCase_				(       self:							List[Any]						,     snake_case:							int						,     snake_case:							Tuple						,     snake_case:							Optional[int]						)   ->	Any:
											if tokenizer is None or tokenizer.mask_token_id is None:
																	self.skipTest("""The provided tokenizer has no mask token, (probably reformer or wav2vec2)"""						)

											snake_case_ :Union[str, Any]						=			FillMaskPipeline(model=snake_case						,     tokenizer=snake_case						)
											snake_case_ :str						=			[
											    f"""This is another {tokenizer.mask_token} test""",
											]
											return fill_masker, examples






					def    lowerCAmelCase_				(       self:							Any						,     snake_case:							Optional[Any]						,     snake_case:							Tuple						)   ->	Union[str, Any]:
											snake_case_ :Any						=			fill_masker.tokenizer
											snake_case_ :List[Any]						=			fill_masker.model

											snake_case_ :int						=			fill_masker(
											    f"""This is a {tokenizer.mask_token}"""						,     )
											self.assertEqual(
											    snake_case						,     [
											        {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											        {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											        {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											        {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											        {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											    ]						,     )

											snake_case_ :Optional[int]						=			fill_masker([f"""This is a {tokenizer.mask_token}"""]						)
											self.assertEqual(
											    snake_case						,     [
											        {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											        {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											        {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											        {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											        {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											    ]						,     )

											snake_case_ :Union[str, Any]						=			fill_masker([f"""This is a {tokenizer.mask_token}""", f"""Another {tokenizer.mask_token} great test."""]						)
											self.assertEqual(
											    snake_case						,     [
											        [
											            {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											            {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											            {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											            {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											            {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											        ],
											        [
											            {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											            {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											            {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											            {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											            {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											        ],
											    ]						,     )

											with self.assertRaises(snake_case						):
																	fill_masker([None]						)
											# No mask_token is not supported
											with self.assertRaises(snake_case						):
																	fill_masker("""This is"""						)

											self.run_test_top_k(snake_case						,     snake_case						)
											self.run_test_targets(snake_case						,     snake_case						)
											self.run_test_top_k_targets(snake_case						,     snake_case						)
											self.fill_mask_with_duplicate_targets_and_top_k(snake_case						,     snake_case						)
											self.fill_mask_with_multiple_masks(snake_case						,     snake_case						)






					def    lowerCAmelCase_				(       self:							Any						,     snake_case:							int						,     snake_case:							int						)   ->	int:
											snake_case_ :List[str]						=			tokenizer.get_vocab()
											snake_case_ :Dict						=			sorted(vocab.keys()						)[:2]
											# Pipeline argument
											snake_case_ :Any						=			FillMaskPipeline(model=snake_case						,     tokenizer=snake_case						,     targets=snake_case						)
											snake_case_ :Optional[Any]						=			fill_masker(f"""This is a {tokenizer.mask_token}"""						)
											self.assertEqual(
											    snake_case						,     [
											        {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											        {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											    ]						,     )
											snake_case_ :List[str]						=			{vocab[el] for el in targets}
											self.assertEqual({el["""token"""] for el in outputs}						,     snake_case						)
											snake_case_ :Optional[int]						=			[tokenizer.decode([x]						) for x in target_ids]
											self.assertEqual({el["""token_str"""] for el in outputs}						,     set(snake_case						)						)

											# Call argument
											snake_case_ :int						=			FillMaskPipeline(model=snake_case						,     tokenizer=snake_case						)
											snake_case_ :Optional[int]						=			fill_masker(f"""This is a {tokenizer.mask_token}"""						,     targets=snake_case						)
											self.assertEqual(
											    snake_case						,     [
											        {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											        {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											    ]						,     )
											snake_case_ :Tuple						=			{vocab[el] for el in targets}
											self.assertEqual({el["""token"""] for el in outputs}						,     snake_case						)
											snake_case_ :Tuple						=			[tokenizer.decode([x]						) for x in target_ids]
											self.assertEqual({el["""token_str"""] for el in outputs}						,     set(snake_case						)						)

											# Score equivalence
											snake_case_ :Tuple						=			fill_masker(f"""This is a {tokenizer.mask_token}"""						,     targets=snake_case						)
											snake_case_ :Any						=			[top_mask["""token_str"""] for top_mask in outputs]
											snake_case_ :Union[str, Any]						=			[top_mask["""score"""] for top_mask in outputs]

											# For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
											if set(snake_case						) == set(snake_case						):
																	snake_case_ :Optional[int]						=			fill_masker(f"""This is a {tokenizer.mask_token}"""						,     targets=snake_case						)
																	snake_case_ :Union[str, Any]						=			[top_mask["""score"""] for top_mask in unmasked_targets]
																	self.assertEqual(nested_simplify(snake_case						)						,     nested_simplify(snake_case						)						)

											# Raises with invalid
											with self.assertRaises(snake_case						):
																	snake_case_ :Union[str, Any]						=			fill_masker(f"""This is a {tokenizer.mask_token}"""						,     targets=[]						)
											# For some tokenizers, `""` is actually in the vocabulary and the expected error won't raised
											if "" not in tokenizer.get_vocab():
																	with self.assertRaises(snake_case						):
																							snake_case_ :int						=			fill_masker(f"""This is a {tokenizer.mask_token}"""						,     targets=[""""""]						)
																	with self.assertRaises(snake_case						):
																							snake_case_ :Optional[Any]						=			fill_masker(f"""This is a {tokenizer.mask_token}"""						,     targets=""""""						)






					def    lowerCAmelCase_				(       self:							int						,     snake_case:							List[str]						,     snake_case:							List[str]						)   ->	Union[str, Any]:
											snake_case_ :Union[str, Any]						=			FillMaskPipeline(model=snake_case						,     tokenizer=snake_case						,     top_k=2						)
											snake_case_ :str						=			fill_masker(f"""This is a {tokenizer.mask_token}"""						)
											self.assertEqual(
											    snake_case						,     [
											        {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											        {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											    ]						,     )

											snake_case_ :Optional[int]						=			FillMaskPipeline(model=snake_case						,     tokenizer=snake_case						)
											snake_case_ :Optional[Any]						=			fill_masker(f"""This is a {tokenizer.mask_token}"""						,     top_k=2						)
											self.assertEqual(
											    snake_case						,     [
											        {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											        {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											    ]						,     )
											self.assertEqual(nested_simplify(snake_case						)						,     nested_simplify(snake_case						)						)






					def    lowerCAmelCase_				(       self:							Any						,     snake_case:							List[str]						,     snake_case:							List[Any]						)   ->	Tuple:
											snake_case_ :Tuple						=			tokenizer.get_vocab()
											snake_case_ :List[str]						=			FillMaskPipeline(model=snake_case						,     tokenizer=snake_case						)

											# top_k=2, ntargets=3
											snake_case_ :List[Any]						=			sorted(vocab.keys()						)[:3]
											snake_case_ :Any						=			fill_masker(f"""This is a {tokenizer.mask_token}"""						,     top_k=2						,     targets=snake_case						)

											# If we use the most probably targets, and filter differently, we should still
											# have the same results
											snake_case_ :str						=			[el["""token_str"""] for el in sorted(snake_case						,     key=lambda snake_case						: x["score"]						,     reverse=snake_case						)]
											# For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
											if set(snake_case						).issubset(snake_case						):
																	snake_case_ :Dict						=			fill_masker(f"""This is a {tokenizer.mask_token}"""						,     top_k=3						,     targets=snake_case						)
																	# They should yield exactly the same result
																	self.assertEqual(nested_simplify(snake_case						)						,     nested_simplify(snake_case						)						)






					def    lowerCAmelCase_				(       self:							Tuple						,     snake_case:							Optional[int]						,     snake_case:							Dict						)   ->	Tuple:
											snake_case_ :List[str]						=			FillMaskPipeline(model=snake_case						,     tokenizer=snake_case						)
											snake_case_ :Dict						=			tokenizer.get_vocab()
											# String duplicates + id duplicates
											snake_case_ :Optional[Any]						=			sorted(vocab.keys()						)[:3]
											snake_case_ :Union[str, Any]						=			[targets[0], targets[1], targets[0], targets[2], targets[1]]
											snake_case_ :str						=			fill_masker(f"""My name is {tokenizer.mask_token}"""						,     targets=snake_case						,     top_k=10						)

											# The target list contains duplicates, so we can't output more
											# than them
											self.assertEqual(len(snake_case						)						,     3						)






					def    lowerCAmelCase_				(       self:							str						,     snake_case:							Optional[int]						,     snake_case:							Dict						)   ->	int:
											snake_case_ :Union[str, Any]						=			FillMaskPipeline(model=snake_case						,     tokenizer=snake_case						)

											snake_case_ :Dict						=			fill_masker(
											    f"""This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}"""						,     top_k=2						)
											self.assertEqual(
											    snake_case						,     [
											        [
											            {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											            {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											        ],
											        [
											            {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											            {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											        ],
											        [
											            {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											            {"""sequence""": ANY(snake_case						), """score""": ANY(snake_case						), """token""": ANY(snake_case						), """token_str""": ANY(snake_case						)},
											        ],
											    ]						,     )

"""simple docstring"""






from collections.abc import Sequence



def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase       ,    __UpperCAmelCase = False )  ->  float:
   if not arr:
      return 0

   lowercase__:   Any					=      0 if allow_empty_subarrays else float('''-inf''' )
   lowercase__:   Union[str, Any]					=      0.0
   for num in arr:
      lowercase__:   List[str]					=      max(0 if allow_empty_subarrays else num       ,    curr_sum + num )
      lowercase__:   int					=      max(__UpperCAmelCase       ,    __UpperCAmelCase )

   return max_sum


if __name__ == "__main__":
       from doctest import testmod

       testmod()

       __A			   = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
       print(f'''{max_subarray_sum(nums) = }''')
