Spaces:

Sanji003
/

qqq

Runtime error

qqq / bypasser.py

Renga

publicearn1

3f9bd3f 6 months ago

No virus

80.3 kB

	import re
	from re import match as rematch, findall, sub as resub, compile as recompile
	from re import findall, match, search
	import requests
	from requests import get as rget
	import base64
	from urllib.parse import unquote, urlparse, parse_qs, quote
	import time
	import cloudscraper
	#from cloudscraper import create_scraper
	from bs4 import BeautifulSoup, NavigableString, Tag
	from lxml import etree
	from curl_cffi import requests as Nreq
	from curl_cffi.requests import Session as cSession
	import hashlib
	import json
	from dotenv import load_dotenv
	load_dotenv()
	from asyncio import sleep as asleep, create_task,gather
	import os
	import ddl
	from cfscrape import create_scraper
	from uuid import uuid4
	from requests import Session
	from ddl import humanbytes
	from animepahe.anime import set_direct_link
	from lk21 import Bypass
	from base64 import standard_b64encode
	from selenium import webdriver
	from selenium.webdriver.common.by import By
	from selenium.webdriver.support import expected_conditions as ec
	from selenium.webdriver.support.ui import WebDriverWait
	import chromedriver_autoinstaller
	##########################################################
	# ENVs

	GDTOT_CRYPT = "b0lDek5LSCt6ZjVRR2EwZnY4T1EvVndqeDRtbCtTWmMwcGNuKy8wYWpDaz0%3D"
	Laravel_Session = os.environ.get("Laravel_Session","")
	XSRF_TOKEN = os.environ.get("XSRF_TOKEN","")
	DCRYPT = os.environ.get("DRIVEFIRE_CRYPT","cnhXOGVQNVlpeFZlM2lvTmN6Z2FPVWJiSjVBbWdVN0dWOEpvR3hHbHFLVT0%3D")
	KCRYPT = os.environ.get("KOLOP_CRYPT","a1V1ZWllTnNNNEZtbkU4Y0RVd3pkRG5UREFJZFlUaC9GRko5NUNpTHNFcz0%3D")
	HCRYPT = os.environ.get("HUBDRIVE_CRYPT","UDJvaFFVQjhlUThTN1I4elNSdkJGem1WUVZYUXFvS3FNRWlCeEM1clhnVT0%3D")
	KATCRYPT = os.environ.get("KATDRIVE_CRYPT","bzQySHVKSkY0bEczZHlqOWRsSHZCazBkOGFDak9HWXc1emRTL1F6Rm9ubz0%3D")
	uid=os.environ.get('PEUID')
	print(uid)
	class DDLException(Exception):
	"""Not method found for extracting direct download link from the http link"""
	pass

	############################################################
	# Lists

	otherslist = ["exe.io","exey.io","sub2unlock.net","sub2unlock.com","rekonise.com","letsboost.net","ph.apps2app.com","mboost.me",
	"sub4unlock.com","ytsubme.com","social-unlock.com","boost.ink","goo.gl","shrto.ml"]

	gdlist = ["appdrive","driveapp","drivehub","gdflix","drivesharer","drivebit","drivelinks","driveace",
	"drivepro","driveseed"]

	DDL_REGEX = recompile(r"DDL$([^),]+)\, (([^),]+)), (([^),]+)), (([^),]+))$")

	POST_ID_REGEX = recompile(r'"postId":"(\d+)"')

	###############################################################

	###############################################################
	# index scrapper

	def scrapeIndex(url, username="none", password="none"):

	def authorization_token(username, password):
	user_pass = f"{username}:{password}"
	return f"Basic {base64.b64encode(user_pass.encode()).decode()}"


	def decrypt(string):
	return base64.b64decode(string[::-1][24:-20]).decode('utf-8')


	def func(payload_input, url, username, password):
	next_page = False
	next_page_token = ""

	url = f"{url}/" if url[-1] != '/' else url

	try: headers = {"authorization":authorization_token(username,password)}
	except: return "username/password combination is wrong", None, None

	encrypted_response = requests.post(url, data=payload_input, headers=headers)
	if encrypted_response.status_code == 401: return "username/password combination is wrong", None, None

	try: decrypted_response = json.loads(decrypt(encrypted_response.text))
	except: return "something went wrong. check index link/username/password field again", None, None

	page_token = decrypted_response["nextPageToken"]
	if page_token is None:
	next_page = False
	else:
	next_page = True
	next_page_token = page_token


	if list(decrypted_response.get("data").keys())[0] != "error":
	file_length = len(decrypted_response["data"]["files"])
	result = ""

	for i, _ in enumerate(range(file_length)):
	files_type = decrypted_response["data"]["files"][i]["mimeType"]
	if files_type != "application/vnd.google-apps.folder":
	files_name = decrypted_response["data"]["files"][i]["name"]

	direct_download_link = url + quote(files_name)
	result += f"• {files_name} :\n{direct_download_link}\n\n"
	return result, next_page, next_page_token

	def format(result):
	long_string = ''.join(result)
	new_list = []

	while len(long_string) > 0:
	if len(long_string) > 4000:
	split_index = long_string.rfind("\n\n", 0, 4000)
	if split_index == -1:
	split_index = 4000
	else:
	split_index = len(long_string)

	new_list.append(long_string[:split_index])
	long_string = long_string[split_index:].lstrip("\n\n")

	return new_list

	# main
	x = 0
	next_page = False
	next_page_token = ""
	result = []

	payload = {"page_token":next_page_token, "page_index": x}
	print(f"Index Link: {url}\n")
	temp, next_page, next_page_token = func(payload, url, username, password)
	if temp is not None: result.append(temp)

	while next_page == True:
	payload = {"page_token":next_page_token, "page_index": x}
	temp, next_page, next_page_token = func(payload, url, username, password)
	if temp is not None: result.append(temp)
	x += 1

	if len(result)==0: return None
	return format(result)


	##############################################################
	# shortners

	def gofile_dl(url: str):
	rget = requests.Session()
	resp = rget.get('https://api.gofile.io/createAccount')
	if resp.status_code == 200:
	data = resp.json()
	if data['status'] == 'ok' and data.get('data', {}).get('token', None):
	token = data['data']['token']
	else:
	return(f'ERROR: Failed to Create GoFile Account')
	else:
	return(f'ERROR: GoFile Server Response Failed')
	headers = f'Cookie: accountToken={token}'
	def getNextedFolder(contentId, path):
	params = {'contentId': contentId, 'token': token, 'websiteToken': '7fd94ds12fds4'}
	res = rget.get('https://api.gofile.io/getContent', params=params)
	if res.status_code == 200:
	json_data = res.json()
	if json_data['status'] == 'ok':
	links = {}
	for content in json_data['data']['contents'].values():
	if content["type"] == "folder":
	path = path+"/"+content['name']
	links.update(getNextedFolder(content['id'], path))
	elif content["type"] == "file":
	links[content['link']] = path
	return links
	else:
	return(f'ERROR: Failed to Receive All Files List')
	else:
	return(f'ERROR: GoFile Server Response Failed')
	return list([getNextedFolder(url[url.rfind('/')+1:], ""), headers][0].keys())[0]


	#################################################
	# drivefire

	def parse_info_drivefire(res):
	info_parsed = {}
	title = re.findall('>(.*?)<\/h4>', res.text)[0]
	info_chunks = re.findall('>(.*?)<\/td>', res.text)
	info_parsed['title'] = title
	for i in range(0, len(info_chunks), 2):
	info_parsed[info_chunks[i]] = info_chunks[i+1]
	return info_parsed

	def drivefire_dl(url,dcrypt):
	client = requests.Session()
	client.cookies.update({'crypt': dcrypt})

	res = client.get(url)
	info_parsed = parse_info_drivefire(res)
	info_parsed['error'] = False

	up = urlparse(url)
	req_url = f"{up.scheme}://{up.netloc}/ajax.php?ajax=download"

	file_id = url.split('/')[-1]
	data = { 'id': file_id }
	headers = {'x-requested-with': 'XMLHttpRequest'}

	try:
	res = client.post(req_url, headers=headers, data=data).json()['file']
	except:
	return "Error"#{'error': True, 'src_url': url}

	decoded_id = res.rsplit('/', 1)[-1]
	info_parsed = f"https://drive.google.com/file/d/{decoded_id}"
	return info_parsed


	##################################################
	# kolop

	def parse_info_kolop(res):
	info_parsed = {}
	title = re.findall('>(.*?)<\/h4>', res.text)[0]
	info_chunks = re.findall('>(.*?)<\/td>', res.text)
	info_parsed['title'] = title
	for i in range(0, len(info_chunks), 2):
	info_parsed[info_chunks[i]] = info_chunks[i+1]
	return info_parsed

	def kolop_dl(url,kcrypt):
	client = requests.Session()
	client.cookies.update({'crypt': kcrypt})

	res = client.get(url)
	info_parsed = parse_info_kolop(res)
	info_parsed['error'] = False

	up = urlparse(url)
	req_url = f"{up.scheme}://{up.netloc}/ajax.php?ajax=download"

	file_id = url.split('/')[-1]
	data = { 'id': file_id }
	headers = { 'x-requested-with': 'XMLHttpRequest'}

	try:
	res = client.post(req_url, headers=headers, data=data).json()['file']
	except:
	return "Error"#{'error': True, 'src_url': url}

	gd_id = re.findall('gd=(.*)', res, re.DOTALL)[0]
	info_parsed['gdrive_url'] = f"https://drive.google.com/open?id={gd_id}"
	info_parsed['src_url'] = url

	return info_parsed['gdrive_url']


	##################################################
	# mediafire

	def mediafire(url):

	res = requests.get(url, stream=True)
	contents = res.text

	for line in contents.splitlines():
	m = re.search(r'href="((http\|https)://download[^"]+)', line)
	if m:
	return m.groups()[0]


	####################################################
	# zippyshare

	def zippyshare(url):
	resp = requests.get(url).text
	surl = resp.split("document.getElementById('dlbutton').href = ")[1].split(";")[0]
	parts = surl.split("(")[1].split(")")[0].split(" ")
	val = str(int(parts[0]) % int(parts[2]) + int(parts[4]) % int(parts[6]))
	surl = surl.split('"')
	burl = url.split("zippyshare.com")[0]
	furl = burl + "zippyshare.com" + surl[1] + val + surl[-2]
	return furl


	####################################################
	# filercrypt

	def getlinks(dlc,client):
	headers = {
	'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:103.0) Gecko/20100101 Firefox/103.0',
	'Accept': 'application/json, text/javascript, /',
	'Accept-Language': 'en-US,en;q=0.5',
	'X-Requested-With': 'XMLHttpRequest',
	'Origin': 'http://dcrypt.it',
	'Connection': 'keep-alive',
	'Referer': 'http://dcrypt.it/',
	}

	data = {
	'content': dlc,
	}

	response = client.post('http://dcrypt.it/decrypt/paste', headers=headers, data=data).json()["success"]["links"]
	links = ""
	for link in response:
	links = links + link + "\n"
	return links[:-1]


	def filecrypt(url):

	client = cloudscraper.create_scraper(allow_brotli=False)
	headers = {
	"authority": "filecrypt.co",
	"accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,/;q=0.8,application/signed-exchange;v=b3;q=0.9",
	"accept-language": "en-US,en;q=0.9",
	"cache-control": "max-age=0",
	"content-type": "application/x-www-form-urlencoded",
	"dnt": "1",
	"origin": "https://filecrypt.co",
	"referer": url,
	"sec-ch-ua": '"Google Chrome";v="105", "Not)A;Brand";v="8", "Chromium";v="105"',
	"sec-ch-ua-mobile": "?0",
	"sec-ch-ua-platform": "Windows",
	"sec-fetch-dest": "document",
	"sec-fetch-mode": "navigate",
	"sec-fetch-site": "same-origin",
	"sec-fetch-user": "?1",
	"upgrade-insecure-requests": "1",
	"user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.0.0 Safari/537.36"
	}


	resp = client.get(url, headers=headers)
	soup = BeautifulSoup(resp.content, "html.parser")

	buttons = soup.find_all("button")
	for ele in buttons:
	line = ele.get("onclick")
	if line !=None and "DownloadDLC" in line:
	dlclink = "https://filecrypt.co/DLC/" + line.split("DownloadDLC('")[1].split("'")[0] + ".html"
	break

	resp = client.get(dlclink,headers=headers)
	return getlinks(resp.text,client)


	#####################################################
	# dropbox

	def dropbox(url):
	return url.replace("www.","").replace("dropbox.com","dl.dropboxusercontent.com").replace("?dl=0","")


	######################################################
	# shareus

	def shareus(url):
	headers = {'user-agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36',}
	DOMAIN = "https://us-central1-my-apps-server.cloudfunctions.net"
	sess = requests.session()

	code = url.split("/")[-1]
	params = {'shortid': code, 'initial': 'true', 'referrer': 'https://shareus.io/',}
	response = requests.get(f'{DOMAIN}/v', params=params, headers=headers)

	for i in range(1,4):
	json_data = {'current_page': i,}
	response = sess.post(f'{DOMAIN}/v', headers=headers, json=json_data)

	response = sess.get(f'{DOMAIN}/get_link', headers=headers).json()
	return response["link_info"]["destination"]

	#######################################################
	# anonfiles

	def anonfile(url):

	headersList = { "Accept": "/"}
	payload = ""

	response = requests.request("GET", url, data=payload, headers=headersList).text.split("\n")
	for ele in response:
	if "https://cdn" in ele and "anonfiles.com" in ele and url.split("/")[-2] in ele:
	break

	return ele.split('href="')[1].split('"')[0]


	##########################################################
	# pixl

	def pixl(url):
	count = 1
	dl_msg = ""
	currentpage = 1
	settotalimgs = True
	totalimages = ""
	client = cloudscraper.create_scraper(allow_brotli=False)
	resp = client.get(url)
	if resp.status_code == 404:
	return "File not found/The link you entered is wrong!"
	soup = BeautifulSoup(resp.content, "html.parser")
	if "album" in url and settotalimgs:
	totalimages = soup.find("span", {"data-text": "image-count"}).text
	settotalimgs = False
	thmbnailanch = soup.findAll(attrs={"class": "--media"})
	links = soup.findAll(attrs={"data-pagination": "next"})
	try:
	url = links[0].attrs["href"]
	except BaseException:
	url = None
	for ref in thmbnailanch:
	imgdata = client.get(ref.attrs["href"])
	if not imgdata.status_code == 200:
	time.sleep(5)
	continue
	imghtml = BeautifulSoup(imgdata.text, "html.parser")
	downloadanch = imghtml.find(attrs={"class": "btn-download"})
	currentimg = downloadanch.attrs["href"]
	currentimg = currentimg.replace(" ", "%20")
	dl_msg += f"{count}. {currentimg}\n"
	count += 1
	currentpage += 1
	fld_msg = f"Your provided Pixl.is link is of Folder and I've Found {count - 1} files in the folder.\n"
	fld_link = f"\nFolder Link: {url}\n"
	final_msg = fld_link + "\n" + fld_msg + "\n" + dl_msg
	return final_msg


	############################################################
	# sirigan ( unused )

	def siriganbypass(url):
	client = requests.Session()
	res = client.get(url)
	url = res.url.split('=', maxsplit=1)[-1]

	while True:
	try: url = base64.b64decode(url).decode('utf-8')
	except: break

	return url.split('url=')[-1]


	############################################################
	# shorte

	def sh_st_bypass(url):
	client = requests.Session()
	client.headers.update({'referer': url})
	p = urlparse(url)

	res = client.get(url)

	sess_id = re.findall('''sessionId(?:\s+)?:(?:\s+)?['\|"](.*?)['\|"]''', res.text)[0]

	final_url = f"{p.scheme}://{p.netloc}/shortest-url/end-adsession"
	params = {
	'adSessionId': sess_id,
	'callback': '_'
	}
	time.sleep(5) # !important

	res = client.get(final_url, params=params)
	dest_url = re.findall('"(.*?)"', res.text)[1].replace('\/','/')

	return {
	'src': url,
	'dst': dest_url
	}['dst']


	#############################################################


	def parse_info_sharer(res):
	f = re.findall(">(.*?)<\/td>", res.text)
	info_parsed = {}
	for i in range(0, len(f), 3):
	info_parsed[f[i].lower().replace(' ', '_')] = f[i+2]
	return info_parsed

	def sharer_pw(url,Laravel_Session, XSRF_TOKEN, forced_login=False):
	client = cloudscraper.create_scraper(allow_brotli=False)
	client.cookies.update({
	"XSRF-TOKEN": XSRF_TOKEN,
	"laravel_session": Laravel_Session
	})
	res = client.get(url)
	token = re.findall("_token\s=\s'(.*?)'", res.text, re.DOTALL)[0]
	ddl_btn = etree.HTML(res.content).xpath("//button[@id='btndirect']")
	info_parsed = parse_info_sharer(res)
	info_parsed['error'] = True
	info_parsed['src_url'] = url
	info_parsed['link_type'] = 'login'
	info_parsed['forced_login'] = forced_login
	headers = {
	'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
	'x-requested-with': 'XMLHttpRequest'
	}
	data = {
	'_token': token
	}
	if len(ddl_btn):
	info_parsed['link_type'] = 'direct'
	if not forced_login:
	data['nl'] = 1
	try:
	res = client.post(url+'/dl', headers=headers, data=data).json()
	except:
	return info_parsed
	if 'url' in res and res['url']:
	info_parsed['error'] = False
	info_parsed['gdrive_link'] = res['url']
	if len(ddl_btn) and not forced_login and not 'url' in info_parsed:
	# retry download via login
	return sharer_pw(url,Laravel_Session, XSRF_TOKEN, forced_login=True)
	return info_parsed["gdrive_link"]


	#################################################################
	# gdtot

	def gdtot(url):
	cget = cloudscraper.create_scraper(allow_brotli=False)
	try:
	url = cget.get(url).url
	p_url = urlparse(url)
	res = cget.post(f"{p_url.scheme}://{p_url.hostname}/ddl", data={'dl': str(url.split('/')[-1])})
	except Exception as e:
	return(f'{e.__class__.__name__}')
	if (drive_link := findall(r"myDl$'(.*?)'$", res.text)) and "drive.google.com" in drive_link[0]:
	d_link = drive_link[0]
	elif GDTOT_CRYPT:
	cget.get(url, cookies={'crypt': GDTOT_CRYPT})
	p_url = urlparse(url)
	js_script = cget.post(f"{p_url.scheme}://{p_url.hostname}/dld", data={'dwnld': url.split('/')[-1]})
	g_id = findall('gd=(.*?)&', js_script.text)
	try:
	decoded_id = b64decode(str(g_id[0])).decode('utf-8')
	except:
	return("Try in your browser, mostly file not found or user limit exceeded!")
	d_link = f'https://drive.google.com/open?id={decoded_id}'
	print(f'2. {d_link}')
	else:
	return('Drive Link not found, Try in your broswer! GDTOT_CRYPT not Provided!')
	soup = BeautifulSoup(cget.get(url).content, "html.parser")
	parse_data = (soup.select('meta[property^="og:description"]')[0]['content']).replace('Download ' , '').rsplit('-', maxsplit=1)
	parse_txt = f'''┎ <b>Name :</b> <i>{parse_data[0]}</i>
	┠ <b>Size :</b> <i>{parse_data[-1]}</i>
	┃
	┠ <b>GDToT Link :</b> {url}
	'''
	try:
	res=cget.get(url)
	if (tele_link := findall(r"myDl2$'(.*?)'$", res.text)):
	print(tele_link[0])
	parse_txt += f"┖ <b>Telegram Link :</b> {tele_link[0]}\n"
	except:pass
	parse_txt += f'┠ <b>Index Link :</b> https://indexlink.mrprincebotz.workers.dev/direct.aspx?id={get_gdriveid(d_link)}\n'
	parse_txt += f"┖ <b>Drive Link :</b> {d_link}"
	return parse_txt

	##################################################################
	# adfly

	def decrypt_url(code):
	a, b = '', ''
	for i in range(0, len(code)):
	if i % 2 == 0: a += code[i]
	else: b = code[i] + b
	key = list(a + b)
	i = 0
	while i < len(key):
	if key[i].isdigit():
	for j in range(i+1,len(key)):
	if key[j].isdigit():
	u = int(key[i]) ^ int(key[j])
	if u < 10: key[i] = str(u)
	i = j
	break
	i+=1
	key = ''.join(key)
	decrypted = base64.b64decode(key)[16:-16]
	return decrypted.decode('utf-8')


	def adfly(url):
	client = cloudscraper.create_scraper(allow_brotli=False)
	res = client.get(url).text
	out = {'error': False, 'src_url': url}
	try:
	ysmm = re.findall("ysmm\s+=\s+['\|\"](.*?)['\|\"]", res)[0]
	except:
	out['error'] = True
	return out
	url = decrypt_url(ysmm)
	if re.search(r'go\.php\?u\=', url):
	url = base64.b64decode(re.sub(r'(.*?)u=', '', url)).decode()
	elif '&dest=' in url:
	url = unquote(re.sub(r'(.*?)dest=', '', url))
	out['bypassed_url'] = url
	return out


	##############################################################################################



	######################################################################################################
	# droplink

	def droplink(url):
	client = cloudscraper.create_scraper(allow_brotli=False)
	res = client.get(url, timeout=5)

	ref = re.findall("action[ ]{0,}=[ ]{0,}['\|\"](.*?)['\|\"]", res.text)[0]
	h = {"referer": ref}
	res = client.get(url, headers=h)

	bs4 = BeautifulSoup(res.content, "html.parser")
	inputs = bs4.find_all("input")
	data = {input.get("name"): input.get("value") for input in inputs}
	h = {
	"content-type": "application/x-www-form-urlencoded",
	"x-requested-with": "XMLHttpRequest",
	}

	p = urlparse(url)
	final_url = f"{p.scheme}://{p.netloc}/links/go"
	time.sleep(3.1)
	res = client.post(final_url, data=data, headers=h).json()

	if res["status"] == "success": return res["url"]
	return 'Something went wrong :('


	#####################################################################################################################
	# link vertise

	def linkvertise(url):
	params = {'url': url,}
	response = requests.get('https://bypass.pm/bypass2', params=params).json()
	if response["success"]: return response["destination"]
	else: return response["msg"]


	###################################################################################################################
	# others

	def others(url):
	return "API Currently not Available"


	#################################################################################################################
	# ouo

	# RECAPTCHA v3 BYPASS
	# code from https://github.com/xcscxr/Recaptcha-v3-bypass
	def recaptchaV3(ANCHOR_URL = 'https://www.google.com/recaptcha/api2/anchor?ar=1&k=6Lcr1ncUAAAAAH3cghg6cOTPGARa8adOf-y9zv2x&co=aHR0cHM6Ly9vdW8ucHJlc3M6NDQz&hl=en&v=pCoGBhjs9s8EhFOHJFe8cqis&size=invisible&cb=ahgyd1gkfkhe'):
	rs = Session()
	rs.headers.update({'content-type': 'application/x-www-form-urlencoded'})
	matches = findall('([api2\|enterprise]+)\/anchor\?(.*)', ANCHOR_URL)[0]
	url_base = 'https://www.google.com/recaptcha/' + matches[0] + '/'
	params = matches[1]
	res = rs.get(url_base + 'anchor', params=params)
	token = findall(r'"recaptcha-token" value="(.*?)"', res.text)[0]
	params = dict(pair.split('=') for pair in params.split('&'))
	res = rs.post(url_base + 'reload', params=f'k={params["k"]}', data=f"v={params['v']}&reason=q&c={token}&k={params['k']}&co={params['co']}")
	return findall(r'"rresp","(.*?)"', res.text)[0]

	def ouo(url: str):
	tempurl = url.replace("ouo.press", "ouo.io")
	p = urlparse(tempurl)
	id = tempurl.split('/')[-1]
	client = cSession(headers={'authority': 'ouo.io', 'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,/;q=0.8,application/signed-exchange;v=b3;q=0.7', 'accept-language': 'en-GB,en-US;q=0.9,en;q=0.8', 'cache-control': 'max-age=0', 'referer': 'http://www.google.com/ig/adde?moduleurl=', 'upgrade-insecure-requests': '1'})
	res = client.get(tempurl, impersonate="chrome110")
	next_url = f"{p.scheme}://{p.hostname}/go/{id}"

	for _ in range(2):
	if res.headers.get('Location'):
	break
	bs4 = BeautifulSoup(res.content, 'lxml')
	inputs = bs4.form.findAll("input", {"name": compile(r"token$")})
	data = { inp.get('name'): inp.get('value') for inp in inputs }
	data['x-token'] = recaptchaV3()
	res = client.post(next_url, data=data, headers= {'content-type': 'application/x-www-form-urlencoded'}, allow_redirects=False, impersonate="chrome110")
	next_url = f"{p.scheme}://{p.hostname}/xreallcygo/{id}"

	return res.headers.get('Location')



	####################################################################################################################
	# mdisk

	def mdisk(url):
	header = {
	'Accept': '/',
	'Accept-Language': 'en-US,en;q=0.5',
	'Accept-Encoding': 'gzip, deflate, br',
	'Referer': 'https://mdisk.me/',
	'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.82 Safari/537.36'
	}

	inp = url
	fxl = inp.split("/")
	cid = fxl[-1]

	URL = f'https://diskuploader.entertainvideo.com/v1/file/cdnurl?param={cid}'
	res = requests.get(url=URL, headers=header).json()
	return res['download'] + '\n\n' + res['source']


	##################################################################################################################
	# AppDrive or DriveApp etc. Look-Alike Link and as well as the Account Details (Required for Login Required Links only)

	def unified(url):

	if ddl.is_share_link(url):
	if 'https://gdtot' in url: return ddl.gdtot(url)
	else: return ddl.sharer_scraper(url)

	try:
	Email = "chzeesha4@gmail.com"
	Password = "zeeshi#789"

	account = {"email": Email, "passwd": Password}
	client = cloudscraper.create_scraper(allow_brotli=False)
	client.headers.update(
	{
	"user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/97.0.4692.99 Safari/537.36"
	}
	)
	data = {"email": account["email"], "password": account["passwd"]}
	client.post(f"https://{urlparse(url).netloc}/login", data=data)
	res = client.get(url)
	key = re.findall('"key",\s+"(.*?)"', res.text)[0]
	ddl_btn = etree.HTML(res.content).xpath("//button[@id='drc']")
	info = re.findall(">(.*?)<\/li>", res.text)
	info_parsed = {}
	for item in info:
	kv = [s.strip() for s in item.split(":", maxsplit=1)]
	info_parsed[kv[0].lower()] = kv[1]
	info_parsed = info_parsed
	info_parsed["error"] = False
	info_parsed["link_type"] = "login"
	headers = {
	"Content-Type": f"multipart/form-data; boundary={'-'*4}_",
	}
	data = {"type": 1, "key": key, "action": "original"}
	if len(ddl_btn):
	info_parsed["link_type"] = "direct"
	data["action"] = "direct"
	while data["type"] <= 3:
	boundary = f'{"-"*6}_'
	data_string = ""
	for item in data:
	data_string += f"{boundary}\r\n"
	data_string += f'Content-Disposition: form-data; name="{item}"\r\n\r\n{data[item]}\r\n'
	data_string += f"{boundary}--\r\n"
	gen_payload = data_string
	try:
	response = client.post(url, data=gen_payload, headers=headers).json()
	break
	except BaseException:
	data["type"] += 1
	if "url" in response:
	info_parsed["gdrive_link"] = response["url"]
	elif "error" in response and response["error"]:
	info_parsed["error"] = True
	info_parsed["error_message"] = response["message"]
	else:
	info_parsed["error"] = True
	info_parsed["error_message"] = "Something went wrong :("
	if info_parsed["error"]:
	return info_parsed
	if "driveapp" in urlparse(url).netloc and not info_parsed["error"]:
	res = client.get(info_parsed["gdrive_link"])
	drive_link = etree.HTML(res.content).xpath(
	"//a[contains(@class,'btn')]/@href"
	)[0]
	info_parsed["gdrive_link"] = drive_link
	info_parsed["src_url"] = url
	if "drivehub" in urlparse(url).netloc and not info_parsed["error"]:
	res = client.get(info_parsed["gdrive_link"])
	drive_link = etree.HTML(res.content).xpath(
	"//a[contains(@class,'btn')]/@href"
	)[0]
	info_parsed["gdrive_link"] = drive_link
	if "gdflix" in urlparse(url).netloc and not info_parsed["error"]:
	res = client.get(info_parsed["gdrive_link"])
	drive_link = etree.HTML(res.content).xpath(
	"//a[contains(@class,'btn')]/@href"
	)[0]
	info_parsed["gdrive_link"] = drive_link

	if "drivesharer" in urlparse(url).netloc and not info_parsed["error"]:
	res = client.get(info_parsed["gdrive_link"])
	drive_link = etree.HTML(res.content).xpath(
	"//a[contains(@class,'btn')]/@href"
	)[0]
	info_parsed["gdrive_link"] = drive_link
	if "drivebit" in urlparse(url).netloc and not info_parsed["error"]:
	res = client.get(info_parsed["gdrive_link"])
	drive_link = etree.HTML(res.content).xpath(
	"//a[contains(@class,'btn')]/@href"
	)[0]
	info_parsed["gdrive_link"] = drive_link
	if "drivelinks" in urlparse(url).netloc and not info_parsed["error"]:
	res = client.get(info_parsed["gdrive_link"])
	drive_link = etree.HTML(res.content).xpath(
	"//a[contains(@class,'btn')]/@href"
	)[0]
	info_parsed["gdrive_link"] = drive_link
	if "driveace" in urlparse(url).netloc and not info_parsed["error"]:
	res = client.get(info_parsed["gdrive_link"])
	drive_link = etree.HTML(res.content).xpath(
	"//a[contains(@class,'btn')]/@href"
	)[0]
	info_parsed["gdrive_link"] = drive_link
	if "drivepro" in urlparse(url).netloc and not info_parsed["error"]:
	res = client.get(info_parsed["gdrive_link"])
	drive_link = etree.HTML(res.content).xpath(
	"//a[contains(@class,'btn')]/@href"
	)[0]
	info_parsed["gdrive_link"] = drive_link
	if info_parsed["error"]:
	return "Faced an Unknown Error!"
	return info_parsed["gdrive_link"]
	except BaseException:
	return "Unable to Extract GDrive Link"


	#####################################################################################################
	# urls open

	def vnshortener(url):
	sess = requests.session()
	DOMAIN = "https://vnshortener.com/"
	org = "https://nishankhatri.xyz"
	PhpAcc = DOMAIN + "link/new.php"
	ref = "https://nishankhatri.com.np/"
	go = DOMAIN + "links/go"

	code = url.split("/")[3]
	final_url = f"{DOMAIN}/{code}/"
	headers = {'authority': DOMAIN, 'origin': org}

	data = {'step_1': code,}
	response = sess.post(PhpAcc, headers=headers, data=data).json()
	id = response["inserted_data"]["id"]
	data = {'step_2': code, 'id': id,}
	response = sess.post(PhpAcc, headers=headers, data=data).json()

	headers['referer'] = ref
	params = {'sid': str(id)}
	resp = sess.get(final_url, params=params, headers=headers)
	soup = BeautifulSoup(resp.content, "html.parser")
	inputs = soup.find_all("input")
	data = { input.get('name'): input.get('value') for input in inputs }

	time.sleep(1)
	headers['x-requested-with'] = 'XMLHttpRequest'
	try:
	r = sess.post(go, data=data, headers=headers).json()
	if r["status"] == "success": return r["url"]
	else: raise
	except: return "Something went wrong :("

	def rslinks(url):
	client = requests.session()
	download = rget(url, stream=True, allow_redirects=False)
	v = download.headers["location"]
	code = v.split('ms9')[-1]
	final = f"http://techyproio.blogspot.com/p/short.html?{code}=="
	try: return final
	except: return "Something went wrong :("
	def du_link(url):
	client = cloudscraper.create_scraper(allow_brotli=False)
	DOMAIN = "https://du-link.in"
	url = url[:-1] if url[-1] == '/' else url
	code = url.split("/")[-1]
	final_url = f"{DOMAIN}/{code}"
	ref = "https://profitshort.com/"
	h = {"referer": ref}
	resp = client.get(final_url,headers=h,allow_redirects=False)
	soup = BeautifulSoup(resp.content, "html.parser")
	inputs = soup.find_all("input")
	data = { input.get('name'): input.get('value') for input in inputs }
	h = { "x-requested-with": "XMLHttpRequest" }
	time.sleep(0)
	r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
	try: return r.json()['url']
	except: return "Something went wrong :("
	def atozcartoonist(url):
	re=requests.get(url,allow_redirects=False).headers['Location']
	print(re)
	if 'moonlinks' in re:
	link=transcript(re, "https://go.moonlinks.in/", "https://www.akcartoons.in/", 7)
	link='https://drive.google.com/uc?id={link.split("=")[-1]}&export=download'
	elif 'xpshort'in re:
	link=re
	return link

	#####################################################################################################
	# bitly + tinyurl

	def bitly_tinyurl(url: str) -> str:
	response = requests.get(url).url
	try: return response
	except: return "Something went wrong :("

	#####################################################################################################
	# thinfi

	def thinfi(url: str) -> str :
	response = requests.get(url)
	soup = BeautifulSoup(response.content, "html.parser").p.a.get("href")
	try: return soup
	except: return "Something went wrong :("

	#####################################################################################################
	# helpers

	# check if present in list
	def ispresent(inlist,url):
	for ele in inlist:
	if ele in url:
	return True
	return False


	async def transcript(url: str, DOMAIN: str, ref: str, sltime) -> str:
	code = url.rstrip("/").split("/")[-1]
	cget = cloudscraper.create_scraper(allow_brotli=False).request
	resp = cget("GET", f"{DOMAIN}/{code}", headers={"referer": ref},allow_redirects=False)
	soup = BeautifulSoup(resp.content, "html.parser")
	data = { inp.get('name'): inp.get('value') for inp in soup.find_all("input") }
	await asleep(sltime)
	resp = cget("POST", f"{DOMAIN}/links/go", data=data, headers={ "x-requested-with": "XMLHttpRequest" })
	try:
	return resp.json()['url']
	except:
	return "Something went wrong :("


	def get_gdriveid(link):
	if "folders" in link or "file" in link:
	res = search(r"https:\/\/drive\.google\.com\/(?:drive(.?)\/folders\/\|file(.?)?\/d\/)([-\w]+)", link)
	return res.group(3)
	parsed = urlparse(link)
	return parse_qs(parsed.query)['id'][0]
	def get_dl(link):
	return f"https://indexlink.mrprincebotz.workers.dev/direct.aspx?id={get_gdriveid(link)}"


	def drivescript(url, crypt, dtype):
	rs = Session()
	resp = rs.get(url)
	title = findall(r'>(.*?)<\/h4>', resp.text)[0]
	size = findall(r'>(.*?)<\/td>', resp.text)[1]
	p_url = urlparse(url)

	dlink = ''
	if dtype != "DriveFire":
	try:
	js_query = rs.post(f"{p_url.scheme}://{p_url.hostname}/ajax.php?ajax=direct-download", data={'id': str(url.split('/')[-1])}, headers={'x-requested-with': 'XMLHttpRequest'}).json()
	if str(js_query['code']) == '200':
	dlink = f"{p_url.scheme}://{p_url.hostname}{js_query['file']}"
	except Exception as e:
	LOGGER.error(e)

	if not dlink and crypt:
	rs.get(url, cookies={'crypt': crypt})
	try:
	js_query = rs.post(f"{p_url.scheme}://{p_url.hostname}/ajax.php?ajax=download", data={'id': str(url.split('/')[-1])}, headers={'x-requested-with': 'XMLHttpRequest'}).json()
	except Exception as e:
	return(f'{e.__class__.__name__}')
	if str(js_query['code']) == '200':
	dlink = f"{p_url.scheme}://{p_url.hostname}{js_query['file']}"

	if dlink:
	res = rs.get(dlink)
	soup = BeautifulSoup(res.text, 'html.parser')
	gd_data = soup.select('a[class="btn btn-primary btn-user"]')
	parse_txt = f'''┎ <b>Name :</b> <code>{title}</code>
	┠ <b>Size :</b> <code>{size}</code>
	┃
	┠ <b>{dtype} Link :</b> {url}'''
	if dtype == "HubDrive":
	parse_txt += f'''\n┠ <b>Instant Link :</b> <a href="{gd_data[1]['href']}">Click Here</a>'''
	if (d_link := gd_data[0]['href']):
	parse_txt += f"\n┠ <b>Index Link :</b> {get_dl(d_link)}"
	parse_txt += f"\n┖ <b>Drive Link :</b> {d_link}"
	return parse_txt
	elif not dlink and not crypt:
	return(f'{dtype} Crypt Not Provided and Direct Link Generate Failed')
	else:
	return(f'{js_query["file"]}')

	######################################################################################################
	#Scrapers
	def htpmovies(link):
	client = cloudscraper.create_scraper(allow_brotli=False)
	r = client.get(link, allow_redirects=True).text
	j = r.split('("')[-1]
	url = j.split('")')[0]
	param = url.split("/")[-1]
	DOMAIN = "https://go.theforyou.in"
	final_url = f"{DOMAIN}/{param}"
	resp = client.get(final_url)
	soup = BeautifulSoup(resp.content, "html.parser")
	try: inputs = soup.find(id="go-link").find_all(name="input")
	except: return "Incorrect Link"
	data = { input.get('name'): input.get('value') for input in inputs }
	h = { "x-requested-with": "XMLHttpRequest" }
	time.sleep(10)
	r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
	try:
	return r.json()['url']
	except: return "Something went Wrong !!"


	def scrappers(link):

	try: link = rematch(r"^(?i)\b((?:https?://\|www\d{0,3}[.]\|[a-z0-9.\-]+[.][a-z]{2,4}/)(?:[^\s()<>]+\|$([^\s()<>]+\|(\([^\s()<>]+$))\))+(?:$([^\s()<>]+\|(\([^\s()<>]+$))\)\|[^\s`!()\[\]{};:'\".,<>?«»“”‘’]))", link)[0]
	except TypeError: return 'Not a Valid Link.'
	links = []

	if "sharespark" in link:
	gd_txt = ""
	res = rget("?action=printpage;".join(link.split('?')))
	soup = BeautifulSoup(res.text, 'html.parser')
	for br in soup.findAll('br'):
	next_s = br.nextSibling
	if not (next_s and isinstance(next_s,NavigableString)):
	continue
	next2_s = next_s.nextSibling
	if next2_s and isinstance(next2_s,Tag) and next2_s.name == 'br':
	if str(next_s).strip():
	List = next_s.split()
	if rematch(r'^(480p\|720p\|1080p)(.+)? Links:\Z', next_s):
	gd_txt += f'<b>{next_s.replace("Links:", "GDToT Links :")}</b>\n\n'
	for s in List:
	ns = resub(r'$\|$', '', s)
	if rematch(r'https?://.+\.gdtot\.\S+', ns):
	r = rget(ns)
	soup = BeautifulSoup(r.content, "html.parser")
	title = soup.select('meta[property^="og:description"]')
	gd_txt += f"<code>{(title[0]['content']).replace('Download ' , '')}</code>\n{ns}\n\n"
	elif rematch(r'https?://pastetot\.\S+', ns):
	nxt = resub(r'$\|$\|(https?://pastetot\.\S+)', '', next_s)
	gd_txt += f"\n<code>{nxt}</code>\n{ns}\n"
	return gd_txt

	elif "htpmovies" in link and "/exit.php" in link:
	return htpmovies(link)

	elif "htpmovies" in link:
	prsd = ""
	links = []
	res = rget(link)
	soup = BeautifulSoup(res.text, 'html.parser')
	x = soup.select('a[href^="/exit.php?url="]')
	y = soup.select('h5')
	z = unquote(link.split('/')[-2]).split('-')[0] if link.endswith('/') else unquote(link.split('/')[-1]).split('-')[0]

	for a in x:
	links.append(a['href'])
	prsd = f"Total Links Found : {len(links)}\n\n"

	msdcnt = -1
	for b in y:
	if str(b.string).lower().startswith(z.lower()):
	msdcnt += 1
	url = f"https://htpmovies.lol"+links[msdcnt]
	prsd += f"{msdcnt+1}. <b>{b.string}</b>\n{htpmovies(url)}\n\n"
	asleep(5)
	return prsd

	elif "cinevood" in link:
	res=requests.get(link)
	soup=BeautifulSoup(res.content,'html.parser')
	l=''
	ll=[]
	for j in soup.find_all('h6'):
	ll.append(j.text)
	ld=[]
	for i in soup.find_all('div',{'class':"cat-b"}):
	ld.append(f'<a href="{i.a["href"]}">➥{i.a.button.text}</a> \|')
	a=0
	for i in ll:
	l+=f'{i}\n{ld[a]}{ld[a+1]}\n'
	a+=2
	return l

	elif "atishmkv" in link:
	prsd = ""
	links = []
	res = rget(link)
	soup = BeautifulSoup(res.text, 'html.parser')
	x = soup.select('a[href^="https://gdflix"]')
	for a in x:
	links.append(a['href'])
	for o in links:
	prsd += o + '\n\n'
	return prsd

	elif "teluguflix" in link:
	gd_txt = ""
	r = rget(link)
	soup = BeautifulSoup (r.text, "html.parser")
	links = soup.select('a[href*="gdtot"]')
	gd_txt = f"Total Links Found : {len(links)}\n\n"
	for no, link in enumerate(links, start=1):
	gdlk = link['href']
	t = rget(gdlk)
	soupt = BeautifulSoup(t.text, "html.parser")
	title = soupt.select('meta[property^="og:description"]')
	gd_txt += f"{no}. <code>{(title[0]['content']).replace('Download ' , '')}</code>\n{gdlk}\n\n"
	asleep(1.5)
	return gd_txt

	elif "taemovies" in link:
	gd_txt, no = "", 0
	r = rget(link)
	soup = BeautifulSoup (r.text, "html.parser")
	links = soup.select('a[href*="shortingly"]')
	gd_txt = f"Total Links Found : {len(links)}\n\n"
	for a in links:
	glink = transcript(a["href"], "https://insurance.techymedies.com/", "https://highkeyfinance.com/", 5)
	t = rget(glink)
	soupt = BeautifulSoup(t.text, "html.parser")
	title = soupt.select('meta[property^="og:description"]')
	no += 1
	gd_txt += f"{no}. {(title[0]['content']).replace('Download ' , '')}\n{glink}\n\n"
	return gd_txt

	elif "animeremux" in link:
	gd_txt, no = "", 0
	r = rget(link)
	soup = BeautifulSoup (r.text, "html.parser")
	links = soup.select('a[href*="urlshortx.com"]')
	gd_txt = f"Total Links Found : {len(links)}\n\n"
	for a in links:
	link = a["href"]
	x = link.split("url=")[-1]
	gd_txt+=f'➥ {x}\n'
	return gd_txt

	elif "skymovieshd" in link:
	gd_txt = ""
	res = rget(link, allow_redirects=False)
	soup = BeautifulSoup(res.text, 'html.parser')
	a = soup.select('a[href^="https://howblogs.xyz"]')
	t = soup.select('div[class^="Robiul"]')
	gd_txt += f"<i>{t[-1].text.replace('Download ', '')}</i>\n\n"
	gd_txt += f"<b>{a[0].text} :</b> \n"
	nres = rget(a[0]['href'], allow_redirects=False)
	nsoup = BeautifulSoup(nres.text, 'html.parser')
	atag = nsoup.select('div[class="cotent-box"] > a[href]')
	for no, link in enumerate(atag, start=1):
	gd_txt += f"➥ {link['href']}\n"
	return gd_txt

	elif "animekaizoku" in link:
	global post_id
	gd_txt = ""
	try: website_html = rget(link).text
	except: return "Please provide the correct episode link of animekaizoku"
	try:
	post_id = POST_ID_REGEX.search(website_html).group(0).split(":")[1].split('"')[1]
	payload_data_matches = DDL_REGEX.finditer(website_html)
	except: return "Something Went Wrong !!"

	for match in payload_data_matches:
	payload_data = match.group(0).split("DDL(")[1].replace(")", "").split(",")
	payload = {
	"action" : "DDL",
	"post_id": post_id,
	"div_id" : payload_data[0].strip(),
	"tab_id" : payload_data[1].strip(),
	"num" : payload_data[2].strip(),
	"folder" : payload_data[3].strip(),
	}
	del payload["num"]
	link_types = "DDL" if payload["tab_id"] == "2" else "WORKER" if payload["tab_id"] == "4" else "GDRIVE"
	response = rpost("https://animekaizoku.com/wp-admin/admin-ajax.php",headers={"x-requested-with": "XMLHttpRequest", "referer": "https://animekaizoku.com"}, data=payload)
	soup = BeautifulSoup(response.text, "html.parser")
	downloadbutton = soup.find_all(class_="downloadbutton")

	with concurrent.futures.ThreadPoolExecutor() as executor:
	for button in downloadbutton:
	if button.text == "Patches": pass
	else:
	dict_key = button.text.strip()
	data_dict[dict_key] = []
	executor.submit(looper, dict_key, str(button))
	main_dict[link_types] = deepcopy(data_dict)
	data_dict.clear()

	to_edit = False
	for key in main_dict:
	gd_txt += f"----------------- <b>{key}</b> -----------------\n"
	dict_data = main_dict[key]

	if bool(dict_data) == 0:
	gd_txt += "No Links Found\n"
	else:
	for y in dict_data:
	gd_txt += f"\n○ <b>{y}</b>\n"
	for no, i in enumerate(dict_data[y], start=1):
	try: gd_txt += f"➥ {no}. <i>{i[0]}</i> : {i[1]}\n"
	except: pass
	asleep(5)
	return gd_txt

	else:
	res = rget(link)
	soup = BeautifulSoup(res.text, 'html.parser')
	mystx = soup.select(r'a[href^="magnet:?xt=urn:btih:"]')
	for hy in mystx:
	links.append(hy['href'])
	return links


	###################################################
	# script links

	def getfinal(domain, url, sess):

	#sess = requests.session()
	res = sess.get(url)
	soup = BeautifulSoup(res.text,"html.parser")
	soup = soup.find("form").findAll("input")
	datalist = []
	for ele in soup:
	datalist.append(ele.get("value"))

	data = {
	'_method': datalist[0],
	'_csrfToken': datalist[1],
	'ad_form_data': datalist[2],
	'_Token[fields]': datalist[3],
	'_Token[unlocked]': datalist[4],
	}

	sess.headers = {
	'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:103.0) Gecko/20100101 Firefox/103.0',
	'Accept': 'application/json, text/javascript, /; q=0.01',
	'Accept-Language': 'en-US,en;q=0.5',
	'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
	'X-Requested-With': 'XMLHttpRequest',
	'Origin': domain,
	'Connection': 'keep-alive',
	'Referer': url,
	'Sec-Fetch-Dest': 'empty',
	'Sec-Fetch-Mode': 'cors',
	'Sec-Fetch-Site': 'same-origin',
	}

	# print("waiting 10 secs")
	time.sleep(10) # important
	response = sess.post(domain+'/links/go', data=data).json()
	furl = response["url"]
	return furl


	def getfirst(url):

	sess = requests.session()
	res = sess.get(url)

	soup = BeautifulSoup(res.text,"html.parser")
	soup = soup.find("form")
	action = soup.get("action")
	soup = soup.findAll("input")
	datalist = []
	for ele in soup:
	datalist.append(ele.get("value"))
	sess.headers = {
	'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:103.0) Gecko/20100101 Firefox/103.0',
	'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,/;q=0.8',
	'Accept-Language': 'en-US,en;q=0.5',
	'Origin': action,
	'Connection': 'keep-alive',
	'Referer': action,
	'Upgrade-Insecure-Requests': '1',
	'Sec-Fetch-Dest': 'document',
	'Sec-Fetch-Mode': 'navigate',
	'Sec-Fetch-Site': 'same-origin',
	'Sec-Fetch-User': '?1',
	}

	data = {'newwpsafelink': datalist[1], "g-recaptcha-response": RecaptchaV3()}
	response = sess.post(action, data=data)
	soup = BeautifulSoup(response.text, "html.parser")
	soup = soup.findAll("div", class_="wpsafe-bottom text-center")
	for ele in soup:
	rurl = ele.find("a").get("onclick")[13:-12]

	res = sess.get(rurl)
	furl = res.url
	# print(furl)
	return getfinal(f'https://{furl.split("/")[-2]}/',furl,sess)

	def decodeKey(encoded):
	key = ''

	i = len(encoded) // 2 - 5
	while i >= 0:
	key += encoded[i]
	i = i - 2

	i = len(encoded) // 2 + 4
	while i < len(encoded):
	key += encoded[i]
	i = i + 2

	return key

	def bypassBluemediafiles(url, torrent=False):
	headers = {
	'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:103.0) Gecko/20100101 Firefox/103.0',
	'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,/;q=0.8',
	'Accept-Language': 'en-US,en;q=0.5',
	'Alt-Used': 'bluemediafiles.com',
	'Connection': 'keep-alive',
	'Upgrade-Insecure-Requests': '1',
	'Sec-Fetch-Dest': 'document',
	'Sec-Fetch-Mode': 'navigate',
	'Sec-Fetch-Site': 'none',
	'Sec-Fetch-User': '?1',

	}

	res = requests.get(url, headers=headers)
	soup = BeautifulSoup(res.text, 'html.parser')
	script = str(soup.findAll('script')[3])
	encodedKey = script.split('Create_Button("')[1].split('");')[0]


	headers = {
	'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:103.0) Gecko/20100101 Firefox/103.0',
	'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,/;q=0.8',
	'Accept-Language': 'en-US,en;q=0.5',
	'Referer': url,
	'Alt-Used': 'bluemediafiles.com',
	'Connection': 'keep-alive',
	'Upgrade-Insecure-Requests': '1',
	'Sec-Fetch-Dest': 'document',
	'Sec-Fetch-Mode': 'navigate',
	'Sec-Fetch-Site': 'same-origin',
	'Sec-Fetch-User': '?1',
	}

	params = { 'url': decodeKey(encodedKey) }

	if torrent:
	res = requests.get('https://dl.pcgamestorrents.org/get-url.php', params=params, headers=headers)
	soup = BeautifulSoup(res.text,"html.parser")
	furl = soup.find("a",class_="button").get("href")

	else:
	res = requests.get('https://bluemediafiles.com/get-url.php', params=params, headers=headers)
	furl = res.url
	if "mega.nz" in furl:
	furl = furl.replace("mega.nz/%23!","mega.nz/file/").replace("!","#")

	#print(furl)
	return furl

	def igggames(url):
	res = requests.get(url)
	soup = BeautifulSoup(res.text,"html.parser")
	soup = soup.find("div",class_="uk-margin-medium-top").findAll("a")

	bluelist = []
	for ele in soup:
	bluelist.append(ele.get('href'))
	bluelist = bluelist[6:-1]

	links = ""
	for ele in bluelist:
	if "bluemediafiles" in ele:
	links = links + bypassBluemediafiles(ele) + "\n"
	elif "pcgamestorrents.com" in ele:
	res = requests.get(ele)
	soup = BeautifulSoup(res.text,"html.parser")
	turl = soup.find("p",class_="uk-card uk-card-body uk-card-default uk-card-hover").find("a").get("href")
	links = links + bypassBluemediafiles(turl,True) + "\n"
	else:
	links = links + ele + "\n"

	return links[:-1]
	def try2link_bypass(url):
	client = cloudscraper.create_scraper(allow_brotli=False)

	url = url[:-1] if url[-1] == '/' else url
	print(f'ry2link_bp {url}')
	params = (('d', int(time.time()) + (60 * 4)),)
	r = client.get(url, params=params, headers= {'Referer': 'https://newforex.online/'})

	soup = BeautifulSoup(r.text, 'html.parser')
	inputs = soup.find(id="go-link").find_all(name="input")
	data = { input.get('name'): input.get('value') for input in inputs }
	time.sleep(7)

	headers = {'Host': 'try2link.com', 'X-Requested-With': 'XMLHttpRequest', 'Origin': 'https://try2link.com', 'Referer': url}

	bypassed_url = client.post('https://try2link.com/links/go', headers=headers,data=data)
	return bypassed_url.json()["url"]

	def try2link_scrape(url):
	client = cloudscraper.create_scraper(allow_brotli=False)
	h = {
	'upgrade-insecure-requests': '1', 'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.0.0 Safari/537.36',
	}
	res = client.get(url, cookies={}, headers=h)
	print(res.headers)
	url = 'https://try2link.com/'+re.findall('try2link\.com\/(.*?) ', res.text)[0]
	print(url)
	return try2link_bypass(url)


	def psa_bypasser(psa_url):
	cookies = {'cf_clearance': 'EgNaZUZVvICwi_V.34D6bTmYzyp24zoY_SFrC2vqm7U-1694540798-0-1-530db2b8.dee7f907.c12667d1-0.2.1694540798' }
	headers = {
	'authority': 'psa.wf',
	'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,/;q=0.8,application/signed-exchange;v=b3;q=0.7',
	'accept-language': 'en-US,en;q=0.9',
	'referer': 'https://psa.wf/',
	'user-agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36',
	}

	r = requests.get(psa_url, headers=headers, cookies=cookies)
	soup = BeautifulSoup(r.text, "html.parser").find_all(class_="dropshadowboxes-drop-shadow dropshadowboxes-rounded-corners dropshadowboxes-inside-and-outside-shadow dropshadowboxes-lifted-both dropshadowboxes-effect-default")
	links = []
	for link in soup:
	try:
	exit_gate = link.a.get("href")
	if "/exit" in exit_gate:
	print("scraping :",exit_gate)
	links.append(try2link_scrape(exit_gate))
	except: pass
	return links
	def themoviesboss(url):
	script=requests.get(url).text
	match = re.search('window\.location\.href="(.*?)"', script)
	if match:
	url = match.group(1)
	if url=='https://themoviesboss.site':
	return 'File not Found'
	else:
	return f'link:{url}\nBypass link: {shortners(url)}'
	def moviesboss(url):
	script=requests.get(url)
	soup=BeautifulSoup(script.content,'html.parser')
	l=''
	def boss(url):
	script=requests.get(url).text
	match = re.search('window\.location\.href="(.*?)"', script)
	if match:
	url = match.group(1)
	if url=='https://themoviesboss.site':
	return 'https://themoviesboss.site'
	else:
	return f'{(url)}'
	for p,q in zip(soup.find_all('p',{'style':"text-align: center;"}),soup.find_all('a', class_='maxbutton-2 maxbutton')):
	aa=p.strong.text.strip().split('\n')[0]
	l+=f"➥<a href='{boss(q['href'])}'>{aa}</a> \|\n"

	return l
	def tenbit(url):
	res=requests.get(url)
	soup=BeautifulSoup(res.content,'html.parser')
	l=''
	# for i in soup.find_all('span',{'style':"color: #ffffff;"}):
	# l+=f'{i.text}'
	l+='\nLinks: '
	for i in soup.find_all('a',{'class':'mb-button'}):
	l+=f'<a href="{i.get("href")}">➥{str(i.text).lstrip()}</a> \|'
	return l
	def animepahe(link):
	client = cloudscraper.session()
	res = client.get(link)
	soup = BeautifulSoup(res.text, "html.parser")
	l = soup.find_all("div", id="pickDownload")
	l2 = []
	l3 = []
	s = f"{soup.find('title').text}\n"
	print(s)
	for i in l:
	for j in i.find_all("a"):
	l2.append(str(j.text).replace("SubsPlease · ",""))
	res1 = client.get(j.get('href')).text
	soup1 = BeautifulSoup(res1, "html.parser")
	l3.append(set_direct_link(soup1.find("a", class_="redirect").get('href')))
	for a,b in zip(l2,l3):
	s += f'<a href="{b}">➳ {a}\| </a>'
	return s
	async def atishmkv(url):
	client = cloudscraper.create_scraper(allow_brotli=False)
	res=client.get(url)
	soup=BeautifulSoup(res.content,'html.parser')
	l=f'Title:{soup.find("title").text}\n'
	for i in soup.find_all('a', class_="button button-shadow"):
	l+=f'➥<a href="{i.get("href")}">{str(i.get_text()).lstrip()}</a> \|\n'
	return l
	async def telegraph_scaper(url):
	res=requests.get(url)
	soup=BeautifulSoup(res.content,'html.parser')
	ll='Scrape Links \n'
	for i,j in zip(soup.find_all('strong'),soup.find_all('code')):#,class_='tl_article_content'):
	ll+=f'➥<a href="{i.a.get("href")}">{str(j.get_text()).lstrip()}</a> \|\n'
	return(ll)

	def atoz(url):
	re=requests.get(url)
	soup=BeautifulSoup(re.content,'html.parser')
	l=f'Title: {soup.find("title")}\n'
	try:
	for i in soup.select('div[class*="mks_accordion_item"]'):
	l+=f'➥<a href="https://www.atozcartoonist.com{i.a["href"]}">{str(i.text).lstrip()}</a>\n'

	except: print('j')
	return l
	async def toonworld4all(url: str):
	if "/redirect/main.php?url=" in url:
	return f'┎ <b>Source Link:</b> {url}\n┃\n┖ <b>Bypass Link:</b> {rget(url).url}'
	xml = rget(url).text
	soup = BeautifulSoup(xml, 'html.parser')
	if '/episode/' not in url:
	epl = soup.select('a[href*="/episode/"]')
	tls = soup.select('div[class*="mks_accordion_heading"]')
	stitle = search(r'\"name\":\"(.+)\"', xml).group(1).split('"')[0]
	prsd = f'<b><i>{stitle}</i></b>'
	for n, (t, l) in enumerate(zip(tls, epl), start=1):
	prsd += f'''

	{n}. <i><b>{t.strong.string}</b></i>
	┖ <b>Link :</b> {l["href"]}'''
	return prsd
	links = soup.select('a[href*="/redirect/main.php?url="]')
	titles = soup.select('h5')
	prsd = f"<b><i>{titles[0].string}</i></b>"
	titles.pop(0)
	slicer, _ = divmod(len(links), len(titles))
	atasks = []
	for sl in links:
	nsl = ""
	while all(x not in nsl for x in ['rocklinks', 'link1s']):
	nsl = rget(sl["href"], allow_redirects=False).headers['location']
	print(nsl)
	if "rocklinks" in nsl:
	atasks.append(create_task(transcript(nsl, "https://insurance.techymedies.com/", "https://highkeyfinance.com/", 5)))
	elif "link1s" in nsl:
	atasks.append(create_task(transcript(nsl, "https://link1s.com", "https://anhdep24.com/", 9)))

	com_tasks = await gather(*atasks, return_exceptions=True)
	lstd = [com_tasks[i:i+slicer] for i in range(0, len(com_tasks), slicer)]

	for no, tl in enumerate(titles):
	prsd += f"\n\n<b>{tl.string}</b>\n┃\n┖ <b>Links :</b> "
	for tl, sl in zip(links, lstd[no]):
	if isinstance(sl, Exception):
	prsd += str(sl)
	else:
	prsd += f"<a href='{sl}'>{tl.string}</a>, "
	prsd = prsd[:-2]
	return prsd
	async def toonhub_scrapper(url):
	client = cloudscraper.create_scraper(allow_brotli=False)
	if 'redirect/?url' in url:
	res=client.get(url,allow_redirects=False).headers['Location']
	return await shortners(res)
	res = client.get(url)
	soup = BeautifulSoup(res.content, 'html.parser')
	if '/episode/' not in url:
	l = f'{soup.find("title").text}\n'
	for i, j in zip(soup.find_all('div', {'class': "three_fourth tie-columns last"}),
	soup.find_all('div', {'class': 'toggle'})):
	l += f'<a href="{j.a.get("href")}">{str(j.h3.text).lstrip()}\n</a>Context: {i.text}\n'
	return l

	links = soup.select('a[href*="/redirect/?url="]')
	titles = soup.select('h5')
	prsd = f"<b><i>{titles[0].string}</i></b>"
	titles.pop(0)
	slicer, _ = divmod(len(links), len(titles))
	atasks = []
	for sl in links:
	nsl = client.get(f'https://toonshub.link/{sl["href"]}', allow_redirects=False).headers['location']
	print(nsl)
	atasks.append(create_task(shortners(nsl)))
	com_tasks = await gather(*atasks, return_exceptions=True)
	lstd = [com_tasks[i:i+slicer] for i in range(0, len(com_tasks), slicer)]

	for no, tl in enumerate(titles):
	prsd += f"\n\n<b>{tl.string}</b>\n┃\n┖ <b>Links :</b> "
	for tl, sl in zip(links, lstd[no]):
	if isinstance(sl, Exception):
	prsd += str(sl)
	else:
	prsd += f"<a href='{sl}'>{tl.string}</a>, "
	prsd = prsd[:-2]
	return prsd

	async def dhakrey(url):
	cget = cloudscraper.create_scraper(allow_brotli=False).request
	resp = cget("GET", url)
	soup=BeautifulSoup(resp.text,'html.parser')
	title=f'\nTitle: {soup.find("title").text}\n\n'
	for button in soup.find_all('button', onclick=True):
	onclick_value = button['onclick']
	match = re.search(r"window\.open$['\"](https://drive.daddyop.us/dl[^'\"]+)['\"].*?$", onclick_value)
	download=re.search(r"window\.open$['\"](https://[^'\"]download\.aspx[^'\"])['\"].*?$", onclick_value)
	if match:
	https_link = match.group(1)
	button_text = button.get_text().strip()
	if button_text=='Direct Drive Link':
	soup1=BeautifulSoup(cget('GET',https_link).content,'html.parser')
	drive_links = soup1.select('a[href^="https://drive.google.com"]')
	filepress=soup1.select('a[href^="https://new.filepress.store"]')
	for link,flink in zip(drive_links,filepress):
	title+=f'➥<a href="{link["href"]}">{str("Drive Link").lstrip()}</a> \| '
	title+=f'➥<a href="{flink["href"]}">{str("Filepress Link").lstrip()}</a> \| '
	if download:
	https_link = download.group(1)
	button_text = button.get_text().strip()
	title+=f'➥<a href="{https_link}">{str(button_text).lstrip()}</a> \|\n'

	return title
	def publicearn(url,uid):
	chromedriver_autoinstaller.install()
	chrome_options = webdriver.ChromeOptions()
	chrome_options.add_argument("--no-sandbox")
	chrome_options.add_argument("--headless")
	chrome_options.add_argument("--disable-dev-shm-usage")
	driver = webdriver.Chrome(options=chrome_options)
	driver.get(url)
	for i in range(0,31):
	time.sleep(1)
	print(i)
	code=url.split('/')[-1]
	ref=(driver.current_url).split('//')[-1].split('/')[0]
	print(ref)
	cget = cloudscraper.create_scraper(allow_brotli=False).request
	resp = cget("GET", f"https://go.publicearn.com/{code}/?uid={uid}", headers={"referer": f'https://{ref}/'})
	soup = BeautifulSoup(resp.content, "html.parser")
	data = { inp.get('name'): inp.get('value') for inp in soup.find_all("input") }
	print(data)
	resp = cget("POST", f"https://go.publicearn.com/links/go", data=data, headers={ "x-requested-with": "XMLHttpRequest" })
	try:
	return resp.json()['url']
	except Exception as e:
	print(e)


	# shortners
	async def shortners(url):
	if "https://igg-games.com/" in url:
	print("entered igg:",url)
	return igggames(url)
	elif "https://katdrive." in url:
	if KATCRYPT == "":
	return "🚫 __You can't use this because__ KATDRIVE_CRYPT __ENV is not set__"

	print("entered katdrive:",url)
	return drivescript(url, KATCRYPT, "KatDrive")
	elif "https://kolop." in url:
	if KCRYPT == "":
	return "🚫 __You can't use this because__ KOLOP_CRYPT __ENV is not set__"

	print("entered kolop:",url)
	return kolop_dl(url, KCRYPT)

	# hubdrive
	elif "https://hubdrive." in url:
	if HCRYPT == "":
	return "🚫 __You can't use this because__ HUBDRIVE_CRYPT __ENV is not set__"

	print("entered hubdrive:",url)
	return drivescript(url, HCRYPT, "HubDrive")

	# drivefire
	elif "https://drivefire." in url:
	if DCRYPT == "":
	return "🚫 __You can't use this because__ DRIVEFIRE_CRYPT __ENV is not set__"

	print("entered drivefire:",url)
	return drivefire_dl(url, DCRYPT)

	# filecrypt
	elif (("https://filecrypt.co/") in url or ("https://filecrypt.cc/" in url)):
	print("entered filecrypt:",url)
	return filecrypt(url)

	# shareus
	elif "https://shareus." in url or "https://shrs.link/" in url:
	print("entered shareus:",url)
	return shareus(url)



	elif "https://shorte.st/" in url:
	print("entered shorte:",url)
	return sh_st_bypass(url)

	elif "https://psa.wf/exit" in url:
	print("enterezbd psa:",url)
	return try2link_scrape(url)
	# psa
	elif "https://psa.wf/" in url:
	print("entered pssfdgsga:",url)
	return psa_bypasser(url)

	# sharer pw
	elif "https://sharer.pw/" in url:
	if XSRF_TOKEN == "" or Laravel_Session == "":
	return "🚫 __You can't use this because__ XSRF_TOKEN __and__ Laravel_Session __ENV is not set__"

	print("entered sharer:",url)
	return sharer_pw(url, Laravel_Session, XSRF_TOKEN)

	# gdtot url
	elif "gdtot.cfd" in url:
	print("entered gdtot:",url)
	return f"<b><i>Can't bypass Now.They add cloudflare protection.</i></b>"
	elif 'dhakrey' in url:
	return await dhakrey(url)
	# adfly
	elif "https://adf.ly/" in url:
	print("entered adfly:",url)
	out = adfly(url)
	return out['bypassed_url']
	# droplink
	elif "https://droplink.co/" in url:
	print("entered droplink:",url)
	return droplink(url)

	# linkvertise
	elif "https://linkvertise.com/" in url:
	print("entered linkvertise:",url)
	return linkvertise(url)


	# ouo
	elif "https://ouo.press/" in url or "https://ouo.io/" in url:
	print("entered ouo:",url)
	return ouo(url)

	# try2link
	elif "https://try2link.com/" in url:
	print("entered try2links:",url)
	return try2link_bypass(url)



	# rslinks
	elif "rslinks.net" in url:
	print("entered rslinks:",url)
	return rslinks(url)

	# bitly + tinyurl
	elif "bit.ly" in url or "tinyurl.com" in url:
	print("entered bitly_tinyurl:",url)
	return bitly_tinyurl(url)

	# thinfi
	elif "thinfi.com" in url:
	print("entered thinfi:",url)
	return thinfi(url)

	# htpmovies sharespark cinevood
	elif "https://htpmovies." in url or 'sharespark' in url or "https://skymovieshd" in url \
	or "https://teluguflix" in url or 'https://taemovies' in url or "https://animeremux" in url or 'https://cinevood.' in url or 'https://animeremux.' in url:
	print("entered htpmovies sharespark cinevood skymovieshd :",url)
	return scrappers(url)

	# gdrive look alike
	elif ispresent(gdlist,url):
	print("entered gdrive look alike:",url)
	return unified(url)

	# others
	elif ispresent(otherslist,url):
	print("entered others:",url)
	return others(url)

	elif "toonworld4all.me/redirect/main.php?" in url:
	nsl=''
	while not any(x in nsl for x in ['rocklinks', 'link1s']):
	nsl=rget(url,allow_redirects=False).headers['location']
	if 'go.rocklinks' in nsl:
	as1=await transcript(nsl, "https://insurance.techymedies.com/", "https://highkeyfinance.com/", 5)
	else:
	as1=await transcript(nsl,"https://link1s.com/","https://anhdep24.com/",8)
	return as1
	#Toonworld4all
	elif "toonworld4all" in url:
	print("entered toonworld4all:",url)
	return await toonworld4all(url)
	elif "toonshub" in url:
	return await toonhub_scrapper(url)

	# elif "drive.google.com/" in url:
	# if 'view' in url:
	# d=url.index('view')
	# url=url[0:66].split('/')
	# url=url[-2]
	# return f'🔗Link: <a href="https://indexlink.mrprincebotz.workers.dev/direct.aspx?id={url}">ɪɴᴅᴇx ʟɪɴᴋ</a>'
	# elif 'id' in url:
	# try:
	# ur=url.index('&export=download')
	# url=url[0:64].split('=')
	# url=url[-1]
	# return f'🔗Link: <a href="https://indexlink.mrprincebotz.workers.dev/direct.aspx?id={url}">ɪɴᴅᴇx ʟɪɴᴋ</a>'
	# except:
	# url=url[0:64].split('=')
	# url=url[-1]
	# return f'🔗Link: <a href="https://indexlink.mrprincebotz.workers.dev/direct.aspx?id={url}">ɪɴᴅᴇx ʟɪɴᴋ</a>'
	elif "drive.google.com/" in url:
	return f'🔗ɪɴᴅᴇx ʟɪɴᴋ: {get_dl(url)}'
	#vnshortener
	elif "vnshortener.com" in url:
	print("entered vnshortener:",url)
	return vnshortener(url)
	elif "themoviesboss.site/secret?" in url:
	print("entered themoviesboss:",url)
	return themoviesboss(url)
	elif "themoviesboss.site" in url:
	print("entered moviesboss:",url)
	return moviesboss(url)
	elif 'https://files.technicalatg.com/' in url:
	code=url.split('/')[-1]
	return f'https://atglinks.com/{code}'
	elif 'https://atglinks.com/' in url:
	return f"There's NO Bypass for atglinks.com Now "
	#tenbit
	elif "https://10bitclub.me" in url:
	print("entered 10bitclub:",url)
	return tenbit(url)

	elif "https://animepahe.ru" in url:
	print("entered animepahe:",url)
	return animepahe(url)

	#du_link
	elif "https://du-link.in" in url:
	print("entered du_link:",url)
	return du_link(url)
	#atozcartoonist
	elif "https://www.atozcartoonist.com/redirect/" in url:
	print("entered atozcartoonist:",url)
	return atozcartoonist(url)
	elif "https://www.atozcartoonist.com/" in url:
	print("entered atoz:",url)
	return atoz(url)
	elif 'atishmkv.wiki' in url:
	print(f"entered atishmkv: {url}")
	return await atishmkv(url)
	#telegraph_scaper
	elif 'https://graph.org' in url:
	print(f"entered telegraph_scaper: {url}")
	return await telegraph_scaper(url)

	elif "shrinkforearn" in url:
	return await transcript(url,"https://shrinkforearn.in/","https://wp.uploadfiles.in/", 10)
	elif "link.short2url" in url:
	return await transcript(url,"https://techyuth.xyz/blog/", "https://blog.mphealth.online/", 9)
	elif "viplinks" in url:
	return await transcript(url,"https://m.vip-link.net/", "https://m.leadcricket.com/", 5)
	elif "bindaaslinks" in url:
	return await transcript(url,"https://thebindaas.com/blog/", "https://finance.appsinsta.com/", 5)
	elif "sheralinks" in url:
	return await transcript(url,"https://link.blogyindia.com/", "https://blogyindia.com/", 5)
	elif "url4earn" in url:
	return await transcript(url,"https://go.url4earn.in/", "https://techminde.com/", 8)
	elif "tglink" in url:
	url=url.lower()
	return await transcript(url, "https://tglink.in/", "https://www.proappapk.com/", 5)
	elif "link1s.com" in url:
	return await transcript(url,"https://link1s.com/","https://anhdep24.com/",8)
	elif "gofile.io" in url:
	return gofile_dl(url)
	elif "publicearn" in url:
	return publicearn(url,uid)
	elif "links4money.com" in url:
	return await transcript(url,'https://links4money.com','https://gamergiri.infokeeda.xyz',2)
	elif "happiurl.com" in url:
	return await transcript(url,'https://count.financevis.com/','https://financevis.com/',5)
	elif "linkfly" in url:
	return await transcript(url, "https://go.linkfly.in", "https://techyblogs.in/", 4)
	elif "mdiskshortner" in url:
	return await transcript(url, "https://loans.yosite.net", "https://yosite.net", 10)
	elif "narzolinks" in url:
	return await transcript(url, "https://go.narzolinks.click/", "https://hydtech.in/", 5)
	elif "earn2me" in url:
	return await transcript(url, "https://blog.filepresident.com/", "https://easyworldbusiness.com/", 5)
	elif "adsfly" in url:
	return await transcript(url, "https://go.adsfly.in/", "https://loans.quick91.com/", 5)
	elif "link4earn" in url:
	return await transcript(url, "https://link4earn.com", "https://studyis.xyz/", 5)
	elif "pdisk.site" in url:
	return await transcript(url, "https://go.moneycase.link", "https://go.moneycase.link", 2)
	elif "link.tnshort.net/" in url or "link.tnlink.net/" in url:
	return await transcript(url, "https://go.tnshort.net", "https://market.finclub.in", 10)
	elif "ziplinker.net" in url:
	return await transcript(url,'https://ziplinker.net/web','https://ontechhindi.com/',0.04)
	elif "urllinkshort.in" in url:
	return await transcript(url,'https://web.urllinkshort.in/','https://suntechu.in/',4.5)
	elif "kpslink.in" in url:
	return await transcript(url, "https://get.infotamizhan.xyz/", "https://infotamizhan.xyz/", 5)
	elif "v2.kpslink.in" in url:
	return await transcript(url, "https://v2download.kpslink.in/", "https://infotamizhan.xyz/", 5)
	elif "go.lolshort" in url:
	return await transcript('http://go.lolshort.tech/DoCpsBrG', "https://get.lolshort.tech/", "https://tech.animezia.com/", 8)
	elif "go.lolshort" in url:
	return await transcript(url, "https://blog.vllinks.in", "https://vlnewshd.in/", 8)
	elif "onepagelink" in url:
	return await transcript(url, "https://go.onepagelink.in/", "https://gorating.in/", 0.9)
	elif "pkin" in url:
	return await transcript(url, "https://go.paisakamalo.in", "https://techkeshri.com/", 9)
	elif "shrinke" in url:
	return await transcript(url, "https://en.shrinke.me/", "https://themezon.net/", 15)
	elif "mplaylink" in url:
	return await transcript(url, "https://tera-box.cloud/", "https://mvplaylink.in.net/", 0.5)
	elif "ewlink" in url:
	return await transcript(url, "https://ewlink.xyz/", "https://rxfastrx.com/", 0)
	elif "sklinks" in url:
	return await transcript(url, "https://sklinks.in", "https://sklinks.in/", 4.5)
	elif "dalink" in url:
	return await transcript(url, "https://get.tamilhit.tech/X/LOG-E/", "https://www.tamilhit.tech/", 8)
	elif "rocklinks" in url:
	return await transcript(url, "https://insurance.techymedies.com/", "https://highkeyfinance.com/", 5)
	elif "short_jambo" in url:
	return await transcript(url, "https://short-jambo.com/","https://1.newworldnew.com/",0.7)
	elif "ez4short" in url:
	return await transcript(url, "https://ez4short.com/","https://ez4mods.com/",5)
	elif "shortingly.com" in url:
	return await transcript(url,"https://go.blogytube.com/","https://blogytube.com/",1)
	elif "https://gyanilinks.com/" in url or "https://gtlinks.me/" in url:
	return await transcript(url,"https://go.hipsonyc.com","https://earn.hostadviser.net",5)
	elif "https://flashlinks.in/" in url:
	return await transcript(url,"https://flashlinks.in", "https://flashlinks.online/",13)
	elif "urlsopen" in url:
	return await transcript(url, "https://s.humanssurvival.com/", "https://1topjob.xyz/", 1)
	elif "xpshort" in url:
	return f"Can't Bypass.Invisible captcha"
	#return await transcript(url, "https://techymozo.com/", "https://portgyaan.in/", 0)
	elif "go.moonlinks.in/" in url:
	return await transcript(url, "https://go.moonlinks.in/", "https://www.akcartoons.in/", 7)
	elif "vivdisk" in url:
	return await transcript(url, "https://tinyfy.in/", "https://web.yotrickslog.tech/", 0)
	elif "https://krownlinks.me" in url:
	return await transcript(url, "https://go.hostadviser.net/", "https://blog.hostadviser.net/", 8)
	elif "adrinolink" in url:
	return f'https://bhojpuritop.in/safe.php?link={url.split("/")[-1]}'#await transcript(url, "https://adrinolinks.in/", "https://amritadrino.com", 8)
	elif "mdiskshortner" in url:
	return await transcript(url, "https://mdiskshortner.link", "https://m.proappapk.com", 2)
	elif "tiny" in url:
	return await transcript(url, "https://tinyfy.in", "https://www.yotrickslog.tech", 0)
	elif "earnl" in url:
	return await transcript(url, "https://v.earnl.xyz", "https://link.modmakers.xyz", 5)
	elif "moneykamalo" in url:
	return await transcript(url, "https://go.moneykamalo.com", "https://blog.techkeshri.com", 5)
	elif "v2links" in url:
	return await transcript(url, "https://vzu.us", "https://gadgetsreview27.com", 15)
	elif "tnvalue" in url:
	return await transcript(url, "https://get.tnvalue.in/", "https://finclub.in", 8)
	elif "omnifly" in url:
	return await transcript(url, "https://f.omnifly.in.net/", "https://f.omnifly.in.net/", 8)
	elif "indianshortner" in url:
	return await transcript(url, "https://indianshortner.com/", "https://moddingzone.in", 5)
	elif "indianshortner" in url:
	return await transcript(url, "https://techy.veganab.co", "https://veganab.co/", 8)
	elif "indi" in url:
	return await transcript(url, "https://file.earnash.com/", "https://indiurl.cordtpoint.co.in/", 10)
	elif "linkbnao" in url:
	return await transcript(url, "https://vip.linkbnao.com", "https://ffworld.xyz/", 2)
	elif "mdiskpro" in url:
	return await transcript(url, "https://mdisk.pro", "https://www.meclipstudy.in", 8)
	elif "omegalinks" in url:
	return await transcript(url, "https://tera-box.com", "https://m.meclipstudy.in", 8)
	elif "mdisklink" in url:
	return await transcript(url, "https://powerlinkz.in", "https://powerlinkz.in", 2)
	elif "indshort" in url:
	return await transcript(url, "https://indianshortner.com", "https://moddingzone.in", 5)
	elif "indyshare" in url:
	return await transcript(url, "https://download.indyshare.net", "https://bestdjsong.com/", 15)
	elif "mdisklink" in url:
	return await transcript(url, "https://gotolink.mdisklink.link/", "https://loans.yosite.net/", 2)
	elif "tamizhmasters" in url:
	return await transcript(url, "https://tamizhmasters.com/", "https://pokgames.com/", 5)
	elif "vipurl" in url:
	return await transcript(url, "https://count.vipurl.in/", "https://awuyro.com/", 8)
	elif "linksly" in url:
	return await transcript(url, "https://go.linksly.co", "https://en.themezon.net/", 10)
	elif "link1s" in url:
	return await transcript(url,'https://link1s.net','https://nguyenvanbao.com/',0)
	elif "sxslink" in url:
	return await transcript(url, "https://getlink.sxslink.com/", "https://cinemapettai.in/", 5)
	elif "urlspay.in" in url:
	return await transcript(url, "https://finance.smallinfo.in/", "https://loans.techyinfo.in/", 5)
	elif "linkpays.in" in url:
	return await transcript(url, "https://tech.smallinfo.in/Gadget/", "https://loan.insuranceinfos.in/", 5)
	elif "seturl.in" in url:
	return await transcript(url,'https://set.seturl.in/','https://earn.petrainer.in/',5)
	else: return "Not in Supported Sites"

	################################################################################################################################