code: 
  
  
  
  
  
  
  from __future__ import annotations
  
  from queue import Queue
  
  
  
  
  class 					UpperCamelCase	:
  
  
  
  
  					def __init__( self :					str						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     {}
  
  
  
  
  					def 							UpperCamelCase_						( self :					Tuple						):
  
  
  							"""simple docstring"""
  
  
  
  
  							for i in self.vertices:
  									print(_lowerCAmelCase      ," : "      ," -> ".join([str(_lowerCAmelCase						) for j in self.vertices[i]]						)						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					Tuple      ,_lowerCAmelCase :					int      ,_lowerCAmelCase :					int						):
  
  
  							"""simple docstring"""
  
  
  
  
  							if from_vertex in self.vertices:
  									self.vertices[from_vertex].append(_lowerCAmelCase						)
  							else:
  									__snake_case		       =     [to_vertex]
  
  
  
  
  
  
  
  					def 							UpperCamelCase_						( self :					Any      ,_lowerCAmelCase :					int						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     set()
  
  							# create a first in first out queue to store all the vertices for BFS
  							__snake_case		       =     Queue()
  
  							# mark the source node as visited and enqueue it
  							visited.add(_lowerCAmelCase						)
  							queue.put(_lowerCAmelCase						)
  
  							while not queue.empty():
  									__snake_case		       =     queue.get()
  
  									# loop through all adjacent vertex and enqueue it if not yet visited
  									for adjacent_vertex in self.vertices[vertex]:
  											if adjacent_vertex not in visited:
  													queue.put(_lowerCAmelCase						)
  													visited.add(_lowerCAmelCase						)
  							return visited
  
  
  if __name__ == "__main__":
  		from doctest import testmod
  
  		testmod(verbose=True)
  
  		lowerCamelCase__           =				Graph()
  		g.add_edge(0, 1)
  		g.add_edge(0, 2)
  		g.add_edge(1, 2)
  		g.add_edge(2, 0)
  		g.add_edge(2, 3)
  		g.add_edge(3, 3)
  
  		g.print_graph()
  		# 0  :  1 -> 2
  		# 1  :  2
  		# 2  :  0 -> 3
  		# 3  :  3
  
  		assert sorted(g.bfs(2)) == [0, 1, 2, 3]
  
  
  
  
  
  
style_context: import os
  from shutil import copyfile
  from typing import Optional, Tuple
  
  from ...tokenization_utils_fast import PreTrainedTokenizerFast
  from ...utils import is_sentencepiece_available, logging
  
  
  if is_sentencepiece_available():
  		from .tokenization_reformer import ReformerTokenizer
  else:
  		lowerCamelCase__           =				None
  
  
  lowerCamelCase__           =				logging.get_logger(__name__)
  
  
  lowerCamelCase__           =				'▁'
  
  lowerCamelCase__           =				{'vocab_file': 'spiece.model', 'tokenizer_file': 'tokenizer.json'}
  
  lowerCamelCase__           =				{
      'vocab_file': {
          'google/reformer-crime-and-punishment': (
              'https://huggingface.co/google/reformer-crime-and-punishment/resolve/main/spiece.model'
          )
      },
      'tokenizer_file': {
          'google/reformer-crime-and-punishment': (
              'https://huggingface.co/google/reformer-crime-and-punishment/resolve/main/tokenizer.json'
          )
      },
  }
  
  lowerCamelCase__           =				{
      'google/reformer-crime-and-punishment': 52_42_88,
  }
  
  
  
  
  class 					UpperCamelCase	(     snake_case__      ):
  					__UpperCamelCase						=   VOCAB_FILES_NAMES
  					__UpperCamelCase						=   PRETRAINED_VOCAB_FILES_MAP
  					__UpperCamelCase						=   PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  					__UpperCamelCase						=   ["""input_ids""", """attention_mask"""]
  					__UpperCamelCase						=   ReformerTokenizer
  
  
  
  
  					def __init__( self :					Tuple      ,_lowerCAmelCase :					Dict=None      ,_lowerCAmelCase :					Union[str, Any]=None      ,_lowerCAmelCase :					int="</s>"      ,_lowerCAmelCase :					Dict="<unk>"      ,_lowerCAmelCase :					Dict=[]      ,**_lowerCAmelCase :					Optional[Any]      ,):
  
  
  							"""simple docstring"""
  
  
  
  
  							super().__init__(
  							    _lowerCAmelCase      ,tokenizer_file=_lowerCAmelCase      ,eos_token=_lowerCAmelCase      ,unk_token=_lowerCAmelCase      ,additional_special_tokens=_lowerCAmelCase      ,**_lowerCAmelCase      ,)
  
  							__snake_case		       =     vocab_file
  							__snake_case		       =     False if not self.vocab_file else True
  
  
  
  
  
  
  
  					def 							UpperCamelCase_						( self :					Dict      ,_lowerCAmelCase :					str      ,_lowerCAmelCase :					Optional[str] = None						):
  
  
  							"""simple docstring"""
  
  
  
  
  							if not self.can_save_slow_tokenizer:
  									raise ValueError(
  									    "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow "
  									    "tokenizer."						)
  
  							if not os.path.isdir(_lowerCAmelCase						):
  									logger.error(F"""Vocabulary path ({save_directory}) should be a directory"""						)
  									return
  							__snake_case		       =     os.path.join(
  							    _lowerCAmelCase      ,(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]						)
  
  							if os.path.abspath(self.vocab_file						) != os.path.abspath(_lowerCAmelCase						):
  									copyfile(self.vocab_file      ,_lowerCAmelCase						)
  
  							return (out_vocab_file,)
  
  
  
  
  
  