



import functools
import math

import flax.linen as nn
import jax
import jax.numpy as jnp







def  _snake_case			(							__snake_case       ,	__snake_case       ,	__snake_case       ,	__snake_case       ,	__snake_case = 4_0_9_6     )  ->  Optional[int]:






      '''simple docstring'''







      UpperCAmelCase_   ,   UpperCAmelCase_   ,   UpperCAmelCase_	:						Optional[int]					   =		key.shape[-3:]
      UpperCAmelCase_	:						Tuple					   =		value.shape[-1]
      UpperCAmelCase_	:						str					   =		min(__snake_case       ,	__snake_case     )
      UpperCAmelCase_	:						int					   =		query / jnp.sqrt(__snake_case     )

      @functools.partial(jax.checkpoint       ,	prevent_cse=__snake_case     )
      def summarize_chunk(__snake_case       ,	__snake_case       ,	__snake_case     ):
            UpperCAmelCase_	:						Union[str, Any]					   =		jnp.einsum("...qhd,...khd->...qhk"       ,	__snake_case       ,	__snake_case       ,	precision=__snake_case     )

            UpperCAmelCase_	:						Optional[Any]					   =		jnp.max(__snake_case       ,	axis=-1       ,	keepdims=__snake_case     )
            UpperCAmelCase_	:						List[str]					   =		jax.lax.stop_gradient(__snake_case     )
            UpperCAmelCase_	:						List[Any]					   =		jnp.exp(attn_weights - max_score     )

            UpperCAmelCase_	:						Dict					   =		jnp.einsum("...vhf,...qhv->...qhf"       ,	__snake_case       ,	__snake_case       ,	precision=__snake_case     )
            UpperCAmelCase_	:						Tuple					   =		jnp.einsum("...qhk->...qh"       ,	__snake_case     )

            return (exp_values, exp_weights.sum(axis=-1     ), max_score)

      def chunk_scanner(__snake_case     ):
            # julienne key array
            UpperCAmelCase_	:						Union[str, Any]					   =		jax.lax.dynamic_slice(
                operand=__snake_case       ,	start_indices=[0] * (key.ndim - 3) + [chunk_idx, 0, 0]       ,	slice_sizes=list(key.shape[:-3]     ) + [key_chunk_size, num_heads, k_features]       ,	)

            # julienne value array
            UpperCAmelCase_	:						Dict					   =		jax.lax.dynamic_slice(
                operand=__snake_case       ,	start_indices=[0] * (value.ndim - 3) + [chunk_idx, 0, 0]       ,	slice_sizes=list(value.shape[:-3]     ) + [key_chunk_size, num_heads, v_features]       ,	)

            return summarize_chunk(__snake_case       ,	__snake_case       ,	__snake_case     )

      UpperCAmelCase_   ,   UpperCAmelCase_   ,   UpperCAmelCase_	:						Union[str, Any]					   =		jax.lax.map(f=__snake_case       ,	xs=jnp.arange(0       ,	__snake_case       ,	__snake_case     )     )

      UpperCAmelCase_	:						List[str]					   =		jnp.max(__snake_case       ,	axis=0       ,	keepdims=__snake_case     )
      UpperCAmelCase_	:						Union[str, Any]					   =		jnp.exp(chunk_max - global_max     )

      chunk_values *= jnp.expand_dims(__snake_case       ,	axis=-1     )
      chunk_weights *= max_diffs

      UpperCAmelCase_	:						Tuple					   =		chunk_values.sum(axis=0     )
      UpperCAmelCase_	:						Any					   =		jnp.expand_dims(__snake_case       ,	-1     ).sum(axis=0     )

      return all_values / all_weights







