
'''simple docstring'''






def 		A_							(						_lowerCAmelCase :     Union[str, Any]					,						_lowerCAmelCase :     Optional[int]				):



      """simple docstring"""




      _lowerCamelCase					: int		    = ""
      for i in table:
            res += inp[i - 1]
      return res







def 		A_							(						_lowerCAmelCase :     Any				):



      """simple docstring"""




      return data[1:] + data[0]







def 		A_							(						_lowerCAmelCase :     int					,						_lowerCAmelCase :     List[Any]				):



      """simple docstring"""




      _lowerCamelCase					: Optional[int]		    = ""
      for i in range(len(_lowerCAmelCase				)				):
            if a[i] == b[i]:
                  res += "0"
            else:
                  res += "1"
      return res







def 		A_							(						_lowerCAmelCase :     Any					,						_lowerCAmelCase :     str				):



      """simple docstring"""




      _lowerCamelCase					: Optional[Any]		    = int("0b" + data[0] + data[-1]					,						2				)
      _lowerCamelCase					: str		    = int("0b" + data[1:3]					,						2				)
      return bin(s[row][col]				)[2:]







def 		A_							(						_lowerCAmelCase :     str					,						_lowerCAmelCase :     List[str]					,						_lowerCAmelCase :     List[Any]					,						_lowerCAmelCase :     int					,						_lowerCAmelCase :     List[Any]				):



      """simple docstring"""




      _lowerCamelCase					: Union[str, Any]		    = message[:4]
      _lowerCamelCase					: Optional[Any]		    = message[4:]
      _lowerCamelCase					: int		    = apply_table(_lowerCAmelCase					,						_lowerCAmelCase				)
      _lowerCamelCase					: List[str]		    = xor(_lowerCAmelCase					,						_lowerCAmelCase				)
      _lowerCamelCase					: List[str]		    = apply_sbox(_lowerCAmelCase					,						temp[:4]				)  # noqa: E741
      _lowerCamelCase					: int		    = apply_sbox(_lowerCAmelCase					,						temp[4:]				)
      _lowerCamelCase					: Optional[int]		    = "0" * (2 - len(_lowerCAmelCase				)) + l  # noqa: E741
      _lowerCamelCase					: int		    = "0" * (2 - len(_lowerCAmelCase				)) + r
      _lowerCamelCase					: str		    = apply_table(l + r					,						_lowerCAmelCase				)
      _lowerCamelCase					: Union[str, Any]		    = xor(_lowerCAmelCase					,						_lowerCAmelCase				)
      return temp + right


if __name__ == "__main__":
 UpperCAmelCase_							: Dict =							input('Enter 10 bit key: ')
 UpperCAmelCase_							: str =							input('Enter 8 bit message: ')

 UpperCAmelCase_							: List[str] =							[6, 3, 7, 4, 8, 5, 10, 9]
 UpperCAmelCase_							: List[Any] =							[3, 5, 2, 7, 4, 10, 1, 9, 8, 6]
 UpperCAmelCase_							: int =							[2, 4, 3, 1]
 UpperCAmelCase_							: Tuple =							[2, 6, 3, 1, 4, 8, 5, 7]
 UpperCAmelCase_							: Dict =							[4, 1, 3, 5, 7, 2, 8, 6]
 UpperCAmelCase_							: List[Any] =							[4, 1, 2, 3, 2, 3, 4, 1]
 UpperCAmelCase_							: Optional[Any] =							[[1, 0, 3, 2], [3, 2, 1, 0], [0, 2, 1, 3], [3, 1, 3, 2]]
 UpperCAmelCase_							: Optional[Any] =							[[0, 1, 2, 3], [2, 0, 1, 3], [3, 0, 1, 0], [2, 1, 0, 3]]

 # key generation
 UpperCAmelCase_							: List[str] =							apply_table(key, paa_table)
 UpperCAmelCase_							: Union[str, Any] =							temp[:5]
 UpperCAmelCase_							: Union[str, Any] =							temp[5:]
 UpperCAmelCase_							: Optional[int] =							left_shift(left)
 UpperCAmelCase_							: Optional[int] =							left_shift(right)
 UpperCAmelCase_							: Optional[Any] =							apply_table(left + right, pa_table)
 UpperCAmelCase_							: Optional[Any] =							left_shift(left)
 UpperCAmelCase_							: Optional[Any] =							left_shift(right)
 UpperCAmelCase_							: Union[str, Any] =							left_shift(left)
 UpperCAmelCase_							: List[str] =							left_shift(right)
 UpperCAmelCase_							: List[Any] =							apply_table(left + right, pa_table)

 # encryption
 UpperCAmelCase_							: Optional[Any] =							apply_table(message, IP)
 UpperCAmelCase_							: int =							function(expansion, sa, sa, keya, temp)
 UpperCAmelCase_							: Tuple =							temp[4:] + temp[:4]
 UpperCAmelCase_							: Optional[Any] =							function(expansion, sa, sa, keya, temp)
 UpperCAmelCase_							: str =							apply_table(temp, IP_inv)
 print('Cipher text is:', CT)

 # decryption
 UpperCAmelCase_							: Union[str, Any] =							apply_table(CT, IP)
 UpperCAmelCase_							: Any =							function(expansion, sa, sa, keya, temp)
 UpperCAmelCase_							: Optional[int] =							temp[4:] + temp[:4]
 UpperCAmelCase_							: Tuple =							function(expansion, sa, sa, keya, temp)
 UpperCAmelCase_							: Optional[Any] =							apply_table(temp, IP_inv)
 print('Plain text after decypting is:', PT)
