






"""simple docstring"""







from collections import defaultdict







class  lowerCamelCase__ :






    def __init__(			self     ,A     ,A ):
          UpperCAmelCase          =	total  # total no of tasks (N)

          # DP table will have a dimension of (2^M)*N
          # initially all values are set to -1
          UpperCAmelCase          =	[
              [-1 for i in range(total + 1 )] for j in range(2 ** len(__A ) )
          ]

          UpperCAmelCase          =	defaultdict(__A )  # stores the list of persons for each task

          # final_mask is used to check if all persons are included by setting all bits
          # to 1
          UpperCAmelCase          =	(1 << len(__A )) - 1






    def     _UpperCamelCase							(			self     ,A     ,A ):
          # if mask == self.finalmask all persons are distributed tasks, return 1
          if mask == self.final_mask:
                return 1

          # if not everyone gets the task and no more tasks are available, return 0
          if task_no > self.total_tasks:
                return 0

          # if case already considered
          if self.dp[mask][task_no] != -1:
                return self.dp[mask][task_no]

          # Number of ways when we don't this task in the arrangement
          UpperCAmelCase          =	self.count_ways_until(__A     ,task_no + 1 )

          # now assign the tasks one by one to all possible persons and recursively
          # assign for the remaining tasks.
          if task_no in self.task:
                for p in self.task[task_no]:
                      # if p is already given a task
                      if mask & (1 << p):
                            continue

                      # assign this task to p and change the mask value. And recursively
                      # assign tasks with the new mask value.
                      total_ways_util += self.count_ways_until(mask | (1 << p)     ,task_no + 1 )

                 # save the value.
          UpperCAmelCase          =	total_ways_util

          return self.dp[mask][task_no]






    def     _UpperCamelCase							(			self     ,A ):
          # Store the list of persons for each task
          for i in range(len(__A ) ):
                for j in task_performed[i]:
                      self.task[j].append(__A )

                 # call the function to fill the DP table, final answer is stored in dp[0][1]
          return self.count_ways_until(0     ,1 )


if __name__ == "__main__":
    _UpperCamelCase					      =  5  # total no of tasks (the value of N)

    # the list of tasks that can be done by M persons.
    _UpperCamelCase					      =  [[1, 3, 4], [1, 2, 5], [3, 4]]
    print(
        AssignmentUsingBitmask(task_performed, total_tasks).count_no_of_ways(
            task_performed
        )
    )











"""simple docstring"""







from __future__ import annotations

import json

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

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

def _a			(		_snake_case							):







      """simple docstring"""






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







class  lowerCamelCase__ :






    def __init__(			self     ,A ):
          UpperCAmelCase          =	F'''https://www.instagram.com/{username}/'''
          UpperCAmelCase          =	self.get_json()






    def     _UpperCamelCase							(			self ):
          UpperCAmelCase          =	requests.get(self.url     ,headers=A ).text
          UpperCAmelCase          =	BeautifulSoup(A     ,"""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 ):
          return F'''{self.__class__.__name__}(\'{self.username}\')'''






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






    @property
    def     _UpperCamelCase							(			self ):
          return self.user_data["username"]






    @property
    def     _UpperCamelCase							(			self ):
          return self.user_data["full_name"]






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






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






    @property
    def     _UpperCamelCase							(			self ):
          return self.user_data["external_url"]






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






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






    @property
    def     _UpperCamelCase							(			self ):
          return self.user_data["edge_owner_to_timeline_media"]["count"]






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






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






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







def _a			(		_snake_case = "github"							):







      """simple docstring"""






      import os

      if os.environ.get("""CI"""							):
            return  # test failing on GitHub Actions
      UpperCAmelCase          =	InstagramUser(_snake_case							)
      assert instagram_user.user_data
      assert isinstance(instagram_user.user_data				,	_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()
  _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 = }""")