def  _snake_case			(							__snake_case       ,	__snake_case       ,	__snake_case       ,	__snake_case=jax.lax.Precision.HIGHEST       ,	__snake_case = 1_0_2_4       ,	__snake_case = 4_0_9_6     )  ->  List[str]:






      '''simple docstring'''







      UpperCAmelCase_   ,   UpperCAmelCase_   ,   UpperCAmelCase_	:						Optional[Any]					   =		query.shape[-3:]

      def chunk_scanner(__snake_case       ,	__snake_case     ):
            # julienne query array
            UpperCAmelCase_	:						str					   =		jax.lax.dynamic_slice(
                operand=__snake_case       ,	start_indices=([0] * (query.ndim - 3)) + [chunk_idx, 0, 0]       ,	slice_sizes=list(query.shape[:-3]     ) + [min(__snake_case       ,	__snake_case     ), num_heads, q_features]       ,	)

            return (
                chunk_idx + query_chunk_size,  # unused ignore it
                _query_chunk_attention(
                    query=__snake_case       ,	key=__snake_case       ,	value=__snake_case       ,	precision=__snake_case       ,	key_chunk_size=__snake_case     ),
            )

      UpperCAmelCase_   ,   UpperCAmelCase_	:						Optional[int]					   =		jax.lax.scan(
          f=__snake_case       ,	init=0       ,	xs=__snake_case       ,	length=math.ceil(num_q / query_chunk_size     )     )

      return jnp.concatenate(__snake_case       ,	axis=-3     )  # fuse the chunked result back