from __future__ import annotations

import json

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

SCREAMING_SNAKE_CASE		:     Union[str, Any]         =	{"UserAgent": UserAgent().random}






def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				Dict			):
						UpperCamelCase_		:							Tuple  =		script.contents[0]
						UpperCamelCase_		:							List[Any]  =		json.loads(data[data.find("""{\"config\""""			) : -1]			)
						return info["entry_data"]["ProfilePage"][0]["graphql"]["user"]

class        UpperCamelCase						:





						def __init__(self			,     __UpperCamelCase						)				->				List[str]:
												UpperCamelCase_		:							Union[str, Any]  =		f'''https://www.instagram.com/{username}/'''
												UpperCamelCase_		:							Optional[int]  =		self.get_json()





						def        A_							(self						)				->				dict:
												UpperCamelCase_		:							Optional[Any]  =		requests.get(self.url			,     headers=__UpperCamelCase						).text
												UpperCamelCase_		:							Any  =		BeautifulSoup(__UpperCamelCase			,     """html.parser"""						).find_all("""script"""						)
												try:
																		return extract_user_profile(scripts[4]						)
												except (json.decoder.JSONDecodeError, KeyError):
																		return extract_user_profile(scripts[3]						)





						def __repr__(self						)				->				str:
												return f'''{self.__class__.__name__}(\'{self.username}\')'''





						def __str__(self						)				->				str:
												return f'''{self.fullname} ({self.username}) is {self.biography}'''





						@property
						def        A_							(self						)				->				str:
												return self.user_data["username"]





						@property
						def        A_							(self						)				->				str:
												return self.user_data["full_name"]





						@property
						def        A_							(self						)				->				str:
												return self.user_data["biography"]





						@property
						def        A_							(self						)				->				str:
												return self.user_data["business_email"]





						@property
						def        A_							(self						)				->				str:
												return self.user_data["external_url"]





						@property
						def        A_							(self						)				->				int:
												return self.user_data["edge_followed_by"]["count"]





						@property
						def        A_							(self						)				->				int:
												return self.user_data["edge_follow"]["count"]





						@property
						def        A_							(self						)				->				int:
												return self.user_data["edge_owner_to_timeline_media"]["count"]





						@property
						def        A_							(self						)				->				str:
												return self.user_data["profile_pic_url_hd"]





						@property
						def        A_							(self						)				->				bool:
												return self.user_data["is_verified"]





						@property
						def        A_							(self						)				->				bool:
												return self.user_data["is_private"]






def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				str = "github"			):
						import os

						if os.environ.get("""CI"""			):
												return  # test failing on GitHub Actions
						UpperCamelCase_		:							Any  =		InstagramUser(_SCREAMING_SNAKE_CASE			)
						assert instagram_user.user_data
						assert isinstance(instagram_user.user_data		, _SCREAMING_SNAKE_CASE			)
						assert instagram_user.username == username
						if username != "github":
												return
						assert instagram_user.fullname == "GitHub"
						assert instagram_user.biography == "Built for developers."
						assert instagram_user.number_of_posts > 150
						assert instagram_user.number_of_followers > 12_0000
						assert instagram_user.number_of_followings > 15
						assert instagram_user.email == "support@github.com"
						assert instagram_user.website == "https://github.com/readme"
						assert instagram_user.profile_picture_url.startswith("""https://instagram."""			)
						assert instagram_user.is_verified is True
						assert instagram_user.is_private is False


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	SCREAMING_SNAKE_CASE		:     Dict         =	InstagramUser("github")
	print(instagram_user)
	print(F'''{instagram_user.number_of_posts = }''')
	print(F'''{instagram_user.number_of_followers = }''')
	print(F'''{instagram_user.number_of_followings = }''')
	print(F'''{instagram_user.email = }''')
	print(F'''{instagram_user.website = }''')
	print(F'''{instagram_user.profile_picture_url = }''')
	print(F'''{instagram_user.is_verified = }''')
	print(F'''{instagram_user.is_private = }''')






