





'''simple docstring'''







from __future__ import annotations

from collections.abc import Sequence
from typing import Literal

def    __UpperCamelCase	(	a    : str					,   a    : str     ) ->str | Literal[False]:
 snake_case				=			list(a     )
 snake_case				=			list(a     )
 snake_case				=			0
 for i in range(len(a     )     ):
  if lista[i] != lista[i]:
   count += 1
   snake_case				=			'''_'''
 if count > 1:
  return False
 else:
  return "".join(a     )

def    __UpperCamelCase	(	a    : list[str]     ) ->list[str]:
 snake_case				=			[]
 while True:
  snake_case				=			['''$'''] * len(a     )
  snake_case				=			[]
  for i in range(len(a     )     ):
   for j in range(i + 1					,   len(a     )     ):
    snake_case				=			compare_string(binary[i]					,   binary[j]     )
    if k is False:
     snake_case				=			'''*'''
     snake_case				=			'''*'''
     temp.append('''X'''     )
  for i in range(len(a     )     ):
   if checka[i] == "$":
    pi.append(binary[i]     )
  if len(a     ) == 0:
   return pi
  snake_case				=			list(set(a     )     )

def    __UpperCamelCase	(	a    : int					,   a    : Sequence[float]     ) ->list[str]:
 snake_case				=			[]
 for minterm in minterms:
  snake_case				=			''''''
  for _ in range(a     ):
   snake_case				=			str(minterm % 2     ) + string
   minterm //= 2
  temp.append(a     )
 return temp

def    __UpperCamelCase	(	a    : str					,   a    : str					,   a    : int     ) ->bool:
 snake_case				=			list(a     )
 snake_case				=			list(a     )
 snake_case				=			0
 for i in range(len(a     )     ):
  if lista[i] != lista[i]:
   count_n += 1
 return count_n == count

def    __UpperCamelCase	(	a    : list[list[int]]					,   a    : list[str]     ) ->list[str]:
 snake_case				=			[]
 snake_case				=			[0] * len(a     )
 for i in range(len(chart[0]     )     ):
  snake_case				=			0
  snake_case				=			-1
  for j in range(len(a     )     ):
   if chart[j][i] == 1:
    count += 1
    snake_case				=			j
  if count == 1:
   snake_case				=			1
 for i in range(len(a     )     ):
  if select[i] == 1:
   for j in range(len(chart[0]     )     ):
    if chart[i][j] == 1:
     for k in range(len(a     )     ):
      snake_case				=			0
   temp.append(prime_implicants[i]     )
 while True:
  snake_case				=			0
  snake_case				=			-1
  snake_case				=			0
  for i in range(len(a     )     ):
   snake_case				=			chart[i].count(1     )
   if count_n > max_n:
    snake_case				=			count_n
    snake_case				=			i

  if max_n == 0:
   return temp

  temp.append(prime_implicants[rem]     )

  for i in range(len(chart[0]     )     ):
   if chart[rem][i] == 1:
    for j in range(len(a     )     ):
     snake_case				=			0

def    __UpperCamelCase	(	a    : list[str]					,   a    : list[str]     ) ->list[list[int]]:
 snake_case				=			[[0 for x in range(len(a     )     )] for x in range(len(a     )     )]
 for i in range(len(a     )     ):
  snake_case				=			prime_implicants[i].count('''_'''     )
  for j in range(len(a     )     ):
   if is_for_table(prime_implicants[i]					,   binary[j]					,   a     ):
    snake_case				=			1

 return chart

def    __UpperCamelCase	(	) ->None:
 snake_case				=			int(input('''Enter the no. of variables\n'''     )     )
 snake_case				=			[
     float(a     )
     for x in input(
         '''Enter the decimal representation of Minterms \'Spaces Separated\'\n'''     ).split()
 ]
 snake_case				=			decimal_to_binary(a					,   a     )

 snake_case				=			check(a     )
 print('''Prime Implicants are:'''     )
 print(a     )
 snake_case				=			prime_implicant_chart(a					,   a     )

 snake_case				=			selection(a					,   a     )
 print('''Essential Prime Implicants are:'''     )
 print(a     )


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   main()








'''simple docstring'''







from ...processing_utils import ProcessorMixin
class 			_lowercase						(       __a					):
     _UpperCAmelCase										=					'''WhisperFeatureExtractor'''
     _UpperCAmelCase										=					'''WhisperTokenizer'''







     def __init__( self    ,   A__    ,   A__    ) ->	Optional[Any]:
      super().__init__(A__    ,   A__    )
      snake_case				=			self.feature_extractor
      snake_case				=			False







     def     UpperCamelCase			( self    ,   A__=None    ,   A__=None    ,   A__=True    ) ->	Union[str, Any]:
      return self.tokenizer.get_decoder_prompt_ids(task=A__    ,   language=A__    ,   no_timestamps=A__    )







     def __call__( self    ,   *A__    ,   **A__    ) ->	Dict:
      # For backward compatibility
      if self._in_target_context_manager:
       return self.current_processor(*A__    ,   **A__    )

      snake_case				=			kwargs.pop('''audio'''    ,   A__    )
      snake_case				=			kwargs.pop('''sampling_rate'''    ,   A__    )
      snake_case				=			kwargs.pop('''text'''    ,   A__    )
      if len(A__    ) > 0:
       snake_case				=			args[0]
       snake_case				=			args[1:]

      if audio is None and text is None:
       raise ValueError('''You need to specify either an `audio` or `text` input to process.'''    )

      if audio is not None:
       snake_case				=			self.feature_extractor(A__    ,   *A__    ,   sampling_rate=A__    ,   **A__    )
      if text is not None:
       snake_case				=			self.tokenizer(A__    ,   **A__    )

      if text is None:
       return inputs

      elif audio is None:
       return encodings
      else:
       snake_case				=			encodings['''input_ids''']
       return inputs







     def     UpperCamelCase			( self    ,   *A__    ,   **A__    ) ->	Optional[Any]:
      return self.tokenizer.batch_decode(*A__    ,   **A__    )







     def     UpperCamelCase			( self    ,   *A__    ,   **A__    ) ->	str:
      return self.tokenizer.decode(*A__    ,   **A__    )







     def     UpperCamelCase			( self    ,   A__    ,   A__="np"    ) ->	Optional[Any]:
      return self.tokenizer.get_prompt_ids(A__    ,   return_tensors=A__    )