class 	snake_case_			(nn.Module	):




       """simple docstring"""






       _lowerCamelCase           =					42
       _lowerCamelCase           =					8
       _lowerCamelCase           =					64
       _lowerCamelCase           =					0.0
       _lowerCamelCase           =					False
       _lowerCamelCase           =					jnp.floataa



       def 			A_ (  self):

             """simple docstring"""





             UpperCAmelCase_	:						Optional[Any]					   =		self.dim_head * self.heads
             UpperCAmelCase_	:						Union[str, Any]					   =		self.dim_head**-0.5

             # Weights were exported with old names {to_q, to_k, to_v, to_out}
             UpperCAmelCase_	:						Optional[int]					   =		nn.Dense(lowercase  ,use_bias=lowercase  ,dtype=self.dtype  ,name="to_q")
             UpperCAmelCase_	:						Union[str, Any]					   =		nn.Dense(lowercase  ,use_bias=lowercase  ,dtype=self.dtype  ,name="to_k")
             UpperCAmelCase_	:						Union[str, Any]					   =		nn.Dense(lowercase  ,use_bias=lowercase  ,dtype=self.dtype  ,name="to_v")

             UpperCAmelCase_	:						Dict					   =		nn.Dense(self.query_dim  ,dtype=self.dtype  ,name="to_out_0")
             UpperCAmelCase_	:						Optional[int]					   =		nn.Dropout(rate=self.dropout)



       def 			A_ (  self  ,lowercase):

             """simple docstring"""





             UpperCAmelCase_   ,   UpperCAmelCase_   ,   UpperCAmelCase_	:						Tuple					   =		tensor.shape
             UpperCAmelCase_	:						Union[str, Any]					   =		self.heads
             UpperCAmelCase_	:						Tuple					   =		tensor.reshape(lowercase  ,lowercase  ,lowercase  ,dim // head_size)
             UpperCAmelCase_	:						List[Any]					   =		jnp.transpose(lowercase  ,(0, 2, 1, 3))
             UpperCAmelCase_	:						Dict					   =		tensor.reshape(batch_size * head_size  ,lowercase  ,dim // head_size)
             return tensor



       def 			A_ (  self  ,lowercase):

             """simple docstring"""





             UpperCAmelCase_   ,   UpperCAmelCase_   ,   UpperCAmelCase_	:						int					   =		tensor.shape
             UpperCAmelCase_	:						List[Any]					   =		self.heads
             UpperCAmelCase_	:						Optional[Any]					   =		tensor.reshape(batch_size // head_size  ,lowercase  ,lowercase  ,lowercase)
             UpperCAmelCase_	:						List[Any]					   =		jnp.transpose(lowercase  ,(0, 2, 1, 3))
             UpperCAmelCase_	:						Any					   =		tensor.reshape(batch_size // head_size  ,lowercase  ,dim * head_size)
             return tensor



       def __call__(  self  ,lowercase  ,lowercase=None  ,lowercase=True):

             """simple docstring"""





             UpperCAmelCase_	:						Dict					   =		hidden_states if context is None else context

             UpperCAmelCase_	:						int					   =		self.query(lowercase)
             UpperCAmelCase_	:						List[str]					   =		self.key(lowercase)
             UpperCAmelCase_	:						Tuple					   =		self.value(lowercase)

             UpperCAmelCase_	:						Dict					   =		self.reshape_heads_to_batch_dim(lowercase)
             UpperCAmelCase_	:						List[Any]					   =		self.reshape_heads_to_batch_dim(lowercase)
             UpperCAmelCase_	:						Union[str, Any]					   =		self.reshape_heads_to_batch_dim(lowercase)

             if self.use_memory_efficient_attention:
                   UpperCAmelCase_	:						Tuple					   =		query_states.transpose(1  ,0  ,2)
                   UpperCAmelCase_	:						int					   =		key_states.transpose(1  ,0  ,2)
                   UpperCAmelCase_	:						List[str]					   =		value_states.transpose(1  ,0  ,2)

                   # this if statement create a chunk size for each layer of the unet
                   # the chunk size is equal to the query_length dimension of the deepest layer of the unet

                   UpperCAmelCase_	:						Union[str, Any]					   =		query_states.shape[-3]
                   if flatten_latent_dim % 64 == 0:
                         UpperCAmelCase_	:						Union[str, Any]					   =		int(flatten_latent_dim / 64)
                   elif flatten_latent_dim % 16 == 0:
                         UpperCAmelCase_	:						List[Any]					   =		int(flatten_latent_dim / 16)
                   elif flatten_latent_dim % 4 == 0:
                         UpperCAmelCase_	:						int					   =		int(flatten_latent_dim / 4)
                   else:
                         UpperCAmelCase_	:						Dict					   =		int(lowercase)

                   UpperCAmelCase_	:						str					   =		jax_memory_efficient_attention(
                       lowercase  ,lowercase  ,lowercase  ,query_chunk_size=lowercase  ,key_chunk_size=4096 * 4)

                   UpperCAmelCase_	:						Optional[int]					   =		hidden_states.transpose(1  ,0  ,2)
             else:
                   # compute attentions
                   UpperCAmelCase_	:						str					   =		jnp.einsum("b i d, b j d->b i j"  ,lowercase  ,lowercase)
                   UpperCAmelCase_	:						int					   =		attention_scores * self.scale
                   UpperCAmelCase_	:						List[str]					   =		nn.softmax(lowercase  ,axis=2)

                   # attend to values
                   UpperCAmelCase_	:						Any					   =		jnp.einsum("b i j, b j d -> b i d"  ,lowercase  ,lowercase)

             UpperCAmelCase_	:						int					   =		self.reshape_batch_dim_to_heads(lowercase)
             UpperCAmelCase_	:						Any					   =		self.proj_attn(lowercase)
             return self.dropout_layer(lowercase  ,deterministic=lowercase)


class 	snake_case_			(nn.Module	):




       """simple docstring"""






       _lowerCamelCase           =					42
       _lowerCamelCase           =					42
       _lowerCamelCase           =					42
       _lowerCamelCase           =					0.0
       _lowerCamelCase           =					False
       _lowerCamelCase           =					jnp.floataa
       _lowerCamelCase           =					False



       def 			A_ (  self):

             """simple docstring"""





             UpperCAmelCase_	:						Any					   =		FlaxAttention(
                 self.dim  ,self.n_heads  ,self.d_head  ,self.dropout  ,self.use_memory_efficient_attention  ,dtype=self.dtype)
             # cross attention
             UpperCAmelCase_	:						Any					   =		FlaxAttention(
                 self.dim  ,self.n_heads  ,self.d_head  ,self.dropout  ,self.use_memory_efficient_attention  ,dtype=self.dtype)
             UpperCAmelCase_	:						Optional[Any]					   =		FlaxFeedForward(dim=self.dim  ,dropout=self.dropout  ,dtype=self.dtype)
             UpperCAmelCase_	:						Tuple					   =		nn.LayerNorm(epsilon=1E-5  ,dtype=self.dtype)
             UpperCAmelCase_	:						Union[str, Any]					   =		nn.LayerNorm(epsilon=1E-5  ,dtype=self.dtype)
             UpperCAmelCase_	:						Dict					   =		nn.LayerNorm(epsilon=1E-5  ,dtype=self.dtype)
             UpperCAmelCase_	:						Dict					   =		nn.Dropout(rate=self.dropout)



       def __call__(  self  ,lowercase  ,lowercase  ,lowercase=True):

             """simple docstring"""





             UpperCAmelCase_	:						Optional[int]					   =		hidden_states
             if self.only_cross_attention:
                   UpperCAmelCase_	:						Any					   =		self.attna(self.norma(lowercase)  ,lowercase  ,deterministic=lowercase)
             else:
                   UpperCAmelCase_	:						Optional[int]					   =		self.attna(self.norma(lowercase)  ,deterministic=lowercase)
             UpperCAmelCase_	:						Dict					   =		hidden_states + residual

             # cross attention
             UpperCAmelCase_	:						Tuple					   =		hidden_states
             UpperCAmelCase_	:						Tuple					   =		self.attna(self.norma(lowercase)  ,lowercase  ,deterministic=lowercase)
             UpperCAmelCase_	:						int					   =		hidden_states + residual

             # feed forward
             UpperCAmelCase_	:						List[Any]					   =		hidden_states
             UpperCAmelCase_	:						Union[str, Any]					   =		self.ff(self.norma(lowercase)  ,deterministic=lowercase)
             UpperCAmelCase_	:						str					   =		hidden_states + residual

             return self.dropout_layer(lowercase  ,deterministic=lowercase)


class 	snake_case_			(nn.Module	):




       """simple docstring"""






       _lowerCamelCase           =					42
       _lowerCamelCase           =					42
       _lowerCamelCase           =					42
       _lowerCamelCase           =					1
       _lowerCamelCase           =					0.0
       _lowerCamelCase           =					False
       _lowerCamelCase           =					False
       _lowerCamelCase           =					jnp.floataa
       _lowerCamelCase           =					False



       def 			A_ (  self):

             """simple docstring"""





             UpperCAmelCase_	:						int					   =		nn.GroupNorm(num_groups=32  ,epsilon=1E-5)

             UpperCAmelCase_	:						str					   =		self.n_heads * self.d_head
             if self.use_linear_projection:
                   UpperCAmelCase_	:						Dict					   =		nn.Dense(lowercase  ,dtype=self.dtype)
             else:
                   UpperCAmelCase_	:						str					   =		nn.Conv(
                       lowercase  ,kernel_size=(1, 1)  ,strides=(1, 1)  ,padding="VALID"  ,dtype=self.dtype  ,)

             UpperCAmelCase_	:						Optional[int]					   =		[
                 FlaxBasicTransformerBlock(
                     lowercase  ,self.n_heads  ,self.d_head  ,dropout=self.dropout  ,only_cross_attention=self.only_cross_attention  ,dtype=self.dtype  ,use_memory_efficient_attention=self.use_memory_efficient_attention  ,)
                 for _ in range(self.depth)
             ]

             if self.use_linear_projection:
                   UpperCAmelCase_	:						List[str]					   =		nn.Dense(lowercase  ,dtype=self.dtype)
             else:
                   UpperCAmelCase_	:						Tuple					   =		nn.Conv(
                       lowercase  ,kernel_size=(1, 1)  ,strides=(1, 1)  ,padding="VALID"  ,dtype=self.dtype  ,)

             UpperCAmelCase_	:						List[Any]					   =		nn.Dropout(rate=self.dropout)



       def __call__(  self  ,lowercase  ,lowercase  ,lowercase=True):

             """simple docstring"""





             UpperCAmelCase_   ,   UpperCAmelCase_   ,   UpperCAmelCase_   ,   UpperCAmelCase_	:						Optional[int]					   =		hidden_states.shape
             UpperCAmelCase_	:						Optional[int]					   =		hidden_states
             UpperCAmelCase_	:						Dict					   =		self.norm(lowercase)
             if self.use_linear_projection:
                   UpperCAmelCase_	:						List[Any]					   =		hidden_states.reshape(lowercase  ,height * width  ,lowercase)
                   UpperCAmelCase_	:						Optional[int]					   =		self.proj_in(lowercase)
             else:
                   UpperCAmelCase_	:						Optional[Any]					   =		self.proj_in(lowercase)
                   UpperCAmelCase_	:						Optional[Any]					   =		hidden_states.reshape(lowercase  ,height * width  ,lowercase)

             for transformer_block in self.transformer_blocks:
                   UpperCAmelCase_	:						int					   =		transformer_block(lowercase  ,lowercase  ,deterministic=lowercase)

             if self.use_linear_projection:
                   UpperCAmelCase_	:						List[str]					   =		self.proj_out(lowercase)
                   UpperCAmelCase_	:						str					   =		hidden_states.reshape(lowercase  ,lowercase  ,lowercase  ,lowercase)
             else:
                   UpperCAmelCase_	:						str					   =		hidden_states.reshape(lowercase  ,lowercase  ,lowercase  ,lowercase)
                   UpperCAmelCase_	:						Any					   =		self.proj_out(lowercase)

             UpperCAmelCase_	:						str					   =		hidden_states + residual
             return self.dropout_layer(lowercase  ,deterministic=lowercase)


class 	snake_case_			(nn.Module	):




       """simple docstring"""






       _lowerCamelCase           =					42
       _lowerCamelCase           =					0.0
       _lowerCamelCase           =					jnp.floataa



       def 			A_ (  self):

             """simple docstring"""





             UpperCAmelCase_	:						Any					   =		FlaxGEGLU(self.dim  ,self.dropout  ,self.dtype)
             UpperCAmelCase_	:						List[Any]					   =		nn.Dense(self.dim  ,dtype=self.dtype)



       def __call__(  self  ,lowercase  ,lowercase=True):

             """simple docstring"""





             UpperCAmelCase_	:						str					   =		self.net_a(lowercase  ,deterministic=lowercase)
             UpperCAmelCase_	:						List[str]					   =		self.net_a(lowercase)
             return hidden_states


class 	snake_case_			(nn.Module	):




       """simple docstring"""






       _lowerCamelCase           =					42
       _lowerCamelCase           =					0.0
       _lowerCamelCase           =					jnp.floataa



       def 			A_ (  self):

             """simple docstring"""





             UpperCAmelCase_	:						int					   =		self.dim * 4
             UpperCAmelCase_	:						Any					   =		nn.Dense(inner_dim * 2  ,dtype=self.dtype)
             UpperCAmelCase_	:						Optional[int]					   =		nn.Dropout(rate=self.dropout)



       def __call__(  self  ,lowercase  ,lowercase=True):

             """simple docstring"""





             UpperCAmelCase_	:						str					   =		self.proj(lowercase)
             UpperCAmelCase_   ,   UpperCAmelCase_	:						Optional[int]					   =		jnp.split(lowercase  ,2  ,axis=2)
             return self.dropout_layer(hidden_linear * nn.gelu(lowercase)  ,deterministic=lowercase)





import logging
import os
import sys
from dataclasses import dataclass, field
from typing import Optional

import transformers
from transformers import (
    AutoConfig,
    AutoModelForQuestionAnswering,
    AutoTokenizer,
    DataCollatorWithPadding,
    HfArgumentParser,
    SquadDataset,
    Trainer,
    TrainingArguments,
)
from transformers import SquadDataTrainingArguments as DataTrainingArguments
from transformers.trainer_utils import is_main_process


__lowerCamelCase								=      logging.getLogger(__name__)


@dataclass
class 	snake_case_			:




       """simple docstring"""






       _lowerCamelCase           =					field(
           metadata={"""help""": """Path to pretrained model or model identifier from huggingface.co/models"""}	)
       _lowerCamelCase           =					field(
           default=lowercase__			,			metadata={"""help""": """Pretrained config name or path if not the same as model_name"""}	)
       _lowerCamelCase           =					field(
           default=lowercase__			,			metadata={"""help""": """Pretrained tokenizer name or path if not the same as model_name"""}	)
       _lowerCamelCase           =					field(default=lowercase__			,			metadata={"""help""": """Set this flag to use fast tokenization."""}	)
       # If you want to tweak more attributes on your tokenizer, you should do it in a distinct script,
       # or just modify its tokenizer_config.json.
       _lowerCamelCase           =					field(
           default=lowercase__			,			metadata={"""help""": """Where do you want to store the pretrained models downloaded from huggingface.co"""}			,			)







def  _snake_case			(							)  ->  Union[str, Any]:






      '''simple docstring'''







      UpperCAmelCase_	:						Union[str, Any]					   =		HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)     )

      if len(sys.argv     ) == 2 and sys.argv[1].endswith(".json"     ):
            # If we pass only one argument to the script and it's the path to a json file,
            # let's parse it to get our arguments.
            UpperCAmelCase_   ,   UpperCAmelCase_   ,   UpperCAmelCase_	:						Any					   =		parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]     )     )
      else:
            UpperCAmelCase_   ,   UpperCAmelCase_   ,   UpperCAmelCase_	:						Union[str, Any]					   =		parser.parse_args_into_dataclasses()

      if (
          os.path.exists(training_args.output_dir     )
          and os.listdir(training_args.output_dir     )
          and training_args.do_train
          and not training_args.overwrite_output_dir
      ):
            raise ValueError(
                F"""Output directory ({training_args.output_dir}) already exists and is not empty. Use"""
                " --overwrite_output_dir to overcome."     )

      # Setup logging
      logging.basicConfig(
          format="%(asctime)s - %(levelname)s - %(name)s - %(message)s"       ,	datefmt="%m/%d/%Y %H:%M:%S"       ,	level=logging.INFO if training_args.local_rank in [-1, 0] else logging.WARN       ,	)
      logger.warning(
          "Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, 16-bits training: %s"       ,	training_args.local_rank       ,	training_args.device       ,	training_args.n_gpu       ,	bool(training_args.local_rank != -1     )       ,	training_args.fpaa       ,	)
      # Set the verbosity to info of the Transformers logger (on main process only):
      if is_main_process(training_args.local_rank     ):
            transformers.utils.logging.set_verbosity_info()
            transformers.utils.logging.enable_default_handler()
            transformers.utils.logging.enable_explicit_format()
      logger.info("Training/evaluation parameters %s"       ,	__snake_case     )

      # Prepare Question-Answering task
      # Load pretrained model and tokenizer
      #
      # Distributed training:
      # The .from_pretrained methods guarantee that only one local process can concurrently
      # download model & vocab.

      UpperCAmelCase_	:						Any					   =		AutoConfig.from_pretrained(
          model_args.config_name if model_args.config_name else model_args.model_name_or_path       ,	cache_dir=model_args.cache_dir       ,	)
      UpperCAmelCase_	:						List[str]					   =		AutoTokenizer.from_pretrained(
          model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path       ,	cache_dir=model_args.cache_dir       ,	use_fast=__snake_case       ,	)
      UpperCAmelCase_	:						Optional[int]					   =		AutoModelForQuestionAnswering.from_pretrained(
          model_args.model_name_or_path       ,	from_tf=bool(".ckpt" in model_args.model_name_or_path     )       ,	config=__snake_case       ,	cache_dir=model_args.cache_dir       ,	)

      # Get datasets
      UpperCAmelCase_	:						str					   =		hasattr(model.config       ,	"lang2id"     )
      UpperCAmelCase_	:						Optional[Any]					   =		(
          SquadDataset(
              __snake_case       ,	tokenizer=__snake_case       ,	is_language_sensitive=__snake_case       ,	cache_dir=model_args.cache_dir     )
          if training_args.do_train
          else None
      )
      UpperCAmelCase_	:						Optional[Any]					   =		(
          SquadDataset(
              __snake_case       ,	tokenizer=__snake_case       ,	mode="dev"       ,	is_language_sensitive=__snake_case       ,	cache_dir=model_args.cache_dir       ,	)
          if training_args.do_eval
          else None
      )

      # Data collator
      UpperCAmelCase_	:						Optional[Any]					   =		DataCollatorWithPadding(__snake_case       ,	pad_to_multiple_of=8     ) if training_args.fpaa else None

      # Initialize our Trainer
      UpperCAmelCase_	:						Any					   =		Trainer(
          model=__snake_case       ,	args=__snake_case       ,	train_dataset=__snake_case       ,	eval_dataset=__snake_case       ,	data_collator=__snake_case       ,	)

      # Training
      if training_args.do_train:
            trainer.train(
                model_path=model_args.model_name_or_path if os.path.isdir(model_args.model_name_or_path     ) else None     )
            trainer.save_model()
            # For convenience, we also re-save the tokenizer to the same directory,
            # so that you can share your model easily on huggingface.co/models =)
            if trainer.is_world_master():
                  tokenizer.save_pretrained(training_args.output_dir     )







def  _snake_case			(							__snake_case     )  ->  List[str]:






      '''simple docstring'''







      main()


if __name__ == "__main__":
   main()
