



SCREAMING_SNAKE_CASE  					=    range(2, 20 + 1)
SCREAMING_SNAKE_CASE  					=    [10**k for k in range(ks[-1] + 1)]
SCREAMING_SNAKE_CASE  					=    {}







def snake_case__	(      __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE			)		->				int:
		UpperCAmelCase_						       =					sum(a_i[j] for j in range(A__      ,  len(A__			)			)			)
		UpperCAmelCase_						       =					sum(a_i[j] * base[j] for j in range(min(len(A__			)      ,  A__			)			)			)

		UpperCAmelCase_       ,    UpperCAmelCase_						       =					0, 0
		UpperCAmelCase_						       =					n - i

		UpperCAmelCase_						       =					memo.get(A__			)

		if sub_memo is not None:
				UpperCAmelCase_						       =					sub_memo.get(A__			)

				if jumps is not None and len(A__			) > 0:
						# find and make the largest jump without going over
						UpperCAmelCase_						       =					-1
						for _k in range(len(A__			) - 1      ,  -1      ,  -1			):
								if jumps[_k][2] <= k and jumps[_k][1] <= max_dn:
										UpperCAmelCase_						       =					_k
										break

						if max_jump >= 0:
								UpperCAmelCase_       ,    UpperCAmelCase_       ,    UpperCAmelCase_						       =					jumps[max_jump]
								# since the difference between jumps is cached, add c
								UpperCAmelCase_						       =					diff + c
								for j in range(min(A__      ,  len(A__			)			)			):
										UpperCAmelCase_       ,    UpperCAmelCase_						       =					divmod(A__      ,  10			)
								if new_c > 0:
										add(A__      ,  A__      ,  A__			)

				else:
						UpperCAmelCase_						       =					[]
		else:
				UpperCAmelCase_						       =					{c: []}
				UpperCAmelCase_						       =					sub_memo

		if dn >= max_dn or c + diff >= base[k]:
				return diff, dn

		if k > ks[0]:
				while True:
						# keep doing smaller jumps
						UpperCAmelCase_       ,    UpperCAmelCase_						       =					next_term(A__      ,  k - 1      ,  i + dn      ,  A__			)
						diff += _diff
						dn += terms_jumped

						if dn >= max_dn or c + diff >= base[k]:
								break
		else:
				# would be too small a jump, just compute sequential terms instead
				UpperCAmelCase_       ,    UpperCAmelCase_						       =					compute(A__      ,  A__      ,  i + dn      ,  A__			)
				diff += _diff
				dn += terms_jumped

		UpperCAmelCase_						       =					sub_memo[c]

		# keep jumps sorted by # of terms skipped
		UpperCAmelCase_						       =					0
		while j < len(A__			):
				if jumps[j][1] > dn:
						break
				j += 1

		# cache the jump for this value digitsum(b) and c
		sub_memo[c].insert(A__      ,  (diff, dn, k)			)
		return (diff, dn)







def snake_case__	(      __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE			)		->				Any:
		if i >= n:
				return 0, i
		if k > len(A__			):
				a_i.extend([0 for _ in range(k - len(A__			)			)]			)

		# note: a_i -> b * 10^k + c
		# ds_b -> digitsum(b)
		# ds_c -> digitsum(c)
		UpperCAmelCase_						       =					i
		UpperCAmelCase_       ,    UpperCAmelCase_       ,    UpperCAmelCase_						       =					0, 0, 0
		for j in range(len(A__			)			):
				if j >= k:
						ds_b += a_i[j]
				else:
						ds_c += a_i[j]

		while i < n:
				i += 1
				UpperCAmelCase_						       =					ds_c + ds_b
				diff += addend
				UpperCAmelCase_						       =					0
				for j in range(A__			):
						UpperCAmelCase_						       =					a_i[j] + addend
						UpperCAmelCase_       ,    UpperCAmelCase_						       =					divmod(A__      ,  10			)

						ds_c += a_i[j]

				if addend > 0:
						break

		if addend > 0:
				add(A__      ,  A__      ,  A__			)
		return diff, i - start_i







def snake_case__	(      __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE			)		->				Union[str, Any]:
		for j in range(A__      ,  len(A__			)			):
				UpperCAmelCase_						       =					digits[j] + addend
				if s >= 10:
						UpperCAmelCase_       ,    UpperCAmelCase_						       =					divmod(A__      ,  10			)
						UpperCAmelCase_						       =					addend // 10 + quotient
				else:
						UpperCAmelCase_						       =					s
						UpperCAmelCase_						       =					addend // 10

				if addend == 0:
						break

		while addend > 0:
				UpperCAmelCase_       ,    UpperCAmelCase_						       =					divmod(A__      ,  10			)
				digits.append(A__			)







def snake_case__	(      __SCREAMING_SNAKE_CASE = 10**15			)		->				Optional[Any]:
		UpperCAmelCase_						       =					[1]
		UpperCAmelCase_						       =					1
		UpperCAmelCase_						       =					0
		while True:
				UpperCAmelCase_       ,    UpperCAmelCase_						       =					next_term(A__      ,  20      ,  i + dn      ,  A__			)
				dn += terms_jumped
				if dn == n - i:
						break

		UpperCAmelCase_						       =					0
		for j in range(len(A__			)			):
				a_n += digits[j] * 10**j
		return a_n


if __name__ == "__main__":
			print(f'''{solution() = }''')




from __future__ import annotations

import json

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

__A			:					List[Any]						=			{'UserAgent': UserAgent().random}





def 	__a     (      A__			:  List[Any]       ):
    SCREAMING_SNAKE_CASE										=   script.contents[0]
    SCREAMING_SNAKE_CASE										=   json.loads(data[data.find("{\"config\""       ) : -1]       )
    return info["entry_data"]["ProfilePage"][0]["graphql"]["user"]





class 			_SCREAMING_SNAKE_CASE :







   '''simple docstring'''




   def __init__(       self					:			List[str]     , __lowerCamelCase					:			Optional[Any]			):
       SCREAMING_SNAKE_CASE										=   f"https://www.instagram.com/{username}/"
       SCREAMING_SNAKE_CASE										=   self.get_json()





   def      _snake_case		(       self					:			Tuple			):
       SCREAMING_SNAKE_CASE										=   requests.get(self.url     , headers=__lowerCamelCase			).text
       SCREAMING_SNAKE_CASE										=   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					:			Union[str, Any]			):
       return f"{self.__class__.__name__}('{self.username}')"





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





   @property
   def      _snake_case		(       self					:			Optional[int]			):
       return self.user_data["username"]





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





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





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





   @property
   def      _snake_case		(       self					:			Optional[Any]			):
       return self.user_data["external_url"]





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





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





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





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





   @property
   def      _snake_case		(       self					:			Optional[int]			):
       return self.user_data["is_verified"]





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





def 	__a     (      A__			:  str = "github"       ):
    import os

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