"""simple docstring"""





from __future__ import annotations

import queue


class 	UpperCAmelCase_      :


      def __init__(  self						,     a				)			->   Dict:
             lowercase__     :						Optional[Any]         =      data
             lowercase__     :						Any         =      None
             lowercase__     :						Optional[Any]         =      None





def 							a_	( ):





       '''simple docstring'''

       print('\n********Press N to stop entering at any point of time********\n'	)
       lowercase__     :						Any         =      input('Enter the value of the root node: '	).strip().lower()
       lowercase__     :						Union[str, Any]         =      queue.Queue()
       lowercase__     :						Optional[int]         =      TreeNode(int(_lowerCAmelCase	)	)
       q.put(_lowerCAmelCase	)
       while not q.empty():
              lowercase__     :						Optional[Any]         =      q.get()
              lowercase__     :						List[Any]         =      f"""Enter the left node of {node_found.data}: """
              lowercase__     :						List[str]         =      input(_lowerCAmelCase	).strip().lower() or 'n'
              if check == "n":
                     return tree_node
              lowercase__     :						Union[str, Any]         =      TreeNode(int(_lowerCAmelCase	)	)
              lowercase__     :						str         =      left_node
              q.put(_lowerCAmelCase	)
              lowercase__     :						str         =      f"""Enter the right node of {node_found.data}: """
              lowercase__     :						Dict         =      input(_lowerCAmelCase	).strip().lower() or 'n'
              if check == "n":
                     return tree_node
              lowercase__     :						int         =      TreeNode(int(_lowerCAmelCase	)	)
              lowercase__     :						int         =      right_node
              q.put(_lowerCAmelCase	)
       raise





def 							a_	( _lowerCAmelCase    :					Any	):





       '''simple docstring'''

       if not isinstance(_lowerCAmelCase  ,					_lowerCAmelCase	) or not node:
              return
       print(node.data  ,					end=','	)
       pre_order(node.left	)
       pre_order(node.right	)





def 							a_	( _lowerCAmelCase    :					Dict	):





       '''simple docstring'''

       if not isinstance(_lowerCAmelCase  ,					_lowerCAmelCase	) or not node:
              return
       in_order(node.left	)
       print(node.data  ,					end=','	)
       in_order(node.right	)





def 							a_	( _lowerCAmelCase    :					Optional[Any]	):





       '''simple docstring'''

       if not isinstance(_lowerCAmelCase  ,					_lowerCAmelCase	) or not node:
              return
       post_order(node.left	)
       post_order(node.right	)
       print(node.data  ,					end=','	)





def 							a_	( _lowerCAmelCase    :					int	):





       '''simple docstring'''

       if not isinstance(_lowerCAmelCase  ,					_lowerCAmelCase	) or not node:
              return
       lowercase__     :						Tuple         =      queue.Queue()
       q.put(_lowerCAmelCase	)
       while not q.empty():
              lowercase__     :						str         =      q.get()
              print(node_dequeued.data  ,					end=','	)
              if node_dequeued.left:
                     q.put(node_dequeued.left	)
              if node_dequeued.right:
                     q.put(node_dequeued.right	)





def 							a_	( _lowerCAmelCase    :					Tuple	):





       '''simple docstring'''

       if not isinstance(_lowerCAmelCase  ,					_lowerCAmelCase	) or not node:
              return
       lowercase__     :						Optional[Any]         =      queue.Queue()
       q.put(_lowerCAmelCase	)
       while not q.empty():
              lowercase__     :						str         =      []
              while not q.empty():
                     lowercase__     :						Optional[int]         =      q.get()
                     print(node_dequeued.data  ,					end=','	)
                     if node_dequeued.left:
                            list_.append(node_dequeued.left	)
                     if node_dequeued.right:
                            list_.append(node_dequeued.right	)
              print()
              for node in list_:
                     q.put(_lowerCAmelCase	)





def 							a_	( _lowerCAmelCase    :					Union[str, Any]	):





       '''simple docstring'''

       if not isinstance(_lowerCAmelCase  ,					_lowerCAmelCase	) or not node:
              return
       lowercase__     :						str         =      []
       lowercase__     :						List[Any]         =      node
       while n or stack:
              while n:  # start from root node, find its left child
                     print(n.data  ,					end=','	)
                     stack.append(_lowerCAmelCase	)
                     lowercase__     :						int         =      n.left
              # end of while means current node doesn't have left child
              lowercase__     :						str         =      stack.pop()
              # start to traverse its right child
              lowercase__     :						Union[str, Any]         =      n.right





def 							a_	( _lowerCAmelCase    :					Any	):





       '''simple docstring'''

       if not isinstance(_lowerCAmelCase  ,					_lowerCAmelCase	) or not node:
              return
       lowercase__     :						Dict         =      []
       lowercase__     :						Dict         =      node
       while n or stack:
              while n:
                     stack.append(_lowerCAmelCase	)
                     lowercase__     :						Any         =      n.left
              lowercase__     :						List[str]         =      stack.pop()
              print(n.data  ,					end=','	)
              lowercase__     :						Dict         =      n.right





