'''simple docstring'''


def    _lowerCamelCase       ( lowerCamelCase_   :				str      ,	lowerCamelCase_   :				str  ):



     """simple docstring"""





     if not isinstance(lowerCamelCase_      ,	lowerCamelCase_  ):
          raise TypeError('plaintext must be a string'  )
     if not isinstance(lowerCamelCase_      ,	lowerCamelCase_  ):
          raise TypeError('key must be a string'  )

     if not plaintext:
          raise ValueError('plaintext is empty'  )
     if not key:
          raise ValueError('key is empty'  )

     key += plaintext
     UpperCAmelCase_				:  Optional[Any]  = plaintext.lower()
     UpperCAmelCase_				:  List[str]  = key.lower()
     UpperCAmelCase_				:  List[Any]  = 0
     UpperCAmelCase_				:  Optional[int]  = 0
     UpperCAmelCase_				:  List[Any]  = ''
     while plaintext_iterator < len(lowerCamelCase_  ):
          if (
              ord(plaintext[plaintext_iterator]  ) < 97
              or ord(plaintext[plaintext_iterator]  ) > 122
          ):
               ciphertext += plaintext[plaintext_iterator]
               plaintext_iterator += 1
          elif ord(key[key_iterator]  ) < 97 or ord(key[key_iterator]  ) > 122:
               key_iterator += 1
          else:
               ciphertext += chr(
                   (
                       (ord(plaintext[plaintext_iterator]  ) - 97 + ord(key[key_iterator]  ))
                       - 97
                   )
                   % 26
                   + 97  )
               key_iterator += 1
               plaintext_iterator += 1
     return ciphertext


def    _lowerCamelCase       ( lowerCamelCase_   :				str      ,	lowerCamelCase_   :				str  ):



     """simple docstring"""





     if not isinstance(lowerCamelCase_      ,	lowerCamelCase_  ):
          raise TypeError('ciphertext must be a string'  )
     if not isinstance(lowerCamelCase_      ,	lowerCamelCase_  ):
          raise TypeError('key must be a string'  )

     if not ciphertext:
          raise ValueError('ciphertext is empty'  )
     if not key:
          raise ValueError('key is empty'  )

     UpperCAmelCase_				:  Optional[Any]  = key.lower()
     UpperCAmelCase_				:  int  = 0
     UpperCAmelCase_				:  Optional[Any]  = 0
     UpperCAmelCase_				:  Tuple  = ''
     while ciphertext_iterator < len(lowerCamelCase_  ):
          if (
              ord(ciphertext[ciphertext_iterator]  ) < 97
              or ord(ciphertext[ciphertext_iterator]  ) > 122
          ):
               plaintext += ciphertext[ciphertext_iterator]
          else:
               plaintext += chr(
                   (ord(ciphertext[ciphertext_iterator]  ) - ord(key[key_iterator]  )) % 26
                   + 97  )
               key += chr(
                   (ord(ciphertext[ciphertext_iterator]  ) - ord(key[key_iterator]  )) % 26
                   + 97  )
               key_iterator += 1
          ciphertext_iterator += 1
     return plaintext


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 snake_case__	:     Union[str, Any]      =    int(input('''Type 1 to encrypt or 2 to decrypt:'''))
 if operation == 1:
  snake_case__	:     Dict      =    input('''Typeplaintext to be encrypted:\n''')
  snake_case__	:     List[Any]      =    input('''Type the key:\n''')
  print(encrypt(plaintext, key))
 elif operation == 2:
  snake_case__	:     List[str]      =    input('''Type the ciphertext to be decrypted:\n''')
  snake_case__	:     Optional[int]      =    input('''Type the key:\n''')
  print(decrypt(ciphertext, key))
 decrypt('''jsqqs avvwo''', '''coffee''')







from typing import List

import datasets
from datasets.tasks import ImageClassification

from ..folder_based_builder import folder_based_builder


_SCREAMING_SNAKE_CASE     =     datasets.utils.logging.get_logger(__name__)







class        UpperCAmelCase_					(				folder_based_builder.FolderBasedBuilderConfig     ):
    UpperCAmelCase_      :							bool    			=				None
    UpperCAmelCase_      :							bool    			=				None







class        UpperCAmelCase_					(				folder_based_builder.FolderBasedBuilder     ):
    UpperCAmelCase_      :							Any    			=				datasets.Image()
    UpperCAmelCase_      :							List[Any]    			=				'image'
    UpperCAmelCase_      :							int    			=				ImageFolderConfig
    UpperCAmelCase_      :							List[str]  # definition at the bottom of the script
    UpperCAmelCase_      :							Dict    			=				ImageClassification(image_column='image'  ,  label_column='label'     )

_SCREAMING_SNAKE_CASE     =     [
    """.blp""",
    """.bmp""",
    """.dib""",
    """.bufr""",
    """.cur""",
    """.pcx""",
    """.dcx""",
    """.dds""",
    """.ps""",
    """.eps""",
    """.fit""",
    """.fits""",
    """.fli""",
    """.flc""",
    """.ftc""",
    """.ftu""",
    """.gbr""",
    """.gif""",
    """.grib""",
    """.h5""",
    """.hdf""",
    """.png""",
    """.apng""",
    """.jp2""",
    """.j2k""",
    """.jpc""",
    """.jpf""",
    """.jpx""",
    """.j2c""",
    """.icns""",
    """.ico""",
    """.im""",
    """.iim""",
    """.tif""",
    """.tiff""",
    """.jfif""",
    """.jpe""",
    """.jpg""",
    """.jpeg""",
    """.mpg""",
    """.mpeg""",
    """.msp""",
    """.pcd""",
    """.pxr""",
    """.pbm""",
    """.pgm""",
    """.ppm""",
    """.pnm""",
    """.psd""",
    """.bw""",
    """.rgb""",
    """.rgba""",
    """.sgi""",
    """.ras""",
    """.tga""",
    """.icb""",
    """.vda""",
    """.vst""",
    """.webp""",
    """.wmf""",
    """.emf""",
    """.xbm""",
    """.xpm""",
]
_SCREAMING_SNAKE_CASE     =     IMAGE_EXTENSIONS

