





from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding




class  __UpperCamelCase						(       A__						):
     __A  :     int            =      ["""image_processor""", """tokenizer"""]
     __A  :     List[Any]            =      """EfficientNetImageProcessor"""
     __A  :     Union[str, Any]            =      ("""BertTokenizer""", """BertTokenizerFast""")





     def __init__(    self							,       _UpperCamelCase							,       _UpperCamelCase				):
        super().__init__(_UpperCamelCase							,       _UpperCamelCase				)





     def __call__(    self							,       _UpperCamelCase=None							,       _UpperCamelCase=None							,       _UpperCamelCase="max_length"							,       _UpperCamelCase=64							,       _UpperCamelCase=None							,       **_UpperCamelCase				):
        if text is None and images is None:
           raise ValueError('''You have to specify either text or images. Both cannot be none.'''				)

        if text is not None:
           _UpperCAmelCase											=      self.tokenizer(
               _UpperCamelCase							,       padding=_UpperCamelCase							,       max_length=_UpperCamelCase							,       return_tensors=_UpperCamelCase							,       **_UpperCamelCase				)

        if images is not None:
           _UpperCAmelCase											=      self.image_processor(_UpperCamelCase							,       return_tensors=_UpperCamelCase							,       **_UpperCamelCase				)

        if text is not None and images is not None:
           _UpperCAmelCase											=      image_features.pixel_values
           return encoding
        elif text is not None:
           return encoding
        else:
           return BatchEncoding(data=dict(**_UpperCamelCase				)							,       tensor_type=_UpperCamelCase				)





     def 		UpperCamelCase(    self							,       *_UpperCamelCase							,       **_UpperCamelCase				):
        return self.tokenizer.batch_decode(*_UpperCamelCase							,       **_UpperCamelCase				)





     def 		UpperCamelCase(    self							,       *_UpperCamelCase							,       **_UpperCamelCase				):
        return self.tokenizer.decode(*_UpperCamelCase							,       **_UpperCamelCase				)





     @property
     def 		UpperCamelCase(    self				):
        _UpperCAmelCase											=      self.tokenizer.model_input_names
        _UpperCAmelCase											=      self.image_processor.model_input_names
        return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names				)				)






def     A__					(						SCREAMING_SNAKE_CASE_      :			Optional[int]							,  SCREAMING_SNAKE_CASE_      :			str	)     ->     List[str]:






   """simple docstring"""







   print('''\nVertex Distance'''	)
   for i in range(SCREAMING_SNAKE_CASE_	):
      if dist[i] != float('''inf'''	):
         print(SCREAMING_SNAKE_CASE_							,  '''\t'''							,  int(dist[i]	)							,  end='''\t'''	)
      else:
         print(SCREAMING_SNAKE_CASE_							,  '''\t'''							,  '''INF'''							,  end='''\t'''	)
      print()
def     A__					(						SCREAMING_SNAKE_CASE_      :			Any							,  SCREAMING_SNAKE_CASE_      :			Optional[Any]							,  SCREAMING_SNAKE_CASE_      :			str	)     ->     Any:






   """simple docstring"""







   _UpperCAmelCase											=      float('''inf'''	)
   _UpperCAmelCase											=      -1
   for i in range(SCREAMING_SNAKE_CASE_	):
      if (not vset[i]) and mdist[i] < min_val:
         _UpperCAmelCase											=      i
         _UpperCAmelCase											=      mdist[i]
   return min_ind
def     A__					(						SCREAMING_SNAKE_CASE_      :			str							,  SCREAMING_SNAKE_CASE_      :			Dict							,  SCREAMING_SNAKE_CASE_      :			int	)     ->     Any:






   """simple docstring"""







   _UpperCAmelCase											=      [float('''inf'''	) for _ in range(SCREAMING_SNAKE_CASE_	)]
   _UpperCAmelCase											=      [False for _ in range(SCREAMING_SNAKE_CASE_	)]
   _UpperCAmelCase											=      0.0

   for _ in range(v - 1	):
      _UpperCAmelCase											=      min_dist(SCREAMING_SNAKE_CASE_							,  SCREAMING_SNAKE_CASE_							,  SCREAMING_SNAKE_CASE_	)
      _UpperCAmelCase											=      True

      for i in range(SCREAMING_SNAKE_CASE_	):
         if (
             (not vset[i])
             and graph[u][i] != float('''inf'''	)
             and mdist[u] + graph[u][i] < mdist[i]
         ):
            _UpperCAmelCase											=      mdist[u] + graph[u][i]

   print_dist(SCREAMING_SNAKE_CASE_							,  SCREAMING_SNAKE_CASE_	)


if __name__ == "__main__":
   UpperCAmelCase_											=  int(input("Enter number of vertices: ").strip())
   UpperCAmelCase_											=  int(input("Enter number of edges: ").strip())

   UpperCAmelCase_											=  [[float("inf") for i in range(V)] for j in range(V)]

   for i in range(V):
      UpperCAmelCase_											=  0.0

   for i in range(E):
      print("\nEdge ", i + 1)
      UpperCAmelCase_											=  int(input("Enter source:").strip())
      UpperCAmelCase_											=  int(input("Enter destination:").strip())
      UpperCAmelCase_											=  float(input("Enter weight:").strip())
      UpperCAmelCase_											=  weight

   UpperCAmelCase_											=  int(input("\nEnter shortest path source:").strip())
   dijkstra(graph, V, gsrc)