




def      A      (      _SCREAMING_SNAKE_CASE    )	-> str:
       lowerCamelCase   :      Optional[Any]			 =					0

       # if input_string is "aba" than new_input_string become "a|b|a"
       lowerCamelCase   :      List[str]			 =					""
       lowerCamelCase   :      List[str]			 =					""

       # append each character + "|" in new_string for range(0, length-1)
       for i in input_string[: len(__a    ) - 1]:
              new_input_string += i + "|"
       # append last character
       new_input_string += input_string[-1]

       # we will store the starting and ending of previous furthest ending palindromic
       # substring
       lowerCamelCase   :      List[Any]			 =					0, 0

       # length[i] shows the length of palindromic substring with center i
       lowerCamelCase   :      Union[str, Any]			 =					[1 for i in range(len(__a    )    )]

       # for each character in new_string find corresponding palindromic string
       lowerCamelCase   :      Tuple			 =					0
       for j in range(len(__a    )    ):
              lowerCamelCase   :      Tuple			 =					1 if j > r else min(length[l + r - j] // 2 ,r - j + 1    )
              while (
                  j - k >= 0
                  and j + k < len(__a    )
                  and new_input_string[k + j] == new_input_string[j - k]
              ):
                     k += 1

              lowerCamelCase   :      Union[str, Any]			 =					2 * k - 1

              # does this string is ending after the previously explored end (that is r) ?
              # if yes the update the new r to the last index of this
              if j + k - 1 > r:
                     lowerCamelCase   :      Dict			 =					j - k + 1  # noqa: E741
                     lowerCamelCase   :      Union[str, Any]			 =					j + k - 1

              # update max_length and start position
              if max_length < length[j]:
                     lowerCamelCase   :      Optional[Any]			 =					length[j]
                     lowerCamelCase   :      int			 =					j

              # create that string
       lowerCamelCase   :      List[str]			 =					new_input_string[start - max_length // 2 : start + max_length // 2 + 1]
       for i in s:
              if i != "|":
                     output_string += i

       return output_string


if __name__ == "__main__":
       import doctest

       doctest.testmod()













class    _SCREAMING_SNAKE_CASE						:







 '''simple docstring'''

 def __init__(self				:   Optional[Any]       , UpperCAmelCase_				:   int)       ->Optional[int]:



   '''simple docstring'''



   lowerCamelCase__:      Any			  =n
   lowerCamelCase__:      Tuple			  =[None] * self.n
   lowerCamelCase__:      str			  =0  # index of the first element
   lowerCamelCase__:      Tuple			  =0
   lowerCamelCase__:      Optional[Any]			  =0

 def __len__(self				:   str)       ->int:



   '''simple docstring'''



   return self.size

 def 							SCREAMING_SNAKE_CASE_					(self				:   int)       ->bool:



   '''simple docstring'''



   return self.size == 0

 def 							SCREAMING_SNAKE_CASE_					(self				:   List[str])       ->str:



   '''simple docstring'''



   return False if self.is_empty() else self.array[self.front]

 def 							SCREAMING_SNAKE_CASE_					(self				:   int       , UpperCAmelCase_				:   Optional[int])       ->str:



   '''simple docstring'''



   if self.size >= self.n:
     raise Exception("QUEUE IS FULL")

   lowerCamelCase__:      List[Any]			  =data
   lowerCamelCase__:      Dict			  =(self.rear + 1) % self.n
   self.size += 1
   return self







 def 							SCREAMING_SNAKE_CASE_					(self				:   Tuple)       ->Tuple:



   '''simple docstring'''



   if self.size == 0:
     raise Exception("UNDERFLOW")

   lowerCamelCase__:      Optional[Any]			  =self.array[self.front]
   lowerCamelCase__:      Optional[int]			  =None
   lowerCamelCase__:      Dict			  =(self.front + 1) % self.n
   self.size -= 1
   return temp