def 							a_	( _lowerCAmelCase    :					str	):





       '''simple docstring'''

       if not isinstance(_lowerCAmelCase  ,					_lowerCAmelCase	) or not node:
              return
       lowercase__       , lowercase__     :						Optional[Any]         =      [], []
       lowercase__     :						Optional[Any]         =      node
       stacka.append(_lowerCAmelCase	)
       while stacka:  # to find the reversed order of post order, store it in stack2
              lowercase__     :						Optional[Any]         =      stacka.pop()
              if n.left:
                     stacka.append(n.left	)
              if n.right:
                     stacka.append(n.right	)
              stacka.append(_lowerCAmelCase	)
       while stacka:  # pop up from stack2 will be the post order
              print(stacka.pop().data  ,					end=','	)





def 							a_	( _lowerCAmelCase    :					List[str] = ""  ,					_lowerCAmelCase    :					Optional[Any]=50  ,					_lowerCAmelCase    :					Optional[int]="*"	):





       '''simple docstring'''

       if not s:
              return "\n" + width * char
       lowercase__       , lowercase__     :						Union[str, Any]         =      divmod(width - len(_lowerCAmelCase	) - 2  ,					2	)
       return f"""{left * char} {s} {(left + extra) * char}"""


if __name__ == "__main__":
       import doctest

       doctest.testmod()
       print(prompt("Binary Tree Traversals"))

       _UpperCamelCase  :		Tuple           =       build_tree()
       print(prompt("Pre Order Traversal"))
       pre_order(node)
       print(prompt() + "\n")

       print(prompt("In Order Traversal"))
       in_order(node)
       print(prompt() + "\n")

       print(prompt("Post Order Traversal"))
       post_order(node)
       print(prompt() + "\n")

       print(prompt("Level Order Traversal"))
       level_order(node)
       print(prompt() + "\n")

       print(prompt("Actual Level Order Traversal"))
       level_order_actual(node)
       print("*" * 50 + "\n")

       print(prompt("Pre Order Traversal - Iteration Version"))
       pre_order_iter(node)
       print(prompt() + "\n")

       print(prompt("In Order Traversal - Iteration Version"))
       in_order_iter(node)
       print(prompt() + "\n")

       print(prompt("Post Order Traversal - Iteration Version"))
       post_order_iter(node)
       print(prompt())


"""simple docstring"""


from __future__ import annotations

import json

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

UpperCAmelCase__			=    {"""UserAgent""": UserAgent().random}






def      __UpperCAmelCase       (      lowercase		):







  """simple docstring"""
  _UpperCAmelCase    			=   script.contents[0]
  _UpperCAmelCase    			=   json.loads(data[data.find("""{\"config\""""		) : -1]		)
  return info["entry_data"]["ProfilePage"][0]["graphql"]["user"]


class 							a					:


    def __init__(       self						:	Any ,					__lowerCAmelCase						:	Union[str, Any]       ):
      _UpperCAmelCase    			=   f'''https://www.instagram.com/{username}/'''
      _UpperCAmelCase    			=   self.get_json()


    def   lowerCAmelCase_	(       self						:	int       ):
      _UpperCAmelCase    			=   requests.get(self.url ,					headers=__lowerCAmelCase       ).text
      _UpperCAmelCase    			=   BeautifulSoup(__lowerCAmelCase ,					"""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						:	Dict       ):
      return f'''{self.__class__.__name__}(\'{self.username}\')'''


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


    @property
    def   lowerCAmelCase_	(       self						:	Union[str, Any]       ):
      return self.user_data["username"]


    @property
    def   lowerCAmelCase_	(       self						:	List[Any]       ):
      return self.user_data["full_name"]


    @property
    def   lowerCAmelCase_	(       self						:	str       ):
      return self.user_data["biography"]


    @property
    def   lowerCAmelCase_	(       self						:	str       ):
      return self.user_data["business_email"]


    @property
    def   lowerCAmelCase_	(       self						:	List[Any]       ):
      return self.user_data["external_url"]


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


    @property
    def   lowerCAmelCase_	(       self						:	Tuple       ):
      return self.user_data["edge_follow"]["count"]


    @property
    def   lowerCAmelCase_	(       self						:	List[str]       ):
      return self.user_data["edge_owner_to_timeline_media"]["count"]


    @property
    def   lowerCAmelCase_	(       self						:	int       ):
      return self.user_data["profile_pic_url_hd"]


    @property
    def   lowerCAmelCase_	(       self						:	str       ):
      return self.user_data["is_verified"]


    @property
    def   lowerCAmelCase_	(       self						:	int       ):
      return self.user_data["is_private"]






def      __UpperCAmelCase       (      lowercase = "github"		):







  """simple docstring"""
  import os

  if os.environ.get("""CI"""		):
    return  # test failing on GitHub Actions
  _UpperCAmelCase    			=   InstagramUser(lowercase		)
  assert instagram_user.user_data
  assert isinstance(instagram_user.user_data ,lowercase		)
  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 > 1_50
  assert instagram_user.number_of_followers > 12_00_00
  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()
    UpperCAmelCase__			=    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 = }''')
