code: 
  
  
  
  """simple docstring"""
  
  
  
  
  from transformers import (
      DPRContextEncoderTokenizer,
      DPRContextEncoderTokenizerFast,
      DPRQuestionEncoderTokenizer,
      DPRQuestionEncoderTokenizerFast,
      DPRReaderOutput,
      DPRReaderTokenizer,
      DPRReaderTokenizerFast,
  )
  from transformers.testing_utils import require_tokenizers, slow
  from transformers.tokenization_utils_base import BatchEncoding
  
  from ..bert.test_tokenization_bert import BertTokenizationTest
  @require_tokenizers
  class 							lowerCamelCase		( UpperCamelCase__				):
     lowercase       :  str      =				DPRContextEncoderTokenizer
     lowercase       :  Any      =				DPRContextEncoderTokenizerFast
     lowercase       :  Union[str, Any]      =				True
  
  
  
  
  
  
  
  @require_tokenizers
  class 							lowerCamelCase		( UpperCamelCase__				):
     lowercase       :  Union[str, Any]      =				DPRQuestionEncoderTokenizer
     lowercase       :  Dict      =				DPRQuestionEncoderTokenizerFast
     lowercase       :  Optional[Any]      =				True
  
  
  
  
  
  
  
  @require_tokenizers
  class 							lowerCamelCase		( UpperCamelCase__				):
     lowercase       :  int      =				DPRReaderTokenizer
     lowercase       :  Optional[Any]      =				DPRReaderTokenizerFast
     lowercase       :  List[str]      =				True
  
  
  
  
  
  
  
     @slow
     def       a_							(							self ):
         UpperCamelCase				:   List[Any]          =							self.tokenizer_class.from_pretrained("""bert-base-uncased""" )
  
         UpperCamelCase				:   List[Any]          =							tokenizer.encode("""question sequence"""    ,      add_special_tokens=snake_case_ )
         UpperCamelCase				:   str          =							tokenizer.encode("""title sequence"""    ,      add_special_tokens=snake_case_ )
         UpperCamelCase				:   Optional[int]          =							tokenizer.encode("""text sequence """ * 4    ,      add_special_tokens=snake_case_ )
         UpperCamelCase				:   List[Any]          =							[[101] + text_a + [102] + text_a + [102] + text_a]
         UpperCamelCase				:   Union[str, Any]          =							BatchEncoding({"""input_ids""": input_ids} )
  
         UpperCamelCase				:   List[Any]          =							[[0] * len(input_ids[0] )]
         UpperCamelCase				:   List[Any]          =							[[0] * len(input_ids[0] )]
         UpperCamelCase				:   List[Any]          =							[0]
         UpperCamelCase				:   Optional[Any]          =							DPRReaderOutput(snake_case_    ,      snake_case_    ,      snake_case_ )
  
         UpperCamelCase				:   int          =							8, 9
         UpperCamelCase				:   Optional[int]          =							10
         UpperCamelCase				:   Any          =							10
         UpperCamelCase				:   Optional[Any]          =							tokenizer.decode_best_spans(snake_case_    ,      snake_case_ )
         self.assertEqual(predicted_spans[0].start_index    ,      snake_case_ )
         self.assertEqual(predicted_spans[0].end_index    ,      snake_case_ )
         self.assertEqual(predicted_spans[0].doc_id    ,      0 )
  
  
  
  
  
  
  
     @slow
     def       a_							(							self ):
         UpperCamelCase				:   List[str]          =							self.tokenizer_class.from_pretrained("""bert-base-uncased""" )
  
         UpperCamelCase				:   Optional[Any]          =							tokenizer.encode("""question sequence"""    ,      add_special_tokens=snake_case_ )
         UpperCamelCase				:   Dict          =							tokenizer.encode("""title sequence"""    ,      add_special_tokens=snake_case_ )
         UpperCamelCase				:   str          =							tokenizer.encode("""text sequence"""    ,      add_special_tokens=snake_case_ )
         UpperCamelCase				:   List[Any]          =							[101] + text_a + [102] + text_a + [102] + text_a
         UpperCamelCase				:   Tuple          =							tokenizer(questions=["""question sequence"""]    ,      titles=["""title sequence"""]    ,      texts=["""text sequence"""] )
         self.assertIn("""input_ids"""    ,      snake_case_ )
         self.assertIn("""attention_mask"""    ,      snake_case_ )
         self.assertListEqual(encoded_input["""input_ids"""][0]    ,      snake_case_ )
  
  
  
  
  
style_context: 
  
  
  
  
  """simple docstring"""
  
  
  
  
  def 					A_			(		snake_case_     :       Tuple						,snake_case_     :       Optional[Any]						,snake_case_     :       Optional[Any]    ):
  
  
  
  
  
  
  
      '''simple docstring'''
      assert b != 0, "This cannot accept modulo that is == 0"
      if n == 0:
          return 1
  
      if n % 2 == 1:
          return (bin_exp_mod(snake_case_						,n - 1						,snake_case_    ) * a) % b
  
      UpperCamelCase				:   List[Any]          =							bin_exp_mod(snake_case_						,n / 2						,snake_case_    )
      return (r * r) % b
  
  
  if __name__ == "__main__":
    try:
      __A :		Any      							=    int(input('''Enter Base : ''').strip())
      __A :		Any      							=    int(input('''Enter Power : ''').strip())
      __A :		List[Any]      							=    int(input('''Enter Modulo : ''').strip())
    except ValueError:
      print('''Invalid literal for integer''')
  
    print(bin_exp_mod(BASE, POWER, MODULO))
  
  
  
  
  