KL-Py 0.0.1__py3-none-any.whl

KL_Py/KL_Py.py

@@ -0,0 +1,4400 @@
+from types import *
+from typing import Callable, TypeVar, NewType, Any, Optional, Union, get_origin, Final, Self, Generic, Sequence, Iterable, Iterator, Generator, Mapping, List, Tuple, Set, Dict, defaultdict, Counter, Literal, NoReturn, Never
+from abc import abstractmethod, ABCMeta, ABC as AbstractBaseClass
+import functools
+from functools import reduce, lru_cache, cache, wraps, partial, partialmethod
+from dataclasses import dataclass
+# need both math imports for convenience
+from numbers import Number
+from random import randint as old_randint, uniform as old_randflt
+import time
+import time as timer
+from threading import Timer
+import datetime
+from dateutil.parser import parse as parse_date, ParserError
+from math import *
+# need both math imports for convenience
+from copy import deepcopy
+from pathlib import Path
+import builtins, os, sys, argparse, io, asyncio, random, urllib, traceback, time as Time, platform, json, shutil, glob, shlex, signal, site, base64, enum, collections, collections.abc, importlib, functools, cmd, ctypes, stat, math, re, ast, webbrowser, subprocess, requests
+from base64 import b64encode, b64decode
+from urllib.parse import quote_plus as encode_url, quote as encode_url_soft, unquote_plus as normalize_url, unquote as normalize_url_soft
+from contextlib import contextmanager, redirect_stdout, redirect_stderr
+from itertools import product as collective_iter, count
+from re import escape
+import enum # NOTE: to allow enum.auto without making it global
+# both of these imports are needed ^V
+from enum import Enum
+from inspect import *
+from hindGui import *
+from when import *
+encodeurl = urlencode = url_encode = encode_url
+encodeurlsoft = encode_urlsoft = urlencodesoft = url_encode_soft =encode_url_soft
+decodeurl = decode_url = normurl = norm_url = normalizeurl = urldecode = url_decode =normalize_url
+decodeurlsoft = decode_url_soft = normurlsoft = norm_url_soft = normalizeurlsoft = urlencodesoft = url_encode_soft =normalize_url_soft
+base64.encode = base64_encode = base64.b64encode
+base64.decode = base64_decode = base64.b64decode
+Many = Union
+Nullable = Optional
+argv = ARGV = sys.argv[1:]
+# helper regexes
+HEX_RE = HEX_REGEX = r"(?:0x|#)?(?:[a-f0-9]{3}){1,2}"
+PIN_RE = PIN_REGEX =  r"^\d{4,64}$"
+MAIL_RE = MAIL_REGEX = EMAIL_RE = EMAIL_REGEX = r"(?P<profile>[\w.+\!\-]+)@(?P<domain>[a-zA-Z0-9](?:[a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?)(?P<suffix>(?:\.[a-zA-Z]{2,})+)"
+STRICT_PWD_RE = STRICT_PWD_REGEX = STRICT_PASSWORD_RE = STRICT_PASSWORD_REGEX = r"(?=.*\d)(?=.*[A-Z])(?=.*[a-z])(?=.*[^\w\d ])(.{8,})"
+PHONE_RE = PHONE_REGEX = r"(?:(?P<start>\+|0{2})?(?P<country>\d{1,3}))?(?:[\-\(]|(?<=\d) )*(?P<A>\d{3})[ \-\)]*(?P<B>\d{3})[ \-\)]*(?P<C>\d{4})"
+HTML_RE = HTML_REGEX = r"\s*(?P<tag>\<\s*(?P<tagName>[\!\/]?\w+)\s*(?P<attributes>(?P<attributeName>[\w\-]+)(?:\s*\=\s*[\"\']?(?P<attributeValue>[^\"\'\<\>]+)?[\"\']?\s*)?\s*)*\s*\/?>)(?P<content>[^\<\>]*)(?P<possibleClosingTag>\<\s*\/\s*(?P<possibleClosingTagName>\w+)\s*\>)?\s*"
+CSS_RE = CSS_REGEX = r"(?P<tag>[\w.\#\:\-\s\,\+\~\>\[\]\=\'\"\\\^\$\~\*]+)\s*\{(?P<pairs>(?:\s*[\w\-]{3,}\:\s*[\w\s\-\,\(\)\\\'\"\#\%.\+\-\*\/]+;\s*)+)\}"
+URL_RE = URL_REGEX = r"(?P<protocol>\w+\:[\\\/]{2,3})?(?:(?P<subDomain>[\w\-]+)\.)?(?P<domain>[\w\-]+)(?P<suffix>(?:\.[a-zA-Z]{2,})+)(?P<port>\:\d{1,5})?(?P<route>\/[^ \?\=\&\#]*)?(?P<query>\?[^ \#]*)?(?P<hash>\#[\w\-]*)?"
+TITLE_CASED_WORD_RE = TITLE_CASED_WORD_REGEX = r"[A-Z][a-z]*(?: +[A-Z][a-z]*)+"
+ALPHA_RE = ALPHA_REGEX = r"[A-Za-z]+"
+LETTERS_WITH_SYMBOLS_RE = LETTERS_WITH_SYMBOLS_REGEX = r"[a-zA-Z (\(\)\{\}\[\]\&\:\;\-\'\"\?\!\,\.)]+"
+TRAILING_SPACE_RE = TRAILING_SPACE_REGEX = r"(^\s+|\s+$)"
+NUM_RE = NUM_REGEX = r"(\-?\d*\.?\d+)"
+NON_NUM_RE: str = r"[^\-\.\d]+"
+INT_RE = INTEGEGER_RE = INT_REGEX = INTEGEGER_REGEX = r"\-?\d+"
+WORD_RE = WORD_REGEX = r"[A-Za-z_\'][\w\']*(?:\-[A-Za-z_\']\w*(?: [A-Za-z_\'][\w\']*){0})*"
+NON_WORD_RE = NON_WORD_REGEX = r"[^A-Za-z_\-]|\-(?![A-Za-z_])"
+def __rgx_is_full_match__(pattern, s): return bool(re.search(f"^{pattern}$", str(s) if s is not None else ""))
+def __rgx_catch__(pattern, s) -> str | list[str]:
+	matches: list[str] = re.findall(pattern, str(s) if s is not None else "")
+	return matches[0] if len(matches) == 1 else matches
+jumle_me_he = lafz_me_he = lambda y, x: re.search(y, x) or False if isinstance(y, str) and isinstance(x, str) else False
+is_mail = is_email = ismail = isemail = lambda s: __rgx_is_full_match__(MAIL_RE, s)
+he_mail = hemail = he_email = heemail = is_mail
+catch_mail = catch_email = catchmail = catchemail = pakro_mail = pakromail = pakro_email = pakroemail = lambda s: __rgx_catch__(MAIL_RE, s)
+has_mail = has_email = hasmail = hasemail = lambda s: catch_mail(s) != []
+me_he_mail = mehemail = me_he_email = meheemail = has_mail
+is_strict_pwd = is_strictpwd = isstrict_pwd = isstrictpwd = lambda s: __rgx_is_full_match__(STRICT_PWD_RE, s)
+he_strict_pwd = he_strictpwd = hestrict_pwd = hestrictpwd = is_strict_pwd
+catch_strict_pwd = catch_strictpwd = catchstrict_pwd = catchstrictpwd = pakro_strict_pwd = pakro_strictpwd = pakrostrict_pwd = pakrostrictpwd = lambda s: __rgx_catch__(STRICT_PWD_RE, s)
+has_strict_pwd = has_strictpwd = hasstrict_pwd = hasstrictpwd = lambda s: catch_strict_pwd(s) != []
+is_phone = isphone = is_phone_number = isphonenumber = is_phone_nr = isphonenr = lambda s: __rgx_is_full_match__(PHONE_RE, s)
+he_phone = hephone = he_phone_number = hephonenumber = he_phone_nr = hephonenr = is_phone
+catch_phone = catchphone = catch_phone_number = catchphonenumber = catch_phone_nr = catchphonenr = lambda s: __rgx_catch__(PHONE_RE, s)
+pakro_phone = pakrophone = pakro_phone_number = pakrophonenumber = pakro_phone_nr = pakrophonenr = catch_phone
+has_phone = hasphone = has_phone_nr = hasphonenr = has_phone_number = hasphonenumber = lambda s: catch_phone(s) != []
+me_he_phone = mehephone = me_he_phone_nr = mehephonenr = me_he_phone_number = mehephonenumber = has_phone
+is_html = ishtml = he_html = hehtml = lambda s: __rgx_is_full_match__(HTML_RE, s)
+catch_html = catchhtml = pakro_html = pakrohtml = lambda s: __rgx_catch__(HTML_RE, s)
+has_html = hashtml = me_he_html = mehehtml = lambda s: catch_html(s) != []
+is_css = iscss = he_css = hecss = lambda s: __rgx_is_full_match__(CSS_RE, s)
+catch_css = catchcss = lambda s: __rgx_catch__(CSS_RE, s)
+has_css = hascss = lambda s: catch_css(s) != []
+is_url = isurl = he_url = heurl = lambda s: __rgx_is_full_match__(URL_RE, s)
+catch_url = catchurl = pakro_url = pakrourl = lambda s: __rgx_catch__(URL_RE, s)
+has_url = hasurl = me_he_url = mehe_url = meheurl = lambda s: catch_url(s) != []
+is_title_cased_word = is_titlecasedword = lambda s: __rgx_is_full_match__(TITLE_CASED_WORD_RE, s)
+catch_title_cased_word = catchtitle_cased_word = lambda s: __rgx_catch__(TITLE_CASED_WORD_RE, s)
+has_title_cased_word = hastitle_cased_word = lambda s: catch_title_cased_word(s) != []
+is_alpha = isalpha = is_letter = isletter = lambda s: __rgx_is_full_match__(ALPHA_RE, s)
+catch_alpha = catchalpha = catch_letter = catchletter = lambda s: __rgx_catch__(ALPHA_RE, s)
+has_alpha = hasalpha = has_letter = hasletter = lambda s: catch_alpha(s) != []
+is_num_like = isnumlike = he_num_jesa = henumjesa = he_num_jesi = henumjesi = he_parsable_num = heparsablenum = lambda s: __rgx_is_full_match__(NUM_RE, s)
+catch_num = catchnum = pakro_num = pakronum = lambda s: __rgx_catch__(NUM_RE, s)
+has_num = hasnum = me_he_num = mehenum = lambda s: catch_num(s) != []
+catch_non_num = catchnonnum = pakro_non_num = pakrononnum = lambda s: __rgx_catch__(NON_NUM_RE, s)
+has_non_num = hasnonnum = me_he_non_num = mehenonnum = lambda s: catch_non_num(s) != []
+catch_int = catchint = lambda s: __rgx_catch__(INT_RE, s)
+has_int = hasint = ne_he_int = meheint = lambda s: catch_int(s) != []
+is_word = isword = lambda s: __rgx_is_full_match__(WORD_RE, s)
+catch_word = catchword = pakro_word = pakroword = lambda s: __rgx_catch__(WORD_RE, s)
+has_word = hasword = lambda s: catch_word(s) != []
+is_non_word = isnon_word = isnonword = he_non_word = henon_word = henonword = lambda s: __rgx_is_full_match__(NON_WORD_RE, s)
+catch_non_word = catchnon_word = catchnonword = pakro_non_word = pakronon_word = pakrononword = lambda s: __rgx_catch__(NON_WORD_RE, s)
+has_non_word = hasnonword = me_he_non_word = mehenonword = lambda s: catch_non_word(s) != []
+is_hex = ishex = he_hex = hehex = lambda s: __rgx_is_full_match__(HEX_RE, s)
+catch_hex = catchhex = pakro_hex = pakrohex = lambda s: __rgx_catch__(HEX_RE, s)
+has_hex = hashex = me_he_hex = mehehex = lambda s: catch_hex(s) != []
+is_pin = ispin = he_pin = hepin = lambda s: __rgx_is_full_match__(PIN_RE, s)
+catch_pin = catchpin = pakro_pin = pakropin = lambda s: __rgx_catch__(PIN_RE, s)
+has_pin = haspin = me_he_pin = mehepin = lambda s: catch_pin(s) != []
+
+# file function aliases
+def make_file(filename: str, content: str = "") -> None:
+	if not isinstance(filename, str) or not filename.strip():
+		return
+	if not isinstance(content, str):
+		content = ""
+	with open(filename, mode="w", encoding="utf-8") as f:
+		f.write(content)
+os.make_file = os.touch = make_file
+os.make_folder = os.create_folder = os.touch_folder = lambda folder_path: os.makedirs(folder_path, exist_ok=True) if isinstance(folder_path, str) and folder_path.strip() else None
+os.copy_file = os.copy = shutil.copy_file = lambda filename, dest: shutil.copy2(filename, dest) if all([isinstance(filename, str), str(filename).strip(), isinstance(dest, str), str(dest).strip()]) else None
+os.move = lambda filename, dest: os.replace(filename, dest) if all([isinstance(filename, str), str(filename).strip(), isinstance(dest, str), str(dest).strip()]) else None
+os.delete_file = os.remove_file = lambda filename: os.remove(filename) if isinstance(filename, str) and filename.strip() else None
+os.remove_folder = os.delete_folder = shutil.remove_folder = shutil.delete_folder = lambda folder_path: shutil.rmtree(folder_path) if isinstance(folder_path, str) and folder_path.strip() else None
+def saare(*args, default=None, n: int | float = 1) -> Any:
+	if len(args) >= 1 and isinstance(args[0], (list, tuple, float)):
+		if len(args) == 2:
+			args, default = [*args]
+		elif len(args) == 3:
+			args, default, n = [*args]
+		else:
+			args = args[0]
+	if not len(args):
+		return default
+	if isinstance(n, float):
+		n = int(n)
+	if type(n) not in (type(None), int):
+		n = None
+	if isinstance(args, (tuple, set)):
+		args = list(args)
+	if all(args):
+		truthies: list = [arg for arg in args if arg]
+		if isinstance(n, int) and n == 1 and len(truthies) >= 1:
+			return truthies[-1]
+		elif isinstance(n, int) and n >= 2:
+			try:
+				return truthies[:int(n) if isinstance(n, (int, float)) and 0<=n<=len(args) else len(args)]
+			except IndexError:
+				...
+		return truthies
+	return default
+sab = both = sare = saare
+def either(*args, default=None, n: int | float = 1) -> Any:
+	if len(args) >= 1 and isinstance(args[0], (list, tuple, float)):
+		if len(args) == 2:
+			args, default = [*args]
+		elif len(args) == 3:
+			args, default, n = [*args]
+		else:
+			args = args[0]
+	if not len(args):
+		return default
+	if isinstance(n, float):
+		n = int(n)
+	if type(n) not in (type(None), int):
+		n = None
+	if isinstance(args, (tuple, set)):
+		args = list(args)
+	if any(args):
+		truthies: list = [arg for arg in args if arg]
+		if isinstance(n, int) and n == 1 and len(truthies) >= 1:
+			return truthies[0]
+		elif isinstance(n, int) and n >= 2:
+			try:
+				return truthies[:int(n) if isinstance(n, (int, float)) and 0<=n<=len(args) else len(args)]
+			except IndexError:
+				...
+		return truthies
+	return default
+yato = ya_to = kuch = some = chand = either
+def neither(*args, default=[], n: int | float | None = None) -> Any:
+	if len(args) >= 1 and isinstance(args[0], (list, tuple, float)):
+		if len(args) == 2:
+			args, default = [*args]
+		elif len(args) == 3:
+			args, default, n = [*args]
+		else:
+			args = args[0]
+	if not len(args):
+		return default
+	if isinstance(n, float):
+		n = int(n)
+	if type(n) not in (type(None), int):
+		n = None
+	if isinstance(args, (tuple, set)):
+		args = list(args)
+	if not any(args):
+		try:
+			return [arg for arg in args if not arg][:int(n) if isinstance(n, int) and 0<=n<=len(args) else len(args)]
+		except IndexError:
+			return args
+	return default
+nahi = nato = na_to = neither
+def xor(*args: tuple[Any]) -> bool:
+	return sum(map(bool, args)) == 1
+# helper placeholders
+OR = YA = NOR = AND = AUR = 0
+EXCL = EXCL_END = EXCL_STOP = EXCLUSIVE = EXCLUSIVE_STOP = EXCLUSIVE_END = EXCLUSIVE_LAST = BAGER = BAGERAKHRI = BAGER_AKHRI = 0
+INCL = INCL_END = INCL_STOP = INCLUSIVE = INCLUSIVE_STOP = INCLUSIVE_END = INCLUSIVE_LAST = SHAMIL = SHAAMIL = SHAMIL_AKHRI = SHAAMIL_AKHRI = 1
+FINCL = FINCL_END = FINCL_STOP = FORCE_INCLUSIVE = FORCE_INCLUSIVE_STOP = FORCE_INCLUSIVE_END = FORCE_INCLUSIVE_LAST = ZABARDASTI_SHAMIL = ZABARDASTI_SHAAMIL = ZABARDASTI_SHAMIL_AKHRI = ZABARDASTI_SHAAMIL_AKHRI = 2
+NO_REVERSE = NON_REVERSE = NOT_REVERSE = DO_NOT_REVERSE = DONT_REVERSE = NO_REVERT = NON_REVERT = NOT_REVERT = DO_NOT_REVERT = DONT_REVERT = NAHI_REVERSE = NAHI_REVERSED = NAHI_REVERT = NOT_REVERSE = NOT_REVERSED = NAHI_ULTA = NAHI_ULTI = NAHI_ULTE = NAHI_ULAT = 0
+ULAT = ULTA = ULTI = ULTE = REVERSE = REVERT = REVERSED = 1
+def _map(array: list | tuple | set, x: Callable, if_: Callable = lambda _: 1) -> list:
+	if type(x) not in (Callable, type):
+		return array
+	was_a_tuple: bool = False
+	was_a_set: bool = False
+	if type(array) == tuple:
+		array = list(array)
+		was_a_tuple = True
+	if type(array) == set:
+		array = list(array)
+		was_a_set = True
+	if type(array) != list:
+		return []
+	result = []
+	try:
+		result = [x(v) for v in array if callable(if_) and if_(v)]
+	except (TypeError, ValueError):
+		pass
+	if was_a_tuple:
+		result = tuple(result)
+	if was_a_set:
+		result = set(result)
+	return result
+def pehla(iterable: Iterable) -> Any:
+	if not isinstance(iterable, Iterable)\
+		or not len(iterable):
+			return
+	try:
+		return iterable[0]
+	except IndexError:
+		...
+def dusra(iterable: Iterable) -> Any:
+	if not isinstance(iterable, Iterable)\
+		or len(iterable) < 1:
+			return
+	try:
+		return iterable[1]
+	except IndexError:
+		...
+def tisra(iterable: Iterable) -> Any:
+	if not isinstance(iterable, Iterable)\
+		or len(iterable) < 2:
+			return
+	try:
+		return iterable[2]
+	except IndexError:
+		...
+teesra = tisra
+def tisra_akhri(iterable: Iterable) -> Any:
+	if not isinstance(iterable, Iterable)\
+		or len(iterable) < 2:
+			return
+	try:
+		return iterable[-3]
+	except IndexError:
+		...
+teesra_aakhri = teesra_akhri = tisra_aakhri = tisra_akhri
+def dusra_akhri(iterable: Iterable) -> Any:
+	if not isinstance(iterable, Iterable)\
+		or len(iterable) < 1:
+			return
+	try:
+		return iterable[-2]
+	except IndexError:
+		...
+dusra_aakhri = dusra_akhri
+def akhri(iterable: Iterable) -> Any:
+	if not isinstance(iterable, Iterable)\
+		or not len(iterable):
+			return
+	try:
+		return iterable[-1]
+	except IndexError:
+		...
+aakhri = akhri
+# ATTENTION: No changes to the following function (EVER):
+__old_open__ = builtins.open
+def open(file, mode="r", buffering=-1, encoding=None, *args, **kwargs):
+	if isinstance(mode, str) and "b" not in mode.lower():
+		encoding = "utf-8"
+	return __old_open__(file, mode=mode, buffering=buffering, encoding=encoding, *args, **kwargs)
+builtins.open = open
+# could help make IO a little easier to work with
+# so no more encoding="..." everywhere
+# CATCH: the mode has to stay any of the following non-binary modes:
+# ['w', 'r', 'a', 'w+', 'r+', 'a+']
+# as the original builtins.open does not allow encoding
+# with binary mode
+# ^
+# WARNING
+# NO CHANGED PLEASE!
+# THIS CAN RUIN THE ENTIRE ENVIROMENT
+def try_else(x: Any, y: Any) -> Any|None:
+	try:
+		if not x:
+			raise Exception()
+			# if x does not even exist
+			# to begin with,
+			# let's just skip to the except block right away
+		if callable(x):
+			x = x()
+			# if callable,
+			# replace x with its return value from the function call, if possible
+		if isinstance(x, str):
+			x = x.strip()
+		# let's check, AND SEE if the RETURN VALUE is FALSY
+		# if it is, head over to the except block, and return y
+		# otherwise, return x, as-is
+		if not x:
+			raise ValueError()
+		return x
+	except:
+		# upon failure,
+		# try the fallback
+		if y is not None and callable(y):
+			y = y()
+			# if callable,
+			# replace y with its return value from the function call, if possible
+		return y
+koshish_nakami = koshish_nakaami = try_else
+def collective_range(*lists: list[list]) -> list[int]:
+	lists = list(lists)
+	# converting the tuples to actual lists
+	# as Python varargs (*args)
+	# return a tuple (immutable)
+	# not a list
+	if not lists:
+		return []
+	lists = [lst for lst in lists if lst is not None and isinstance(lst, list)]
+	# filter
+	for i, lst in enumerate(lists):
+		if not isinstance(lists[i], list):
+			continue
+		lists[i] = range(len(lists[i]))
+	return collective_iter(*lists)
+# this is going to be an improved version, a replacement of (random.)randint
+# to avoid stack overflow, and cyclic references,
+# let's store the old_randint function
+from random import randint as old_randint, uniform as old_randflt
+def rand_int(x: int = 10, y: int|None = None) -> int:
+	"""
+	Ek random integer generate karta he range `x` (zaruri), aur `y` (kaabile ignore) ke darmyaan.
+	A replacement to random.randint
+	@param x				 min (switchable with @param:y)
+		:type					 <int>
+	@param y				 max (switchable with @param:x)
+		:type					 <int, optional>
+	@return					 a random int
+		:type					 <int>
+	"""
+	if isinstance(x, float) and isinstance(y, float): return rand_flt(x, y)
+	if isinstance(x, float):
+		x = int(x)
+	if not isinstance(x, int):
+		x = 0
+	if y is not None:
+		if isinstance(y, float):
+			y = int(y)
+		if not isinstance(y, int):
+			y = 10
+	if y is None:
+		x, y = 0, x
+	# with type checks out of the way
+	# there shouldn't be a problem
+	# if we do:
+	x = int(x)
+	y = int(y)
+	if x == y:
+		return x
+	if y < x:
+		x, y = y, x
+	# let's make the make the function exclusive (of y itself)
+	result: int = 0
+	if y > x:
+		result = old_randint(x, y - 1)
+	else:
+		result = old_randint(y, x - 1)
+	return result
+randint = koiint = koi_int = koinum = koi_num = koi_darmyan = randbetween = rand_between = randbw = rand_bw = randbelow = rand_below = rand_int
+def rand_flt(x: float = 0, y: float|None = None, precision: int|None = None) -> float:
+	"""
+	A replacement to random.uniform
+	@param x				 min (or max if y is None)
+		:type					 <float>
+	@param y				 max (switchable with @param:x)
+		 :type		   		 <float, optional>
+	@return					 a random int
+	 	:type			   	 <float>
+	"""
+	if not isinstance(x, (int, float)):
+		x = 0
+	if y is not None and not isinstance(y, (int, float)):
+		y = 1
+	x = float(x)
+	if y is not None:
+		y = float(y)
+	if not x and y is None:
+		x, y = 0, 1
+	if y is None:
+		x, y = 0.0, x
+	if x == y:
+		return x
+	if y < x:
+		x, y = y, x
+	# let's make the make the function exclusive (of y itself)
+	if y > 0:
+		y -= .1
+	else:
+		y += .1
+	if not precision or not isinstance(precision, int) or precision <= 0:
+		precision = 1
+	return round(old_randflt(x, y), precision)
+randfloat = rand_float = randflt = koi_flt = koiflt = rand_flt
+def choose(iterable: Iterable, n: int|None= None, koi: int|None=None) -> Any|list[Any]:
+	if koi is not None and isinstance(koi, int) and not isinstance(n, int):
+		n = abs(koi)
+	if isinstance(iterable, int) and isinstance(n, Iterable):
+		# cross compatibility: if the arguments
+		# are in reverse order
+		# order them
+		n, iterable = iterable, n
+	if not isinstance(iterable, Iterable):
+		return []
+	iterable = list(iterable)
+	if not len(iterable):
+		return [] if n != 1 else None
+	if isinstance(n, int) and n < 0:
+		n = abs(n)
+	if not n or not isinstance(n, int):
+		n = 1
+	if n > len(iterable):
+		n = len(iterable)
+	items: list[Any] = []
+	for _ in range(n):
+		items.append(iterable[rand_int(len(iterable))])
+	if isinstance(iterable, str):
+		return "".join(items)
+	if n == 1:
+		return items[0]
+	return items
+choice = choices = choose_from = random_from = rand_from = rand_item = rand_items = rand_choice = choose_any = chuno = chuno_koi = koi = choose
+def rand_range(start: int = 9, stop: int|None = None) -> list[int]:
+	"""
+	Generate a list of random integers.
+	- If stop is provided, generate a list of length abs(stop) with elements between start and stop (exclusive of stop).
+	- If stop is not provided, generate a list of length start with elements between 0 and start (exclusive of start)
+	- If nothing is provided, generate a list of 10 elements between 0 and 9 (inclusive).
+	@param start: The start of the range (inclusive) or length of list if stop is None.
+	@param stop: The end of the range (exclusive).
+	@return: A list of random integers.
+	"""
+	if not isinstance(start, int):
+		start = 9
+	if stop is None:
+		if start == 0:
+			return []
+		length = abs(start)
+		return [rand_int(0, start+1 if start > 0 else start-1) for _ in range(length)]
+	else:
+		if not isinstance(stop, int):
+			stop = 9
+		if stop < start:
+			start, stop = stop, start
+		length = abs(stop)
+		if start == stop:
+			return [start] * length  # or handle this case differently
+		return [rand_int(start, stop) for _ in range(length)]
+randrange = rand_range
+def rand_str(length: int = 16) -> str:
+	if not isinstance(length, int) or length < 8:
+		length = 8
+	if length > 64:
+		length = 64
+	chars: str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+=_"
+	return_value: str = ""
+	for i in range(length):
+		return_value += chars[randint(0, len(chars)-1)]
+	return return_value
+randstr = rand_str
+def rand_hex(length: int = 16) -> str:
+	if not isinstance(length, int) or length < 8:
+		length = 8
+	if length > 64:
+		length = 64
+	chars: str = "0123456789abcdef"
+	return_value: str = ""
+	while length := length - 1:
+		return_value += chars[randint(0, len(chars)-1)]
+	return return_value
+randhex = rand_hex
+def rand_uuid() -> str:
+	from uuid import uuid4
+	return str(uuid4())
+randuuid = rand_uuid
+haal = filhal = filhaal = bool
+line_break = linebreak = LINE_BREAK = LINEBREAK = "\n"
+tab = TAB = "\t"
+one_dim = two_dim = three_dim = four_dim = five_dim = \
+six_dim = seven_dim = eight_dim = nine_dim = ten_dim = list
+# recognizes all, just set it to `list`
+# besides, the whole point of this
+# is to achieve readability;
+# will fail with `list|tuple|set`,
+# and trust me, it has been tried
+# to allow readable list-in-list, tuple-in-tuple types like the following:
+# list[two_dim], list[three_dim], tuple[two_dim], tuple[three_dim]
+# test:
+# x: list[two_dim[int]] = [[1, 3, 5], [2, 4, 6]]
+# print(x)
+def intersection_of(x: list|dict, y: list|dict) -> list|dict:
+	if isinstance(x, tuple):
+		x = list(x)
+	if isinstance(y, tuple):
+		y = list(y)
+	if not isinstance(x, (list, dict)) and not isinstance(y, (list, dict)):
+		return []
+	if all(isinstance(each, list) for each in [x, y]):
+		return_val: list[Any] = list(set(x).intersection(y))
+		return_val.sort()
+		# list.sort returns None
+		return return_val
+	if all(isinstance(each, dict) for each in [x, y]):
+		return dict(x.items() & y.items())
+	return []
+intersection = intersection_of
+def if_main(main: Callable[[], None]) -> Callable[[], None]:
+	if callable(main) and main.__module__ == "__main__":
+		main()
+	return main
+_entry = __entry = __entry__ = ifmain = if_main
+
+
+class Date:
+	SEP: str = ", "
+	TIME_SEP: str = ":"
+	def __init__(self, date_string: Many[str, int, float, datetime.datetime, None] = None) -> None:
+		self.date_object: datetime.datetime
+		if isinstance(date_string, datetime.datetime):
+			self.date_object = date_string
+		if isinstance(date_string, (int, float)):
+			try:
+				self.date_object = datetime.datetime.fromtimestamp(date_string)
+				return
+			except (OverflowError, OSError, ValueError):
+				self.date_object = datetime.datetime.now()
+				return
+		if not isinstance(date_string, str):
+			self.date_object = datetime.datetime.now()
+			return
+		try:
+			date_string = re.sub(r"(?<=\d)\.(?=\d)", ":", date_string)
+			# replace is defined further below in the file
+			# better use original re.sub for safety
+			self.date_object = parse_date(date_string)
+		except ParserError:
+			print("Not a valid date string. Defaulting to today.")
+			self.date_object = datetime.datetime.now()
+	def __repr__(self, *args, **kwargs) -> str:
+		return self.format(*args, **kwargs)
+	__str__ = __repr__
+	# getters
+	def to_datetime(self) -> None:
+		return self.date_object
+	get_object = to_datetime
+	def format(self, short: bool = False, s: bool = False, short_year: bool = False, sep: str = SEP, time_sep: str = TIME_SEP) -> str:
+		if not isinstance(sep, str):
+			sep = self.SEP
+		if not isinstance(time_sep, str):
+			time_sep = self.TIME_SEP
+		date: datetime.datetime = self.date_object
+		format_for_short_dates: str = f"%I{time_sep}%M %p{sep}%a{sep}%b %d{sep}%{'Y' if not short_year else 'y'}"
+		format_for_longer_dates: str = f"%I{time_sep}%M{'' if not s else time_sep + '%S'} %p{sep}%A{sep}%B %d{sep}%{'Y' if not short_year else 'y'}"
+		formatted_date: str = ""
+		if short:
+			formatted_date = date.strftime(format_for_short_dates)
+		else:
+			formatted_date = date.strftime(format_for_longer_dates)
+		return formatted_date.lstrip("0").replace(" 0", " ")
+	get = get_long = long_get = get_full = full_get = read = full_read = read_full = long_read = read_long = read_long = long_read = f = _f = f_ = fmt = _str = str_ = _format = format_ = to_str = to_string = full = long = detailed = extended = full_form = long_form = detailed_form = extended_form = format
+	short = short_form = get_short = read_short = short_read = get_short = short_get = f_short = _f_short = f_short_ = fmt_short = _str_short = str_short = _format_short = format_short_ = partialmethod(format, short=True)
+	super_short = short_super = partialmethod(format, short=True, short_year=True)
+	super_super_short = short_super_super = super_duper_short = short_super_duper = lambda self: self.date_object.strftime("%I:%M %p, %a, %b %d, %y").lstrip("0")
+	short_almost_unreadable = almost_unreadable = inhuman_short = short_inhuman = inhumanly_short = short_inhumanly = insanely_short = short_insane = short_insanely = almost_unreadable_short = short_computerized = computerized_short = short_robotic = robotic_short = crazy_short = lambda self: self.date_object.strftime("%D")
+	def day(self, short: bool = False, short_year: bool = False, sep: str = SEP) -> str:
+		if isinstance(short, int)\
+			and not isinstance(short, bool)\
+			and short not in (True, False):
+				# if it's a true int, not a bool disguised as such
+				day: int = short
+				return self.set_day(day)
+		if not isinstance(sep, str):
+			sep = self.SEP
+		_today: str = self.format(
+			short=short,
+			short_year=short_year,
+			sep=sep
+		).split(sep, 1)[1]
+		return _today
+	date = d = long_timeless = timeless_long = long_wo_time = long_without_time = long_no_time = day
+	date_short = short_date = day_short = short_day = short_without_time = short_wo_time = timeless_short = short_timeless = short_no_time = partialmethod(day, short=True)
+	date_super_short = super_short_date = day_super_short = super_short_day = super_short_without_time = super_short_wo_time = timeless_super_short = super_short_timeless = super_short_no_time = partialmethod(day, short=True, short_year=True)
+	def day_only(self, short: bool = False) -> str:
+		name_of_day: str = self.day(short=short).split(",")[0].strip()
+		return name_of_day
+	day_name = day_of_week = dow = day_only
+	def day_number(self, short: bool = False) -> str:
+		day_number: str = self.day().split(",")[1].strip().split(" ")[1]
+		return int(day_number)
+	d_nr = day_nr = day_num = day_of_month = dom = day_number
+	def is_weekend(self) -> bool:
+		return self.day_only() in ("Saturday", "Sunday")
+	he_weekend = is_weekend
+	def is_weekday(self) -> bool:
+		return not self.is_weekend()
+	he_weekday = is_weekday
+	def month_only(self, short: bool = False) -> str:
+		if isinstance(short, int)\
+			and not isinstance(short, bool)\
+			and short not in (True, False):
+				# if it's a true int, not a bool disguised as such
+				month: int = short
+				return self.set_month(month)
+		name_of_month: str = self.day(
+			short=short
+		).split(", ")[1].split(" ")[0].strip()
+		return name_of_month
+	month_name = month = mn = month_only
+	def year_only(self, short: bool = False) -> str | int:
+		if isinstance(short, int)\
+			and not isinstance(short, bool)\
+			and short not in (True, False):
+				# if it's a true int, not a bool disguised as such
+				year: int = short
+				return self.set_year(year)
+		year_string: str = self.day()\
+			.split(", ")[-1].strip()
+		if short:
+			year_string = year_string[-2:]
+			# if short,
+			# return early
+			# so '2002' (str)
+			# now shortened into
+			# '02' doesn't end up
+			# 2 (now int)
+			return year_string
+		year: int = int(year_string)
+		return year
+	yr = year = year_only
+	def time(self, s: bool = False, time_sep: str = TIME_SEP) -> str:
+		if not isinstance(time_sep, str):
+			time_sep = self.TIME_SEP
+		return self.format(s=s, sep=self.SEP, time_sep=time_sep).split(self.SEP, 1)[0]
+	def time_and_day(self, s: bool = False, time_sep: str = TIME_SEP) -> str:
+		if not isinstance(time_sep, str):
+			time_sep = self.TIME_SEP
+		return self.format(s=s, sep=self.SEP, time_sep=time_sep).rsplit(self.SEP, 2)[0]
+	@classmethod
+	def now(cls) -> str:
+		return str(cls())
+	@classmethod
+	def time_now(cls, s: bool = False, time_sep: str = TIME_SEP) -> str:
+		return cls().time(s=s, time_sep=time_sep)
+	@classmethod
+	def today(cls, short: bool = False, sep: str = SEP) -> str:
+		return cls().day(short=short, sep=sep)
+	@classmethod
+	def day_today(cls, short: bool = False) -> str:
+		return cls().day_only(short=short)
+	# setters
+	def update(self, *args, **kwargs) -> Self:
+		self.date_object = self.date_object.replace(*args, **kwargs)
+		return self
+	replace = change = update
+	def set_year(self, year: int) -> Self:
+		if not isinstance(year, int) or year <= 0 or year > int(9.9e3):
+			raise TypeError("A year is supposed to be an int between 1 and 9999 (both inclusive)")
+		self.update(year=year)
+		return self
+	set_yr = set_year
+	def set_month(self, month: int) -> Self:
+		if not isinstance(month, int) or month <= 0 or month > 12:
+			raise TypeError("A month is supposed to be an int between 1 and 12 (both inclusive)")
+		self.update(month=month)
+		return self
+	set_mn = set_month
+	def set_day(self, day: int) -> Self:
+		if not isinstance(day, int) or day <= 0 or day > 31:
+			raise TypeError("A day is supposed to be an int between 1 and 31 (both inclusive)")
+		self.update(day=day)
+		return self
+	set_d = set_day
+	
+class Char(str):
+	def __new__(cls, value: Any):
+		if value is None:
+			return ""
+		character: str = ""
+		if isinstance(value, int|float):
+			character = chr(int(value))
+		else:
+			value = str(value).strip()
+			if not len(value):
+				return ""
+			character = value[0]
+		return super().__new__(cls, character)
+char = Char
+Str = lafz = jumla = lambda x: str(x).strip() # trim the string after parsing
+# no one needs additional whitespace
+nr = num = Num = Nr = Number
+INFINITY = Infinity = infinity = Inf = inf
+INT_INFINITY = INTEGER_INFINITY = INTINFINITY = INTEGERINFINITY = IntInfinity = Int_Infinity = int_infinity = intinfinity = int_inf = IntInf = intinf = sys.maxsize
+goto = open_link = link_kholo = kholo_link = webbrowser.open
+link = webbrowser
+_dir = os.getcwd()
+# crucial \/
+class AbstractMethodsRehteHeError(TypeError):
+	def __init__(self, name: str):
+		self.name = str(name)
+		super().__init__(self.name)
+class AbstractBaseClassMeta(ABCMeta):
+	def __new__(mcs, name, bases, namespace, **kwargs):
+		cls = super().__new__(mcs, name, bases, namespace, **kwargs)
+		if ABCMeta in cls.__mro__ and cls.__abstractmethods__:
+			return cls
+		abstract_methods: set = set()
+		for base in bases:
+			if isinstance(base, ABCMeta):
+				abstract_methods.update(base.__abstractmethods__)
+		missing_methods = abstract_methods - set(cls.__dict__)
+		for method_name in abstract_methods:
+			if not any(method_name in base.__dict__ for base in inspect.getmro(cls)[1:]):
+				missing_methods.add(method_name)
+		if missing_methods:
+			raise AbstractMethodsRehteHeError(
+				f"Base class '{name}' ke methods {missing_methods} ko implement karna laazmi he"
+			)
+		for method_name in abstract_methods:
+			if method_name not in cls.__dict__ :
+				continue
+			subclass_method = cls.__dict__[method_name]
+			for base in inspect.getmro(cls)[1:]:
+				if method_name not in base.__dict__:
+					continue
+				base_method = base.__dict__[method_name]
+				base_method_type = inspect.signature(base_method)
+				subclass_method_type = inspect.signature(subclass_method)
+				if base_method_type == subclass_method_type:
+					continue
+				raise TypeError(
+					f"Concrete class '{name}' ke method '{method_name}' ka kism BASE CLASS '{base.__name__}' ke sath match nahi karta"
+				)
+		return cls
+# preserve the sequence
+# it MATTERS
+def extends_from(_object: Any, target: Any) -> bool:
+	"""
+	checks if @_object extends from (or isinstance of) @super_class
+	DIFFERENT FROM regular `__builtins__.isinstance`
+	in the sense that `__builtins__.isinstance` only tells you if an object x
+	is strictly of type --- or an "instance" initiated directly from class --- y
+	@param		_object
+	::type		Any/type type (class)
+	::desc		an object or a class to test if it extends from (or at least belongs to) class @target
+	@param		target
+	::type		Any/type type (class)
+	::desc		the target class
+	@return
+	::type		bool
+	::desc		returns True if @_object extends from @target
+
+	Reads like: 'If X extends_from Y', or 'If X belongs_to Y'
+	Handles both instances (isinstance), and classes (issubclass).
+	"""
+	if isinstance(target, (list, tuple, UnionType)):
+		sub_targets: list[Any] = target.__args__ if isinstance(target, UnionType) else target
+		return any(extends_from(_object, sub_target) for sub_target in sub_targets)
+	if isinstance(_object, (list, tuple, set)) and not isinstance(_object, (str, bytes)):
+		if len(_object) == 0:
+			return False
+		return all(extends_from(item, target) for item in _object)
+	# kill int-on-bool, bool-on-int false-positive checks
+	if target is int and isinstance(_object, bool):
+		return False
+	if target is int and _object is bool:
+		return False
+	if isinstance(_object, type) or hasattr(_object, "__origin__"):
+		try:
+			# Handle Generic Aliases like list[int] which issubclass() can reject
+			_object = get_origin(_object) or _object
+			target = get_origin(target) or target
+			return issubclass(_object, target)
+		except TypeError:
+			return False
+	# if _object is an object, check if it's an instance of target
+	try:
+		return isinstance(_object, target)
+	except TypeError:
+		return False
+belongs_to = he_sub_class = sub_class_he = he_kism = extends_from
+# ^^much needed
+def kism(x: Any) -> type:
+	return get_origin(x) or type(x)
+he_kism = hekism = is_type = istype = lambda y, x: kism(x) == y
+# keep the order
+def __ltype_helper_fn__(o: object) -> str:
+	try:
+		cls = o if isinstance(o, type) else type(o)
+		name = getattr(cls, "__name__", "unknown")
+		name = re.sub(r"^(?:KL(?:_Py)?[\._]|datetime\.|__main\.)", "", name)
+		type_normalization = {
+			"str_": "str",
+			"float64": "float", "float32": "float", "float16": "float",
+			"int64": "int", "int32": "int", "int16": "int", "int8": "int",
+			"bool_": "bool"
+		}
+		return type_normalization.get(name, name)
+	except Exception:
+		return "unknown"
+def ltype(o: object, max_depth: int = 6, _current_depth: int = 0) -> str:
+	if _current_depth > max_depth:
+		return "..."
+	parsed_type = __ltype_helper_fn__(o)
+	if (not isinstance(o, Iterable) or 
+		isinstance(o, (str, bytes, bytearray, memoryview, Generator, Iterator, zip, map, builtins.filter, enumerate))):
+		return parsed_type
+	try:
+		if callable(getattr(o, "__len__", None)) and not len(o):
+			return parsed_type
+	except Exception:
+		pass
+	if isinstance(o, Mapping):
+		try:
+			items_snapshot = list(o.items())
+		except (KeyboardInterrupt, SystemExit):
+			raise
+		except Exception:
+			return parsed_type
+		filtered_items = [
+			(k, v) for k, v in items_snapshot 
+			if not (isinstance(k, str) and re.search(r"^\b(?:k[aeio]|mese)\b$", k))
+		]
+		if not filtered_items:
+			return parsed_type
+		first_k, first_v = filtered_items[0]
+		if id(o) == id(first_v):
+			return f"{parsed_type}[{__ltype_helper_fn__(first_k)}, ...]"
+		first_k_type, first_v_type = type(first_k), type(first_v)
+		supported_key_types = (str, int, float, bool)
+		if first_k_type in supported_key_types:
+			try:
+				if all(type(k) is first_k_type for k, _ in filtered_items):
+					if all(type(v) is first_v_type for _, v in filtered_items):
+						return f"{parsed_type}[{__ltype_helper_fn__(first_k)}, {ltype(first_v, max_depth, _current_depth + 1)}]"
+			except (KeyboardInterrupt, SystemExit):
+				raise
+			except Exception:
+				pass
+		return parsed_type
+	try:
+		iterator = iter(o)
+		first_item = next(iterator)
+	except (StopIteration, KeyboardInterrupt, SystemExit):
+		if isinstance(sys.exc_info()[0], (KeyboardInterrupt, SystemExit)):
+			raise
+		return parsed_type
+	except Exception:
+		return parsed_type
+	if id(o) == id(first_item):
+		return f"{parsed_type}[...]"
+	first_type = type(first_item)
+	try:
+		for item in iterator:
+			if type(item) is not first_type:
+				return parsed_type
+	except (KeyboardInterrupt, SystemExit):
+		raise
+	except Exception:
+		return parsed_type
+	return f"{parsed_type}[{ltype(first_item, max_depth, _current_depth + 1)}]"
+pakki_kism = pkism = literal_kism = lkism = literal_type = ltype
+def ltype_old(o: object) -> str:
+	try:
+		parsed_type: str = re.split(r"[\"\']", str(type(o)))[1]
+	except IndexError:
+		return "unknown"
+	if re.search(r"^(?:KL(?:_Py)?|datetime|__main__)\.(?=[A-Za-z_])", parsed_type):
+		parsed_type = parsed_type.split(".", maxsplit=1)[1]
+	if not isinstance(o, Iterable) or isinstance(o, (Generator, Iterator, zip, map, builtins.filter, enumerate)) or (callable(getattr(o, "__len__", None)) and not len(o)):
+		return parsed_type
+	if re.search(r"\b(?:list|tuple|(?:frozen)?set|(?:p(?:an)?d(?:as)?\.)?(?:Custom)?Series|(?:n(?:um)?py?\.)?ndarray|dict_(?:keys|values))\b", parsed_type):
+		if all(isinstance(item, list) for item in o):
+			parsed_type += "[list]"
+		elif all(isinstance(item, tuple) for item in o):
+			parsed_type += "[tuple]"
+		elif all(isinstance(item, set) for item in o):
+			parsed_type += "[set]"
+		elif all(isinstance(item, frozenset) for item in o):
+			parsed_type += "[frozenset]"
+		elif all(isinstance(item, dict) for item in o):
+			parsed_type += "[dict]"
+		elif all(isinstance(item, str) for item in o):
+			parsed_type += "[str]"
+		elif all(isinstance(item, int) or re.search(r"(?:n(?:um)?py?)?\.int\d*", str(type(item))) for item in o):
+			parsed_type += "[int]"
+		elif all(isinstance(item, float) or re.search(r"(?:n(?:um)?py?)?\.float\d*", str(type(item))) for item in o):
+			parsed_type += "[float]"
+		elif all(isinstance(item, bool) for item in o):
+			parsed_type += "[bool]"
+		elif all(isinstance(item, datetime.datetime) for item in o):
+			parsed_type += "[datetime]"
+		elif all(re.search(r"\b(?:KL(?:_Py)?\.)?Date\b", str(type(item))) for item in o):
+			parsed_type += "[Date]"
+		elif all(isinstance(item, type(None)) for item in o):
+			parsed_type += "[None]"
+	elif re.search(r"\b(?:dict|(?:KL(?:_Py)?\.)?obj)\b", parsed_type):
+		keys = [k for k, v in o.items() if not re.search(r"^\bk[aeio]\b$", str(k))]
+		if not len(keys):
+			return parsed_type
+		if all(isinstance(item, str) for item in keys):
+			parsed_type += "[str"
+		elif all(isinstance(item, int) for item in keys):
+			parsed_type += "[int"
+		elif all(isinstance(item, float) for item in keys):
+			parsed_type += "[float"
+		elif all(isinstance(item, bool) for item in keys):
+			parsed_type += "[bool"
+		parsed_type += ", "
+		values = [v for k, v in o.items() if not re.search(r"^\bk[aeio]\b$", str(k))]
+		if all(isinstance(item, list) for item in values):
+			parsed_type += "list"
+		elif all(isinstance(item, tuple) for item in values):
+			parsed_type += "tuple"
+		elif all(isinstance(item, set) for item in values):
+			parsed_type += "set"
+		elif all(isinstance(item, frozenset) for item in values):
+			parsed_type += "frozenset"
+		elif all(isinstance(item, dict) for item in values):
+			parsed_type += "dict"
+		elif all(isinstance(item, str) for item in values):
+			parsed_type += "str"
+		elif all(isinstance(item, int) for item in values):
+			parsed_type += "int"
+		elif all(isinstance(item, float) for item in values):
+			parsed_type += "float"
+		elif all(isinstance(item, bool) for item in values):
+			parsed_type += "bool"
+		elif all(isinstance(item, datetime.datetime) for item in values):
+			parsed_type += "datetime"
+		elif all(re.search(r"\b(?:KL(?:_Py)?\.)?Date\b", str(type(item))) for item in values):
+			parsed_type += "Date"
+		elif all(isinstance(item, type(None)) for item in values):
+			parsed_type += "None"
+		if re.search(r"\[\w+, *$", parsed_type.strip()):
+			parsed_type = parsed_type.split("[")[0]
+		else:
+			parsed_type += "]"
+		if re.search(r", *]$", parsed_type.strip()):
+			parsed_type = re.sub(r", *]$", "", parsed_type)
+	return parsed_type
+# preserve the sequence
+# it MATTERS
+def hissa(item: Any|type, container: Any|type|Iterable, _seen: Optional[set[int]] = None) -> bool:
+	try:
+		if _seen is None:
+			_seen = set()
+		container_id = id(container)
+		if container_id in _seen:
+			return False  # Already checked this exact container
+		_seen.add(container_id)
+		if isinstance(item, str) and isinstance(container, str):
+			return match_i(container, item)
+			# NOTE: keep the order like this
+			# has to be called in reverse
+			# the parameters of this function are
+			# in reverse for readability
+		item_is_type_type: bool = isinstance(item, type) or hasattr(item, "__origin__")
+		container_is_type_type: bool = isinstance(container, type) or hasattr(container, "__origin__")
+		if item_is_type_type and container_is_type_type:
+			return extends_from(container, item)
+		if isinstance(container, (list, tuple, set, collections.abc.Iterable)):
+			if item_is_type_type:
+				return any(extends_from(parent, item) for parent in container if isinstance(parent, type) or hasattr(parent, "__origin__"))
+			try:
+				# direct membership check first (fast)
+				if item in container:
+					return True
+			except TypeError:
+				pass
+			for element in container:
+				if isinstance(element, (list, tuple, set, dict)):
+					if hissa(item, element, _seen=_seen):
+						return True
+				elif item == element:
+					return True
+		return item == container
+	except (TypeError, ValueError, AttributeError):
+		return False
+# preserve the sequence
+# it MATTERS
+def isinstance_each(collection: Any, target: Any) -> bool:
+	"""
+	WARNING:
+	this is DIFFERENT from `__builtins__.isinstance`
+	HERE'S HOW: it shortens multiple isinstance checks into one
+	WHERE y is the type to compare each item in x with.
+	So, unlike the original...
+	this one won't return True for
+	`isinstance([1, 2], list)`
+	unlike the original!
+	INSTEAD:
+	this one checks if every item from the @collection on the left
+	matches the type of the @target
+	Here is what it WILL return True for:
+		isinstance_each([1, 2], int) // output: True
+		isinstance_each([1.2, 2.1], float) // output: True
+		isinstance_each([1.2, 2], float) // output: False, since 2 is an int
+
+	:: Checks if every item in @collection belongs_to @target.
+	:: Returns False if the collection is empty.
+	:: Also works with classes: isinstance_each([ValueError, TypeError], Exception) returns True
+	"""
+	if not isinstance(collection, (list, tuple, set)):
+		return False
+	return extends_from(collection, target)
+each_isinstance = each_is_instance = is_instance_each = isinstance_each
+from bisect import bisect_left
+def near_get(
+	d: dict,
+	k: Union[str, int, float],
+	default=None
+):
+	if not isinstance(d, dict)\
+		or not d\
+		or type(k) not in (
+			str,
+			int,
+			float
+		):
+			return default
+	if k in d:
+		return d[
+			k
+		]
+	if isinstance(k, str):
+		k_lower: str = k.lower()
+		str_keys = [
+			str(key)\
+				for key in d\
+					if isinstance(key, str)
+		]
+		if not str_keys:
+			return default
+		for key in str_keys:
+			if key\
+				.lower() == k_lower:
+					return d[
+						key
+					]
+		for key in sorted(
+			str_keys
+		):
+				if key\
+					.lower()\
+					.startswith(
+						k_lower
+					):
+						return d[
+							key
+						]
+		for key in sorted(
+			str_keys,
+			key=len,
+			reverse=True
+		):
+			if k_lower\
+				.startswith(
+					key\
+						.lower()
+			):
+					return d[
+						key
+					]
+	else:
+		k_int: int = int(
+			k
+		)
+		if k_int in d:
+			return d[
+				k_int
+			]
+		num_keys_map = {}
+		for key in d:
+			if isinstance(
+				key,
+				(
+					int,
+					float
+				)
+			):
+					num_keys_map[
+						int(key)
+					] = key
+		if not num_keys_map:
+			return default
+		sorted_ints = sorted(
+			num_keys_map\
+				.keys()
+		)
+		if k_int < sorted_ints[
+			0
+		]:
+				return d[
+					num_keys_map[
+						sorted_ints[
+							0
+						]
+					]
+				]
+		if k_int > sorted_ints[
+			-1
+		]:
+				return d[
+					num_keys_map[
+						sorted_ints[
+							-1
+						]
+					]
+				]
+		pos = bisect_left(
+			sorted_ints,
+			k_int
+		)
+		candidates = [
+			sorted_ints[
+				pos - 1
+			],
+			sorted_ints[
+				pos
+			]
+		]\
+				if pos < len(
+					sorted_ints
+				)\
+				else [
+					sorted_ints[
+						pos - 1
+					]
+				]
+		closest_int = min(
+			candidates,
+			key=lambda x:\
+				abs(
+					x - k_int
+				)
+		)
+		if abs(
+			closest_int - k_int
+		) <= 3:
+				return d[
+					num_keys_map[
+						closest_int
+					]
+				]
+	return default
+def safe_get(
+	data: Any, 
+	path: str | list | tuple, 
+	default: Any = None, 
+	target_type: Any = object,
+	ignore_case: bool = True,
+	use_regex: bool = False,
+	auto_flatten: bool = False,
+	on_match: Optional[Callable[[Any], Any]] = None,
+	deep_search: bool = True,
+	max_depth: int = 20,
+	_seen: Optional[set[int]] = None
+) -> Any:
+	if isinstance(data, dict):
+		# add a fallback
+		# if dictionary
+		# get the closest key
+		# if nothing works out
+		default = close_get(d=data, k=path, default=default)
+	if _seen is None:
+		_seen = set()
+	if max_depth < 0:
+		return default
+	if isinstance(path, str) and '.' in path:
+		parts: list[str] = path.split('.')
+		if deep_search:
+			path = parts[-1]
+		else:
+			path = parts[0]
+	if isinstance(path, (list, tuple)) and not deep_search:
+		if len(path) > 0 and any(isinstance(p, (str, list, tuple)) for p in path):
+			is_multi = any(
+				'.' in p\
+					if isinstance(p, str)\
+					else True\
+						for p in path
+			)
+			if is_multi:
+				return [
+					safe_get(
+						data,
+						p,
+						default,
+						target_type,
+						ignore_case,
+						use_regex,
+						auto_flatten,
+						on_match,
+						deep_search,
+						max_depth,
+						_seen.copy()
+					) for p in path
+				]
+	if isinstance(
+		data,
+		(
+			list,
+			tuple,
+			dict,
+			set
+		)
+	):
+			if id(data) in _seen:
+				return default
+			_seen.add(
+				id(data)
+			)
+	def _run_finalize(val):
+		if auto_flatten:
+			def _gen_flatten(items):
+				if isinstance(
+					items,
+					(
+						list,
+						tuple,
+						set
+					)
+				):
+						for item in items:
+							yield from _gen_flatten(
+								item
+							)
+				else:
+					yield items
+			val = list(
+				_gen_flatten(
+					val
+				)
+			)
+		if on_match\
+			and val is not default:
+				try:
+					val = [
+						on_match(i)\
+							for i in val
+					]\
+						if auto_flatten\
+						else on_match(val)
+				except:
+					return default
+		if val is not None\
+			and target_type is not object:
+				if auto_flatten:
+					if "isinstance_each" in globals()\
+						and not isinstance_each(
+							val,
+							target_type
+						):
+							return default
+		else:
+			if "extends_from" in globals()\
+				and not extends_from(
+					val,
+					target_type
+				):
+					return default
+		return val
+	def _find_key(d, k):
+		if use_regex:
+			try:
+				p = re.compile(
+					str(k),
+					re.IGNORECASE\
+						if ignore_case\
+						else 0
+				)
+				for existing_key in d:
+					if p.search(
+						str(
+							existing_key
+						)
+					):
+							return d[
+								existing_key
+							]
+			except re.error:
+				pass
+		elif ignore_case:
+			k_map = {
+				str(key).lower(): key\
+					for key in d.keys()
+			}
+			look = k_map.get(
+				str(k)\
+					.lower()
+			)
+			if look is not None:
+				return d[
+					look
+				]
+		return d\
+			.get(k)\
+				if isinstance(d, dict)\
+				else None
+	if deep_search:
+		target_key = path\
+				if isinstance(path, (list, tuple))\
+				else str(path)
+		if isinstance(data, dict):
+			found = _find_key(
+				data,
+				target_key
+			)
+			if found is not None:
+				return _run_finalize(
+					found
+				)
+			for v in data.values():
+				res = safe_get(
+					v,
+					path,
+					default,
+					target_type,
+					ignore_case,
+					use_regex,
+					auto_flatten,
+					on_match,
+					True,
+					max_depth - 1,
+					_seen
+				)
+				if res is not default:
+					return res
+		elif isinstance(data, (list, tuple)):
+			for item in data:
+				res = safe_get(
+					item,
+					path,
+					default,
+					target_type,
+					ignore_case,
+					use_regex,
+					auto_flatten,
+					on_match,
+					True,
+					max_depth - 1,
+					_seen
+				)
+				if res is not default:
+					return res
+		return default
+	segments = path.split('.')\
+			if isinstance(path, str)\
+			else path
+	current = data
+	for key in segments:
+		if current is None:
+			return default
+		try:
+			if isinstance(current, dict):
+				current = _find_key(
+					current,
+					key
+				)
+			elif isinstance(current, (list, tuple)):
+				current = current[
+					int(key)
+				]
+			elif hasattr(current, str(key)):
+				current = getattr(
+					current,
+					str(key),
+					default
+				)
+			else:
+				return default
+		except:
+			return default
+		if current is default\
+			or current is None:
+				return default
+	return _run_finalize(
+		current
+	)
+deepget = deep_get = safeget = safe_get
+autoclass = auto_class = dataclass
+def auto_id(
+	_cls=None,
+	start: int = 1000,
+	field: str = "__id__"
+) -> type:
+	if not isinstance(start, int):
+		start = 1000
+	if not isinstance(field, str):
+		field = "__id__"
+	def decorator(cls):
+		counters: dict[str, int] = {
+			field: count(start),
+			"__shanakht__": count(start)
+		}
+		original_init = cls.__init__
+		@wraps(original_init)
+		def new_init(self, *args, **kwargs):
+			setattr(
+				self,
+				field,
+				next(
+					counters[
+						field
+					]
+				)
+			)
+			setattr(
+				self,
+				"__shanakht__",
+				next(
+					counters[
+						"__shanakht__"
+					]
+				)
+			)
+			original_init(
+				self,
+				*args,
+				**kwargs
+			)
+		cls.__init__ = new_init
+		return cls
+	if _cls is None:
+		return decorator
+	return decorator(_cls)
+serialize = autoid = auto_id
+______auto_variable_count_helper______: dict = {}
+class AutoField:
+	def __init__(self, start: int = 0, key:str|None=None, increment: bool=True):
+		self.start = 0 if not isinstance(start, int) else start
+		self.key = object() if key is None else key
+		self.increment = increment
+		______auto_variable_count_helper______[self.key] = start
+	def __get__(self, instance, owner):
+		if instance is None:
+			return self
+		key = (id(instance), self.key)
+		if key not in ______auto_variable_count_helper______: ______auto_variable_count_helper______[key] = self.start
+		value = ______auto_variable_count_helper______[key]
+		if self.increment:
+			______auto_variable_count_helper______[key] += 1
+		else: ______auto_variable_count_helper______[key] -= 1
+		return value
+	def __call__(self):
+		value = ______auto_variable_count_helper______[self.key]
+		if self.increment:
+			______auto_variable_count_helper______[self.key] += 1
+		else: ______auto_variable_count_helper______[self.key] -= 1
+		return value
+def auto_inc(start: int = 0):
+	if not isinstance(start, int):
+		start = 0
+	return AutoField(start=start)
+def auto_dec(start: int = 0):
+	if not isinstance(start, int):
+		start = 0
+	return AutoField(start, increment=False)
+typename = TypeT = typeT = TypeVar("T")
+def is_active_process(process: str) -> bool:
+	if os.name != "nt" or not isinstance(process, str):
+		return False
+	process = process.strip("\"'").strip()
+	if not process:
+		return False
+	if not process.lower().endswith(".exe"):
+		process_pattern = f"{process}.exe"
+	else:
+		process_pattern = process
+	try:
+		cmd = ["tasklist", "/FI", f"IMAGENAME eq {process_pattern}", "/NH"]
+		result = subprocess.run(
+			cmd,
+			stdout=subprocess.PIPE,
+			stderr=subprocess.DEVNULL,
+			text=True,
+			check=False
+		)
+		if process_pattern.lower() not in result.stdout.lower():
+			return False
+		return True
+	except Exception:
+		return False
+is_running_process = is_running_app = is_active_process
+def run_process(
+	command: str | list[str] | tuple[str, ...],
+	new_window: bool = False,
+	max: Optional[int] = None,
+	timeout: Optional[int | float] = None,
+	**kwargs
+) -> bool:
+	if isinstance(max, int) and max == 1:
+		if is_running_process(command):
+			return
+	if not command:
+		return False
+	if not new_window\
+		or not isinstance(
+			new_window,
+			bool
+		):
+			new_window = any(
+				bool(
+					kwargs.pop(k, False)
+				)\
+					for k in [
+						"dont_block",
+						"non_blocking",
+						"detach"
+					]
+			)
+	is_shell = any(
+		bool(
+			kwargs.pop(k, False)
+		)\
+			for k in [
+				"cmd",
+				"internal",
+				"shell"
+			]
+	)
+	capture_output = bool(
+		kwargs.pop(
+			"capture_output",
+			False
+		)
+	)
+	print_output = bool(
+		kwargs.pop(
+			"print_output",
+			False
+		)
+	)
+	if print_output:
+		capture_output = True
+	as_text = bool(
+		kwargs.get(
+			"text",
+			kwargs.get(
+				"universal_newlines",
+				False
+			)
+		)
+	) or print_output
+	kwargs["text"] = as_text
+	kwargs["shell"] = is_shell
+	if isinstance(command, tuple):
+		command = list(command)
+	if isinstance(command, str):
+		if not is_shell\
+			and os.name != 'nt':
+				command = shlex.split(
+					command,
+					posix=True
+				)
+	elif isinstance(command, list)\
+		and is_shell:
+			if os.name == 'nt':
+				command = subprocess\
+					.list2cmdline(
+						command
+					)
+			else:
+				command = shlex.join(
+					command
+				)
+	if os.name == 'nt':
+		creationflags = kwargs.get("creationflags", 0)\
+			| subprocess\
+				.CREATE_NEW_PROCESS_GROUP
+		kwargs["creationflags"] = creationflags
+	empty_buf = "" if as_text else b""
+	stdout, stderr = empty_buf, empty_buf
+	return_code = 1
+	try:
+		if new_window:
+			stdout_pipe = subprocess.PIPE\
+				if capture_output else None
+			stderr_pipe = subprocess.PIPE\
+				if capture_output else None
+			proc = subprocess.Popen(
+				command,
+				stdout=stdout_pipe,
+				stderr=stderr_pipe,
+				**kwargs
+			)
+			if not capture_output:
+				timer.sleep(0.05)
+				return proc.poll() is None or\
+					proc.poll() == 0
+			try:
+				stdout, stderr = proc.communicate(
+					timeout=timeout
+				)
+				return_code = proc.returncode
+			except subprocess.TimeoutExpired:
+				if os.name == "nt":
+					try:
+						proc.send_signal(
+							signal\
+								.CTRL_BREAK_EVENT
+						)
+					except Exception:
+						proc.kill()
+				else:
+					proc.kill()
+				stdout, stderr = proc\
+					.communicate()
+				return_code = 1
+		else:
+			try:
+				proc_res = subprocess.run(
+					command,
+					capture_output=capture_output,
+					timeout=timeout,
+					**kwargs
+				)
+				return_code = proc_res.returncode
+				if capture_output:
+					stdout, stderr = proc_res.stdout, proc_res.stderr
+				else:
+					return return_code == 0
+			except subprocess.TimeoutExpired as e:
+				stdout = e.stdout\
+					if e.stdout is not None\
+					else empty_buf
+				stderr = e.stderr\
+					if e.stderr is not None\
+					else empty_buf
+				return_code = 1
+		if print_output:
+			out = stdout if stdout else stderr
+			if out:
+				msg = out.decode(errors="replace")\
+					if isinstance(out, (bytes, bytearray))\
+					else str(out)
+				if msg.strip():
+					print(msg.strip())
+		return return_code == 0
+	except Exception as e:
+		print(f"Process execution failed, reason: {e}")
+		return False
+run_command = execute_command = execute_process = run_process
+def kill_process(process_name: str) -> bool:
+	process_name: str = str(process_name).strip()
+	killed: bool = False
+	if not process_name:
+		return False
+	opsys: str = platform.system().lower()
+	try:
+		if opsys == "windows" or os.name == "nt":
+			if not process_name.lower().endswith(".exe"):
+				process_name += ".exe"
+				# need this
+			run_process(f"taskkill /f /im {process_name}")
+		else:
+			run_process(f"pkill -f {process_name}")
+		killed = True
+	except:
+		killed = False
+	return killed
+kill_application = kill_app = kill_process
+def Int(x: str|int|float, base: int = 10) -> int:
+	try:
+		if x is None or\
+			not isinstance(
+				x,
+				(str, int, float, bool)
+			):
+				return 0
+		if isinstance(x, bool):
+			return 1\
+				if x else 0
+		if not base or\
+			not isinstance(base, int)\
+			or base <= 0\
+			or base >= Infinity:
+				base = 10
+		x = str(x).strip()
+		x = replace(
+			x,
+			r"[^\-\.\d]",
+			""
+		)
+		# NOTE: keep the dot(.), it's needed for now. keep. the. dot.
+		# ^ allow the dot(.) to pass through, for now, so that 23.5 does NOT become 253
+		if "." in x\
+			and len(x) >= 2:
+				# and later, remove it gracefully
+				x = x.split(".")[0]
+		return int(x, base)
+	except (ValueError, TypeError):
+		return 0
+def Flt(x: str|int|float) -> float:
+	try:
+		if x is None or\
+			not isinstance(
+				x,
+				(str, int, float, bool)
+			):
+				return 0.0
+		if isinstance(x, bool):
+			return 1.0\
+				if x else 0.0
+		if isinstance(x, str):
+			x = replace(
+				x.strip(),
+				r"[^e\+\-\.\d]",
+				""
+			)
+		return float(x)
+	except (ValueError, TypeError):
+		return 0.0
+def is_pos(n: int|float) -> bool:
+	"""agar number ek positive number he to kehta he `Han`,
+	warna `Nahi`"""
+	if not n\
+		or not isinstance(n, (int, float)):
+			return False
+	return n > 0
+he_positive = he_pos = is_pos
+def is_neg(n: int|float) -> bool:
+	"""agar number ek negative number he to kehta he `Han`,
+	warna `Nahi`"""
+	if not n\
+		or not isinstance(n, (int, float)):
+			return False
+	return n < 0
+he_negative = he_neg = is_neg
+def is_even(n: int) -> bool:
+	"""agar number ek even number he to kehta he `Han`,
+	warna `Nahi`"""
+	if not isinstance(n, int):
+		return False
+	# allow zero to pass through
+	# might not seem like it,
+	# but it does have the quality OF being even,
+	# or odd, it even... though
+	return n % 2 == 0
+he_even = is_even
+def is_odd(n: int) -> bool:
+	"""agar number ek odd number he to kehta he `Han`,
+	warna `Nahi`"""
+	if not isinstance(n, int):
+		return False
+	# allow zero to pass through
+	# might not seem like it,
+	# but it does have the quality OF being even,
+	# or odd, it's not odd though
+	return n % 2 != 0
+he_odd = is_odd
+char_code = ascii_code = int_code = lambda c: ord(c[0]) if isinstance(c, str) else 0
+Function = Fc = Pukarne_Layak = Callable
+def delay(n: int, fn: Callable) -> None:
+	"""
+	kism<nr> `n` seconds baad kisi operation ko perform karne ke lie
+	@param
+			  n							   kism<int | float>
+			  the delay in seconds
+	@param fn
+			  fn							  kism<Pukarne_Layak / Function>
+			  the function to be executed after the delay
+	@return_type
+			  kism<KoiNa|NoneType>
+			  operation perform karke koi value return nahi karta (koi_na|None)
+	"""
+	if not isinstance(n, (int, float)) or n <= 0:
+		n = 1
+	MAX_DELAY: int = int(1e5)
+	if n > MAX_DELAY:
+		n = MAX_DELAY
+	# good practice
+	if not isinstance(fn, Callable):
+		return
+	timed_fn: Timer = Timer(n, fn)
+	timed_fn.start()
+sec, mint = 1, 60
+# helpers contants
+# so we can do delay(5*min, lambda: doSomeThing())
+# again, helper constants
+after = baad = delay
+def blocking_sleep(s: Number = 5) -> None:
+	if not isinstance(s, Number):
+		return
+	from time import sleep
+	sleep(s)
+wait = rukawat = rukaawat = blocking_sleep
+def get_platform() -> str:
+	from platform import system
+	return system()
+get_os = get_platform
+user_os = user_platform = get_platform()
+def try_luck(*args, default=None) -> Optional[Any]:
+	import random
+	high = True
+	low = False
+	if args:
+		if len(args) >= 1:
+			if isinstance(args[0], (list, tuple, set)):
+				args = list(args[0])
+			if len(args) >= 2:
+				default = args[1]
+			high = args[0]
+			low = default
+	return random.choice([high, low])
+Re = re.Re = re.compile
+re.repl = re.sub
+def th(n: Number) -> str:
+	if not isinstance(n, Number):
+		return "0th"
+	n = abs(int(n))
+	if 10 <= n % 100 <= 20:
+		suffix = "th"
+	else:
+		suffix = {1: "st", 2: "nd", 3: "rd"}.get(n % 10, "th")
+	return str(n) + suffix
+def fus(amount: Number) -> str:
+	if amount is None or not isinstance(amount, Number):
+		return ""
+	amount = round(amount, 1)
+	parts = str(amount).split('.')
+	integer_part = '{:,}'.format(int(parts[0]))
+	decimal_part = f".{parts[1]}" if len(parts) > 1 else ''
+	result: str = f"{integer_part}{decimal_part}"
+	result = re.sub(r"\.0+$", "", result)
+	return result
+def fpk(amount: Number) -> str:
+	if amount is None or not isinstance(amount, Number):
+		return ""
+	amount = round(amount, 1)
+	parts = str(amount).split('.')
+	# Indian formatting for integer part
+	integer_part = parts[0]
+	if len(integer_part) > 3:
+		last_three = integer_part[-3:]
+		rest = integer_part[:-3]
+		rest = ','.join(reversed([rest[max(0, i-2):i] for i in range(len(rest), 0, -2)]))
+		integer_part = f"{rest},{last_three}" if rest else last_three
+	decimal_part = f".{parts[1]}" if len(parts) > 1 else ''
+	format: str = f"{integer_part}{decimal_part}"
+	# fixing a bug...
+	result: str = format.replace("-,", "-")
+	result = re.sub(r"\.0+$", "", result)
+	return result
+athwa: float = 0.125
+chotha: float = 0.25
+adha: float = 0.5
+dedh: float = 1.5
+dhai: float = 2.5
+tin: int = 3
+chaar: int = 4
+ath: int = 8
+aath = ath
+def number_list_validator(args: tuple[Any]):
+	args = list(args)
+	if len(args) == 1 and isinstance(args[0], (list, tuple)):
+		args = list(args[0])
+	if not all(isinstance(arg, (int, float)) for arg in args):
+		return []
+	return args
+def mean(*args: tuple[int | float]) -> float:
+	args = number_list_validator(args)
+	if not args:
+		return 0.0
+	return float(sum(args) / len(args))
+avg = average = math.avg = math.average = math.mean = mean
+def median(*args: tuple[int | float]) -> float:
+	args = number_list_validator(args)
+	if not args:
+		return 0.0
+	args = sorted(args)
+	mid_of_length: int = len(args) // 2
+	if len(args) % 2 != 0:
+		return float(args[mid_of_length])
+	first_middle: int | float = args[mid_of_length - 1]
+	second_middle: int | float = args[mid_of_length]
+	return float((first_middle + second_middle) / 2)
+math.find_middle = math.middle_number = math.find_median = math.median = median
+def arithmode(*args: tuple[int | float]) -> float:
+	args = number_list_validator(args)
+	if not args:
+		return 0.0
+	most_frequent_number: int | float = Counter(args).most_common(1)[0][0]
+	return float(most_frequent_number)
+math.frequent = math.most_frequent = math.mode = frequent = most_frequent = arith_mode = arithmode
+def arithrange(*args: tuple[int | float]) -> float:
+	args = number_list_validator(args)
+	if not args:
+		return 0.0
+	return float(max(args) - min(args))
+math.arith_range = math.arithrange = arith_range = arithrange
+def IntInput(*args, **kwargs):
+	try:
+		return Int(input(*args, **kwargs))
+	except Exception:
+		return 0
+def FltInput(*args, **kwargs):
+	try:
+		return Flt(input(*args, **kwargs))
+	except Exception:
+		return 0
+intInput, fltInput = IntInput, FltInput
+def flattened(lst: list[Any]) -> list[Any]:
+	if lst is None or not isinstance(lst, list):
+		return []
+	out: list[Any] = []
+	for item in lst:
+		if isinstance(item, Iterable) and not isinstance(item, (str, bytes)):
+			out.extend(flattened(item))
+		else:
+			out.append(item)
+	return out
+flat = flatten = flattened
+def clone(item: list|tuple|dict) -> list|tuple|dict:
+	if item is None:
+		return None
+	return deepcopy(item)
+	"""
+	__KL_Py.deepcopy__
+	
+	@param	   item
+	  @@type	 (list, tuple, dict)
+						:: object to clone
+	@return		
+	   @@type	(list, tuple, dict)
+						:: a cloned object
+						   depending on
+						   the type passed
+						   in as the argument
+	"""
+def lambai(x: Iterable) -> int:
+	if not isinstance(x, Iterable):
+		return 0
+	return len(x)
+def barabar(x, y) -> haal:
+	if isinstance(x, str) and isinstance(y, str):
+		return x.lower() == y.lower()
+	return x == y
+def he(x: Any, y: Any = None) -> bool:
+	"""
+	stricter he
+	ONLY EXISTS TO BOOST READABILITY
+	IN HINDGUI-ONLY (non-Klang) PROJECTS
+	different from `barabar`
+	which uses case-insensitivity for strings
+	"""
+	if x is not None and y is None:
+		return bool(x)
+	return x == y
+mojud = bool
+def yato(x, y) -> bool:
+	return x or y
+def collect(x, *rest) -> list[list[Any], list[Any]]:
+	if not x or not rest or len(rest) == 0 or not is_iterable(x) or not all(isinstance(item, Iterable) for item in [x, *rest]):
+		return [[], []]
+	args: list = [x, *rest]
+	return list(zip(args))
+# wraps the old enumerate function
+# to avoid stack overflow
+# we'll need this
+ikhatte = collect
+old_enumerate = builtins.enumerate
+def numbered(x: str|list|tuple|dict, *args, **kwargs) -> list[list[Any], list[int]]:
+	if not x or not isinstance(x, (str, list, tuple, dict)):
+		return []
+	kwargs["start"] = kwargs.pop("shuru", kwargs.pop("start", 0))
+	enumeration_object: old_enumerate = old_enumerate(x, *args, **kwargs)
+	if not enumeration_object:
+		return []
+	lst: list = list(enumeration_object)
+	if not lst:
+		return []
+	return [(v, i) for i, v in lst]
+	# WARNING: the `old_enumerate` part
+	# is supposed to be AS/IS
+	# this function overrides
+	# the old enumerate function
+	# for Klang
+	# and replaces it with numbered
+	# also, the swapping is a mandatory step
+	# allowing the following syntax:
+	#	for item, i in numbered(arr):
+	#		print("{i}. {item}")
+enumer = numbered
+__old_list__ = builtins.list
+class Arr(__old_list__):
+	current_type = Any
+	length_is_final: bool = False
+	def __init__(self, *objs, fixed: bool = False):
+		objs = flattened(__old_list__(objs))
+		if len(objs) > 0 and objs[0] is not None and objs[0] is not Iterable:
+			self.current_type = type(objs[0])
+		super().__init__()
+		self.push(objs)
+		filtered_lst: list = []
+		if self.current_type is not Any:
+			for item in self:
+				if isinstance(item, Number) and not isinstance(item, bool) and self.current_type == str:
+					item = Str(item)
+				if re.search(r"\d|\b(?:True|False)\b", str(item)) and isinstance(item, (str, int, float, bool)) and self.current_type in [int, float]:
+					if self.current_type == int:
+						item = Int(item)
+					else:
+						item = Flt(item)
+					# ^ WARNING (change not needed): refers to `Int` instead of
+					# builtin `int`
+					# FOR A REASON:
+					# forced int-ification (if possible)
+					# applying the type filter on items
+				if type(item) != self.current_type:
+					continue
+				filtered_lst.append(item)
+		self.clear()
+		self[:] = filtered_lst
+		if fixed:
+			self.length_is_final = True
+	def filter_out(self, fn):
+		if not callable(fn):
+			return self
+		self[:] = [x for x in self if not fn(x)]
+		return self
+	def keep_if(self, fn):
+		if not callable(fn):
+			return self
+		self[:] = [x for x in self if fn(x)]
+		return self
+	def map(self, fn):
+		if not callable(fn):
+			return self
+		self[:] = [fn(x) for x in self]
+		return self
+	def unique(self):
+		self[:] = __old_list__(dict.fromkeys(self))
+		return self
+	def has(self, x):
+		return x in self
+	def includes(self, x):
+		return self.has(x)
+	def i(self, i, default=None):
+		if not isinstance(i, int):
+			return self
+		if i < 0:
+			i = len(self) + i
+		if 0 <= i < len(self):
+			return self[i]
+		return default
+	def last(self):
+		if self:
+			return self[-1]
+		return self
+	def last_i(self, n: int = 1):
+		if not isinstance(n, int):
+			return self
+		if n > 0 and n <= len(self):
+			return self[-n]
+		return self
+	def nth(self, n):
+		return self.i(n)
+	def nth_last(self, n):
+		return self.last_i(n)
+	def first(self):
+		if self:
+			return self[0]
+		return None
+	def second(self):
+		return self.i(1)
+	def sec_last(self):
+		return self.last_i(2)
+	def update(self, i, x):
+		if not isinstance(i, int):
+			return self
+		if i < 0:
+			i = len(self) + i
+		if 0 <= i < len(self):
+			self[i] = x
+		return self
+	def replace(self, i, x):
+		return self.update(i, x)
+	def shuffle(self):
+		if len(self) > 1:
+			random.shuffle(self)
+		return self
+	def sort(self, key=None, reverse=False):
+		if len(self) > 1:
+			super().sort(key=key, reverse=reverse)
+		return self
+	def reverse(self):
+		if len(self) > 1:
+			super().reverse()
+		return self
+	def key_array(self):
+		return __old_list__(range(len(self)))
+	def keys(self):
+		return self.key_array()
+	def values(self):
+		return __old_list__(self)
+	def entries(self):
+		return [self.keys(), self.values()]
+	def slice(self, start: int = None, end: int = None):
+		if not isinstance(start, int) or not isinstance(end, int) or start >= len(self) or end > len(self) or start == end:
+			return self[:]
+		return Arr(self[start:end])
+	def slice_keep(self, x):
+		if not isinstance(x, int) or x <= len(self) or x > len(self):
+			return self.copy()
+		return self.slice(0, x)
+	def slice_right(self, x):
+		if not isinstance(x, int):
+			return self.copy()
+		return self.slice(len(self) - x)
+	def slice_end(self, x):
+		if not isinstance(x, int):
+			return self.copy()
+		return self.slice(0, len(self) - x)
+	def random(self):
+		if self:
+			return random.choice(self)
+		return None
+	def empty(self) -> Self:
+		self.clear()
+		return self
+	def eq(self, other):
+		if not isinstance(other, __old_list__):
+			return False
+		return self == other
+	def compare(self, other):
+		if not isinstance(other, __old_list__):
+			return False
+		intersection = Arr(set(self) & set(other))
+		return len(intersection) > len(self) / 2
+	def union(self, *arrays):
+		return self.combine(*arrays)
+	def cat(self, *arrays):
+		return self.combine(*arrays)
+	def concat(self, *arrays):
+		return self.combine(*arrays)
+	def join(self, *arrays):
+		return self.combine(*arrays)
+	def join_str(self, s: str = ""):
+		return str(s).join(map(str, self))
+	def intersection(self, *arrays):
+		for arr in arrays:
+			if isinstance(arr, __old_list__):
+				self[:] = [x for x in self if x in arr]
+			elif isinstance(arr, Arr):
+				self[:] = [x for x in self if x in arr]
+		return self
+	def negative_intersection(self, *arrays):
+		for arr in arrays:
+			if isinstance(arr, __old_list__):
+				self[:] = [x for x in self if x not in arr]
+			elif isinstance(arr, Arr):
+				self[:] = [x for x in self if x not in arr]
+		return self
+	def map_val(self, old_val, new_val) -> Self:
+		for i, x in enumerate(self):
+			if x == old_val:
+				self[i] = new_val
+		return self
+	def sum(self) -> Number:
+		if not len(self):
+			return 0.0
+		nums: __old_list__[Number] = [num for num in self if num is not None and isinstance(num, Number)]
+		# this is a necessary check
+		if not len(nums):
+			return 0.0
+		return sum(nums)
+	def difference(self) -> Number:
+		if not len(self):
+			return 0.0
+		nums: __old_list__[Number] = [num for num in self if num is not None and isinstance(num, Number)]
+		# this is a necessary check
+		if not len(nums):
+			return 0.0
+		diff: Number = nums[0]
+		for i, item in old_enumerate(nums):
+			if i == 0:
+				continue
+			# since we've already taken care of the first item
+			# we don't that
+			if item > 1e9:
+				item = 1e9
+			if item < 1e-9:
+				item = 1e-9
+			diff -= item
+		return diff
+	diff = difference
+	def product(self) -> Number:
+		if not len(self):
+			return 0.0
+		nums: __old_list__[Number] = [num for num in self if num is not None and isinstance(num, Number)]
+		# this is a necessary check
+		if not len(nums):
+			return 0.0
+		prd: Number = nums[0]
+		for i, item in old_enumerate(nums):
+			if i == 0:
+				continue
+			# since we've already taken care of the first item
+			# we don't that
+			if item > 1e9:
+				item = 1e9
+			if item < 1e-9:
+				item = 1e-9
+			prd *= item
+		return prd
+	prd = product
+	def quotient(self) -> Number:
+		if not len(self):
+			return 0.0
+		nums: __old_list__[Number] = [num for num in self if num is not None and isinstance(num, Number)]
+		# this is a necessary check
+		if not len(nums):
+			return 0.0
+		quo: Number = nums[0]
+		for i, item in old_enumerate(nums):
+			if i == 0:
+				continue
+			# since we've already taken care of the first item
+			# we don't that
+			if item == 0:
+				item = 1
+			if item > 1e9:
+				item = 1e9
+			if item < 1e-9:
+				item = 1e-9
+			quo /= item
+		return quo
+	quo = quotient
+	def max(self) -> Number:
+		if not len(self):
+			return 0.0
+		nums: __old_list__[Number] = [num for num in self if num is not None and isinstance(num, Number)]
+		# this is a necessary check
+		if not len(nums):
+			return 0.0
+		return max(nums)
+	def min(self) -> Number:
+		if not len(self):
+			return 0.0
+		nums: __old_list__[Number] = [num for num in self if num is not None and isinstance(num, Number)]
+		# this is a necessary check
+		if not len(nums):
+			return 0.0
+		return min(nums)
+	def combine(self, *args) -> Self:
+		if self.length_is_final:
+			return self
+		if not args:
+			return self
+		for arg in args:
+			if isinstance(arg, tuple):
+				arg = __old_list__(arg)
+				# a tuple?
+				# no thanks,
+				# we need a list
+			if isinstance(arg, __old_list__):
+				arg = flatten(arg)
+				self.extend(arg)
+				return self
+			else:
+				if self.current_type is not Any:
+					if isinstance(arg, Number) and not isinstance(arg, bool) and self.current_type == str:
+						item = Str(arg)
+					if re.search(r"\d|\b(?:True|False)\b", str(arg)) and isinstance(arg, (str, int, float, bool)) and self.current_type in [int, float]:
+						if self.current_type == int:
+							arg = Int(arg)
+						else:
+							arg = Flt(arg)
+						# ^ WARNING (change not needed): refers to `Int` instead of
+						# builtin `int`
+						# FOR A REASON:
+						# forced int-ification (if possible)
+					if type(arg) != self.current_type:
+						continue
+				self.append(arg)
+		return self
+	add = push = me_dalo = combine
+	def push_at(self, i: int, *items) -> Self:
+		if self.length_is_final:
+			return self
+		if not len(items):
+			return self
+		if not isinstance(i, int):
+			i = len(self)
+		if i < 0:
+			i = 0
+		elif i > len(self):
+			i = len(self)
+		#items = flatten(__old_list__(items))
+		items = list(items)
+		if self.current_type is not Any:
+			for i, item in enumerate(items):
+				if isinstance(items[i], Number) and not isinstance(items[i], bool) and self.current_type == str:
+					items[i] = Str(item)
+				if re.search(r"\d|\b(?:True|False)\b", str(items[i])) and isinstance(items[i], (str, int, float, bool)) and self.current_type in [int, float]:
+					if self.current_type == int:
+						items[i] = Int(item)
+					else:
+						items[i] = Flt(item)
+					# ^ WARNING (change not needed): refers to `Int` instead of
+					# builtin `int`
+					# FOR A REASON:
+					# forced int-ification (if possible)
+					# applying the type filter on items
+				if type(items[i]) != self.current_type:
+					items.pop(i)
+		x = self[:i] + items + self[i+len(items)-1:]
+		updated_list: __old_list__ = __old_list__(x)
+		self.clear()
+		self.extend(updated_list)
+		return self
+	def push_start(self, *items) -> Self:
+		self.push_at(0, *items)
+		return self
+	pehla_dalo = ke_pehle_dalo = unshift = push_start
+	def shift(self) -> Any|None:
+		if self.length_is_final:
+			return None
+		if len(self) == 0:
+			return None
+		return self.pop(0)
+		# pop the first item, "shift"ing all to the left by one bit
+	pehla_nikalo = shift
+	# OVERRIDE self.remove
+	old_remove = __old_list__.remove
+	def remove(self, *items) -> Any|None:
+		if self.length_is_final:
+			return None
+		if not len(self):
+			return None
+		if not len(items):
+			return super().pop()
+		items = flatten(__old_list__(items))
+		last_removed: Any = items[-1]
+		for item in items:
+			if not self.contains(item):
+				continue
+			self.old_remove(item)
+		return last_removed
+	rmv = se_nikalo = mese_nikalo = remove
+	# OVERRIDE self.pop
+	old_pop = __old_list__.pop
+	def pop(self, *items) -> Any|None:
+		if self.length_is_final:
+			return None
+		if not len(self):
+			return None
+		if not len(items):
+			return super().pop()
+		items = flatten(__old_list__(items))
+		last_popped: Any = self.old_pop(items[-1])
+		for index in items:
+			if index >= len(self):
+				continue
+			if index < 0:
+				index = len(self) - abs(index)
+				if index < 0 or index >= len(self):
+					continue
+			self.old_pop(index)
+		return last_popped
+	def contains(self, item) -> bool:
+		return self.count(item) > 0
+	has = includes = me_shamil = me_mojud = contains
+	def index_of(self, x: Any) -> int:
+		if not self.contains(x):
+			return -1
+		return self.index(x)
+	find = find_index = index_of
+	no_of = counts_of = __old_list__.count
+	def print_map(self):
+		print(self)
+	def length(self):
+		return len(self)
+class numlist(list[Number]):
+	def __init__(self, *items: Number|list[Number]):
+		super().__init__()
+		self.push(*items)
+	def __add__(self, other: Number|list[Number]) -> Self:
+		if isinstance(other, list):
+			lst: numlist = numlist()
+			for a, b in zip(self, other):
+				lst.append(a+b)
+			return lst
+		if isinstance(other, Number):
+			self.append(other)
+		return self
+	def __radd__(self, other: Number|list[Number]) -> Self:
+		if isinstance(other, list):
+			lst: numlist = numlist()
+			for a, b in zip(self, other):
+				lst.append(b+a)
+			return lst
+		if isinstance(other, Number):
+			self.insert(0, other)
+		return self
+	def __sub__(self, other: list[Number]) -> Self:
+		lst: numlist = numlist()
+		for a, b in zip(self, other):
+			lst.append(a-b)
+		return lst
+	def __rsub__(self, other: list[Number]) -> Self:
+		lst: numlist = numlist()
+		for a, b in zip(self, other):
+			lst.append(b-a)
+		return lst
+	def __mul__(self, other: list[Number]) -> Self:
+		lst: numlist = numlist()
+		for a, b in zip(self, other):
+			lst.append(a*b)
+		return lst
+	def __truediv__(self, other: list[Number]) -> Self:
+		lst: numlist = numlist()
+		for a, b in zip(self, other):
+			if b == 0:
+				b = 1
+			lst.append(a/b)
+		return lst
+	def __pos__(self) -> Self:
+		return numlist(+x for x in self)
+	def __neg__(self) -> Self:
+		return numlist(-x for x in self)
+	def __abs__(self) -> Self:
+		return numlist(abs(x) for x in self)
+	def __pow__(self, other: list[Number]) -> Self:
+		lst: numlist = numlist()
+		for a, b in zip(self, other):
+			if b == 0:
+				b = 1
+			lst.append(a ** b)
+		return lst
+	def __gt__(self, other: list[Number]) -> bool:
+		return all(a > b for a, b in zip(self, other))
+	def __lt__(self, other: list[Number]) -> bool:
+		return all(a < b for a, b in zip(self, other))
+	def __ge__(self, other: list[Number]) -> bool:
+		return all(a >= b for a, b in zip(self, other))
+	def __le__(self, other: list[Number]) -> bool:
+		return all(a <= b for a, b in zip(self, other))
+	def __eq__(self, other: list[Number]) -> bool:
+		return all(a == b for a, b in zip(self, other))
+	def __ne__(self, other: list[Number]) -> bool:
+		return not all(a == b for a, b in zip(self, other))
+	def __str__(self) -> str:
+		return f"numlist([{', '.join(map(str, self))}])"
+	def __repr__(self) -> str:
+		return f"numlist([{', '.join(map(repr, self))}])"
+	def sum(self) -> Number:
+		if not len(self):
+			return 0
+		return sum(self)
+	def difference(self) -> Number:
+		if not len(self):
+			return 0
+		diff: Number = self[0]
+		for i, item in old_enumerate(self):
+			if i == 0:
+				continue
+			# since we've already taken care of the first item
+			# we don't that
+			if item > 1e9:
+				item = 1e9
+			if item < 1e-9:
+				item = 1e-9
+			diff -= item
+		return diff
+	diff = difference
+	def product(self) -> Number:
+		if not len(self):
+			return 0
+		prd: Number = self[0]
+		for i, item in old_enumerate(self):
+			if i == 0:
+				continue
+			# since we've already taken care of the first item
+			# we don't that
+			if item > 1e9:
+				item = 1e9
+			if item < 1e-9:
+				item = 1e-9
+			prd *= item
+		return prd
+	prd = product
+	def quotient(self) -> Number:
+		if not len(self):
+			return 0
+		quo: Number = self[0]
+		for i, item in old_enumerate(self):
+			if i == 0:
+				continue
+			# since we've already taken care of the first item
+			# we don't that
+			if item == 0:
+				item = 1
+			if item > 1e9:
+				item = 1e9
+			if item < 1e-9:
+				item = 1e-9
+			quo /= item
+		return quo
+	quo = quotient
+	def max(self) -> Number:
+		if not len(self):
+			return 0
+		return max(self)
+	def min(self) -> Number:
+		if not len(self):
+			return 0
+		return min(self)
+	def combine(self, *args: list[Number]) -> Self:
+		if not args:
+			return self
+		for arg in args:
+			if not isinstance(arg, (Number, list)):
+				continue
+			if (isinstance(arg, list) and not all(isinstance(item, Number) for item in arg)):
+				# if it's neither of the supported types
+				# don't push anything
+				continue
+			if isinstance(arg, tuple):
+				arg = list(arg)
+				# a tuple?
+				# no thanks,
+				# we need a list
+			if isinstance(arg, list):
+				self.extend(arg)
+			else:
+				self.append(arg)
+		return self
+	add = push = me_dalo = combine
+	def push_at(self, i: int, *items) -> Self:
+		if not len(items) or not all(isinstance(item, Number) for item in items):
+			return self
+		if not isinstance(i, int):
+			i = len(self)
+		if i < 0:
+			i = 0
+		elif i > len(self):
+			i = len(self)
+		items = flatten(list(items))
+		x = self[:i] + list(items) + self[i+len(items)-1:]
+		updated_list: numlist = numlist(x)
+		self.clear()
+		self.extend(updated_list)
+		return self
+	def push_start(self, *items) -> Self:
+		self.push_at(0, *items)
+		return self
+	unshift = push_start
+	def shift(self) -> Number:
+		if len(self) == 0:
+			return 0
+		return self.pop(0)
+	# OVERRIDE self.remove
+	old_remove = list[Number].remove
+	def remove(self, *items: list[Number]) -> Number:
+		if not len(self) or not all(isinstance(item, (Number, list)) for item in items if item is not None):
+			return 0
+		if not len(items):
+			return super().pop()
+		items = flatten(list(items))
+		last_removed: Number = items[-1]
+		for item in items:
+			if not self.contains(item):
+				continue
+			self.old_remove(item)
+		return last_removed
+	rmv = se_nikalo = remove
+	# OVERRIDE self.pop
+	old_pop = list[Number].pop
+	def pop(self, *items: list[Number]) -> Number:
+		if not len(self) or not all(isinstance(item, (Number, list)) for item in items if item is not None):
+			return 0
+		if not len(items):
+			return super().pop()
+		items = flatten(list(items))
+		last_popped: Number = self.old_pop(items[-1])
+		for index in items:
+			if index >= len(self):
+				continue
+			if index < 0:
+				index = len(self) - abs(index)
+				if index < 0 or index >= len(self):
+					continue
+			self.old_pop(index)
+		return last_popped
+	#def pop_at
+	def contains(self, item) -> bool:
+		return self.count(item) > 0
+	has = includes = me_mojud = contains
+	def index_of(self, x: Number) -> int:
+		if not isinstance(x, Number) or not self.contains(x):
+			return -1
+		return self.index(x)
+	find = find_index = index_of
+	no_of = counts_of = list[Number].count
+"""
+nlist: numlist = numlist([2, 0, 5])
+print(nlist.pop(0, -2))
+print(nlist.quo())
+print(nlist.find(1))
+print(nlist)
+"""
+num_list = numlist
+class intlist(list[int]):
+	def __init__(self, *items: int):
+		super().__init__(items)
+	def __add__(self, other: list[int]) -> Self:
+		lst: intlist = intlist()
+		for a, b in zip(self, other):
+			lst.append(Int(a)+Int(b))
+		return lst
+	def __radd__(self, other: list[int]) -> Self:
+		lst: intlist = intlist()
+		for a, b in zip(self, other):
+			lst.append(Int(b)+Int(a))
+		return lst
+	def __sub__(self, other: list[int]) -> Self:
+		lst: intlist = intlist()
+		for a, b in zip(self, other):
+			lst.append(Int(a)-Int(b))
+		return lst
+	def __rsub__(self, other: list[int]) -> Self:
+		lst: intlist = intlist()
+		for a, b in zip(self, other):
+			lst.append(Int(b)-Int(a))
+		return lst
+	def __mul__(self, other: list[int]) -> Self:
+		lst: intlist = intlist()
+		for a, b in zip(self, other):
+			lst.append(Int(a)*Int(b))
+		return lst
+	def __truediv__(self, other: list[int]) -> Self:
+		lst: intlist = intlist()
+		for a, b in zip(self, other):
+			if b == 0:
+				b = 1
+			lst.append(Int(a)/Int(b))
+		return lst
+	def __pos__(self) -> Self:
+		return intlist(Int(+x) for x in self)
+	def __neg__(self) -> Self:
+		return intlist(Int(-x) for x in self)
+	def __abs__(self) -> Self:
+		return intlist(Int(abs(x)) for x in self)
+	def __pow__(self, other: list[int]) -> Self:
+		lst: intlist = intlist()
+		for a, b in zip(self, other):
+			if b == 0:
+				b = 1
+			lst.append(Int(a) ** Int(b))
+		return lst
+	def __gt__(self, other: list[int]) -> bool:
+		return all(Int(a) > Int(b) for a, b in zip(self, other))
+	def __lt__(self, other: list[int]) -> bool:
+		return all(Int(a) < Int(b) for a, b in zip(self, other))
+	def __ge__(self, other: list[int]) -> bool:
+		return all(Int(a) >= Int(b) for a, b in zip(self, other))
+	def __le__(self, other: list[int]) -> bool:
+		return all(Int(a) <= Int(b) for a, b in zip(self, other))
+	def __eq__(self, other: list[int]) -> bool:
+		return all(Int(a) == Int(b) for a, b in zip(self, other))
+	def __ne__(self, other: list[int]) -> bool:
+		return not all(Int(a) == Int(b) for a, b in zip(self, other))
+	def __str__(self) -> str:
+		return f"intlist([{', '.join(map(str, self))}])"
+	def __repr__(self) -> str:
+		return f"intlist([{', '.join(map(repr, self))}])"
+int_list = intlist
+class fltlist(list[float]):
+	def __init__(self, *items: int):
+		super().__init__(items)
+	def __add__(self, other: list[float]) -> Self:
+		lst: fltlist = fltlist()
+		for a, b in zip(self, other):
+			lst.append(Flt(a)+Flt(b))
+		return lst
+	def __radd__(self, other: list[float]) -> Self:
+		lst: fltlist = fltlist()
+		for a, b in zip(self, other):
+			lst.append(Flt(b)+Flt(a))
+		return lst
+	def __sub__(self, other: list[float]) -> Self:
+		lst: fltlist = fltlist()
+		for a, b in zip(self, other):
+			lst.append(Flt(a)-Flt(b))
+		return lst
+	def __rsub__(self, other: list[float]) -> Self:
+		lst: fltlist = fltlist()
+		for a, b in zip(self, other):
+			lst.append(Flt(b)-Flt(a))
+		return lst
+	def __mul__(self, other: list[float]) -> Self:
+		lst: fltlist = fltlist()
+		for a, b in zip(self, other):
+			lst.append(Flt(a)*Flt(b))
+		return lst
+	def __truediv__(self, other: list[float]) -> Self:
+		lst: fltlist = fltlist()
+		for a, b in zip(self, other):
+			if b == 0:
+				b = 1
+			lst.append(Flt(a)/Flt(b))
+		return lst
+	def __pos__(self) -> Self:
+		return fltlist(Flt(+x) for x in self)
+	def __neg__(self) -> Self:
+		return fltlist(Flt(-x) for x in self)
+	def __abs__(self) -> Self:
+		return fltlist(Flt(abs(x)) for x in self)
+	def __pow__(self, other: list[float]) -> Self:
+		lst: fltlist = fltlist()
+		for a, b in zip(self, other):
+			if b == 0:
+				b = 1
+			lst.append(Flt(a) ** Flt(b))
+		return lst
+	def __gt__(self, other: list[float]) -> bool:
+		return all(Flt(a) > Flt(b) for a, b in zip(self, other))
+	def __lt__(self, other: list[float]) -> bool:
+		return all(Flt(a) < Flt(b) for a, b in zip(self, other))
+	def __ge__(self, other: list[float]) -> bool:
+		return all(Flt(a) >= Flt(b) for a, b in zip(self, other))
+	def __le__(self, other: list[float]) -> bool:
+		return all(Flt(a) <= Flt(b) for a, b in zip(self, other))
+	def __eq__(self, other: list[float]) -> bool:
+		return all(Flt(a) == Flt(b) for a, b in zip(self, other))
+	def __ne__(self, other: list[float]) -> bool:
+		return not all(Flt(a) == Flt(b) for a, b in zip(self, other))
+	def __str__(self) -> str:
+		return f"fltlist([{', '.join(map(str, self))}])"
+	def __repr__(self) -> str:
+		return f"fltlist([{', '.join(map(repr, self))}])"
+flt_list = fltlist
+# preserve the sequence
+T: TypeVar = TypeVar('T')
+class Stack[T]:
+	def __init__(self, *items: T):
+		self.array: list[T] = []
+		self.length: int = -1
+		if len(items) != 0:
+			for item in items:
+				self.push(item)
+	def push(self, item: T) -> Self:
+		self.array.append(item)
+		self.length += 1
+		return self
+	def pop(self) -> Optional[T]:
+		if self.length == -1:
+			return None
+		popped: T = self.array[self.length]
+		self.length -= 1
+		return popped
+	def top(self) -> Optional[T]:
+		if self.length == -1:
+			return None
+		return self.array[self.length]
+	def len(self) -> int:
+		return self.length + 1
+	def size(self) -> int:
+		return self.len()
+	def __len__(self) -> int:
+		return self.len()
+	def __str__(self) -> str:
+		return str(self.array)
+def is_valid_regex(text: str) -> bool:
+	if not isinstance(text, str):
+		return False
+	try:
+		re.compile(text)
+		return True
+	except re.error:
+		return False
+is_valid_re = he_valid_regex = he_valid_re = is_valid_regex
+def escape_if_not_valid_regex(text: str) -> str:
+	if not isinstance(text, str):
+		return ""
+	escaped_text: str = re.escape(
+		text
+	)
+	if not is_valid_regex(text):
+		return escaped_text
+	return text
+escape_if_not_valid_re = escape_if_not_valid_regex
+floor_get = floor_key = near_key = close_get = near_get
+class obj(dict):
+	def __init__(self, *args, **kwargs):
+		super().__init__(*args, **kwargs)
+		self._convert_nested_dicts(self)
+	def _convert_nested_dicts(self, object):
+		if isinstance(object, dict):
+			for k, v in object.items():
+				if isinstance(v, dict):
+					object[k] = obj(v)
+				elif isinstance(v, (list, tuple)):
+					object[k] = self._convert_nested_collections(v)
+		elif isinstance(object, (list, tuple)):
+			return self._convert_nested_collections(object)
+		return object
+	def _convert_nested_collections(self, collection):
+		converted_collection = []
+		for item in collection:
+			if isinstance(item, dict):
+				converted_collection.append(obj(item))
+			elif isinstance(item, (list, tuple)):
+				converted_collection.append(self._convert_nested_collections(item))
+			else:
+				converted_collection.append(item)
+		return type(collection)(converted_collection)
+	floor_get = floor_key = near_key = close_get = near_get = lambda self, k, default=None: globals().get("floor_get", None)(self, k, default) if callable(globals().get("floor_get", None)) else None
+	def __call__(self, key, default = None, *args, **kwargs):
+		return safe_get(
+			self,
+			path=key,
+			default=default,
+			*args,
+			**kwargs
+		)
+	def __getitem__(self, key) -> Any:
+		default = None
+		if isinstance(key, (list, tuple, set))\
+			and len(key) >= 2:
+				key, default = key[0], key[1]
+		if not all(
+			isinstance(
+				k,
+				(str, int, float)
+			)\
+				for k in self.keys()
+		):
+			return default
+		if not isinstance(
+			key,
+			(str, int, float)
+		):
+				return default
+		key_lower  = key.lower()\
+			if isinstance(key, str)\
+			else int(key)
+		d_lower : dict = {
+			(k.lower()\
+				if type(k) == str\
+				else int(k))\
+					: v\
+						for k, v\
+							in self.items()
+		}
+		try:
+			if isinstance(key_lower, str):
+				if not any(
+					k.startswith(key_lower)\
+						for k in d_lower\
+							if isinstance(k, str)
+				):
+								return default
+				for k in d_lower:
+					if isinstance(k, str)\
+						and k.startswith(key_lower):
+							return d_lower[k]
+			elif key_lower not in d_lower:
+					return default
+			return d_lower[key_lower]
+		except Exception as e:
+			print(e)
+			if key not in self:
+				return default
+			return super().__getitem__(key)
+	ka = ki = ke = mese = __getattr__ = __call__
+	def __setattr__(self, key, value) -> None:
+		if isinstance(value, dict):
+			self[key] = obj(value)
+		elif isinstance(value, (list, tuple)):
+			self[key] = self._convert_nested_collections(
+				value
+			)
+		else:
+			self[key] = value
+	def __setitem__(self, key, value) -> None:
+		if isinstance(value, dict):
+			super().__setitem__(
+				key,
+				obj(value)
+			)
+		elif isinstance(value, (list, tuple)):
+			super().__setitem__(
+				key,
+				self.\
+					_convert_nested_collections(
+						value
+					)
+			)
+		else:
+			super().__setitem__(
+				key,
+				value
+			)
+	def keys(self) -> list[Union[str, int, float]]:
+		return list(
+			super()\
+				.keys()
+		)
+	def values(self) -> list[Any]:
+		return list(
+			super()\
+				.values()
+		)
+	def entries(self) -> list[list]:
+		return list(
+			super()\
+				.items()
+		)
+# allows obj($x=$valueForX, $y=$valueForY)
+o = Obj = obj
+# for older dictionaries
+def keys(dictionary: dict) -> list:
+	if not isinstance(dictionary, dict):
+		return []
+	return list(
+		dictionary.keys()
+	)
+def values(dictionary: dict) -> list:
+	if not isinstance(dictionary, dict):
+		return []
+	return list(
+		dictionary.values()
+	)
+def entries(dictionary: dict) -> list:
+	if not isinstance(dictionary, dict):
+		return []
+	return list(
+		dictionary.items()
+	)
+get_keys = keys_of = keys
+get_values = values_of = values
+get_entries = entries_of = entries
+def remove_duplicates(lst: list) -> list:
+	if not lst or not isinstance(lst, list):
+		return []
+	return list(dict.fromkeys(lst).keys())
+def swap_keys(_obj: dict[Any, Any]) -> dict[Any, Any]:
+	if not isinstance(_obj, Iterable):
+		return {}
+	return {v: k for k, v in _obj.items()}
+def Count(itrbl: Iterable) -> dict[int, Any]:
+	if not isinstance(itrbl, Iterable):
+		return {}
+	counted: dict[int, Any] = {}
+	for key in itrbl:
+		counted[key] = counted.get(key, 0) + 1
+	counted = swap_keys(counted)
+	return counted
+count_occur = Count
+# ^DIFFERENT FROM collections.count
+def get_local_declarations() -> obj:
+	"""
+	@return
+		<dict>
+		::a dictionary holding all the local variables, (sub)classes (of classes), and the functions of the local scope of a class/function
+	"""
+	[variables, classes, functions] = [{}, {}, {}]
+	frame = currentframe().f_back
+	for name, _obj in frame.f_locals.items():
+		# Exclude built-in names and imported modules
+		if not name.startswith('__'):
+			if isfunction(_obj):
+				functions[name] = _obj
+			elif isclass(_obj):
+				classes[name] = _obj
+			# For variables, we can assume anything else that's not a function or class
+			# and is user-defined in this module is a variable.
+			# This is a simplification; more robust checks might be needed for complex cases.
+			elif not ismodule(_obj):						   # Exclude imported modules
+				variables[name] = _obj
+	return o(variables=variables, classes=classes, functions=functions)
+def get_global_declarations() -> obj:
+	"""
+	@return
+		<dict>
+		::a dictionary holding all the local variables, (sub)classes (of classes), and the functions of the local scope of a class/function
+	"""
+	[variables, classes, functions] = [{}, {}, {}]
+	for name, _obj in globals().items():
+		# Exclude built-in names and imported modules
+		if not name.startswith('__') and getmodule(_obj) is sys.modules[__name__]:
+			if isfunction(_obj):
+				functions[name] = _obj
+			elif isclass(_obj):
+				classes[name] = _obj
+			# For variables, we can assume anything else that's not a function or class
+			# and is user-defined in this module is a variable.
+			# This is a simplification; more robust checks might be needed for complex cases.
+			elif not ismodule(_obj):						  # Exclude imported modules
+				variables[name] = _obj
+	return o(variables=variables, classes=classes, functions=functions)
+Yes = Ha = Han =  true = True
+No = Na = Nahi = false = False
+none: NoneType = None
+null = none
+sort = lambda x: sorted(x) if isinstance(x, Iterable) else []
+reverse_sort = sort_reverse = lambda x: sorted(x, reverse=True) if isinstance(x, Iterable) else []
+def sort_mutate(x) -> str | list | tuple:
+	if type(x) not in (str, list, tuple):
+		return x
+	was_a_string: bool = False
+	was_a_tuple: bool = False
+	if isinstance(x, str):
+		x = list(x)
+		was_a_string = True
+	elif isinstance(x, tuple):
+		x = list(x)
+		was_a_tuple = True
+	x.sort()
+	# ^ return None after sorting
+	# let's forcibly return the final x
+	if was_a_string:
+		x = "".join(str(item) for item in x)
+	elif was_a_tuple:
+		x = tuple(x)
+	return x
+mutate_sort = inplace_sort = sort_inplace = sort_mutate
+def sort_reverse_mutate(x) -> str | list | tuple:
+	if type(x) not in (str, list, tuple):
+		return x
+	was_a_string: bool = False
+	was_a_tuple: bool = False
+	if isinstance(x, str):
+		x = list(x)
+		was_a_string = True
+	elif isinstance(x, tuple):
+		x = list(x)
+		was_a_tuple = True
+	x.sort(reverse=True)
+	# ^ return None after reverse-sorting
+	# let's forcibly return the final x
+	if was_a_string:
+		x = "".join(str(item) for item in x)
+	elif was_a_tuple:
+		x = tuple(x)
+	return x
+mutate_sort_reverse = mutate_reverse_sort = sort_mutate_reverse = reverse_mutate_sort = reverse_sort_mutate = inplace_sort_reverse = inplace_reverse_sort = sort_inplace_reverse = reverse_inplace_sort = reverse_sort_inplace = sort_reverse_mutate
+def reverse(x: Iterable) -> str | list | tuple | dict:
+	if type(x) not in (str, list, tuple, dict):
+		return x
+	if isinstance(x, dict):
+		reversed_kvs: dict = {v: k for k, v in x.items() if type(v) in (str, int, float)}
+		return reversed_kvs
+	return x[::-1]
+def shuffle(x: Iterable) -> str | list | tuple:
+	if type(x) not in (str, list, tuple):
+		return x
+	was_a_string: bool = False
+	was_a_tuple: bool = False
+	if isinstance(x, str):
+		x = list(x)
+		was_a_string = True
+	elif isinstance(x, tuple):
+		x = list(x)
+		was_a_tuple = True
+	final_x: list = x.copy() # to not mutate the original x
+	random.shuffle(final_x)
+	# ^ return None after shuffling
+	# let's forcibly return the final x
+	if was_a_string:
+		final_x = "".join(str(item) for item in final_x)
+	elif was_a_tuple:
+		final_x = tuple(final_x)
+	return final_x
+shuffled = shuffle
+def shuffle_mutate(x: Iterable) -> str | list | tuple:
+	if type(x) not in (str, list, tuple):
+		return x
+	was_a_string: bool = False
+	was_a_tuple: bool = False
+	if isinstance(x, str):
+		x = list(x)
+		was_a_string = True
+	elif isinstance(x, tuple):
+		x = list(x)
+		was_a_tuple = True
+	random.shuffle(x)
+	# ^ return None after shuffling
+	# let's forcibly return the final x
+	final_x: list = x
+	if was_a_string:
+		final_x = "".join(str(item) for item in final_x)
+	elif was_a_tuple:
+		final_x = tuple(final_x)
+	return final_x
+mutate_shuffle = inplace_shuffle = shuffle_inplace = shuffle_mutate
+_filter = lambda arr, condition: filter(condition, arr)
+# test this	
+def rng_old(x: str|list|tuple|Number, y: str|list|tuple|Number|None = None, step: Number = 1, inclusive: bool = True, **kwargs) -> list[int] | list[float] | list[str]:
+	if x is None or not isinstance(x, (str, list, tuple, Number)) or not isinstance(y, (str, list, tuple, Number, NoneType)) or step is None or not isinstance(step, Number):
+		return []
+	x_is_a_parsable_char: bool = False
+	y_is_a_parsable_char: bool = False
+	if isinstance(x, str) and len(str(x).strip()) == 1 and 0 <= ord(x) <= 127:
+		if not y:
+			y = ord(x[0])
+			x = 97 if x[0].lower() == x[0] else 65
+		else:
+			x = ord(x[0])
+		x_is_a_parsable_char = True
+	if isinstance(y, str) and len(str(y).strip()) != 0 and 0 <= ord(y) <= 127:
+		y = ord(y[0])
+		y_is_a_parsable_char = True
+	char_mode: bool = x_is_a_parsable_char and y_is_a_parsable_char
+	if len(kwargs):
+		if "s" in kwargs:
+			step = kwargs.get("s", 1)
+		elif "step" in kwargs:
+			step = kwargs.get("step", 1)
+		if "incl" in kwargs:
+			inclusive = kwargs.get("incl", inclusive)
+		elif "shamil" in kwargs:
+			inclusive = kwargs.get("shamil", inclusive)
+		elif "shamil_akhri" in kwargs:
+			inclusive = kwargs.get("shamil_akhri", inclusive)
+		elif "shaamil" in kwargs:
+			inclusive = kwargs.get("shaamil", inclusive)
+		elif "shaamil_akhri" in kwargs:
+			inclusive = kwargs.get("shaamil_akhri", inclusive)
+	if step <= 0:
+		step = 1
+	if (isinstance(y, Number) and step >= y):
+		step = 1
+	if isinstance(x, (str, list, tuple)) and step >= len(x):
+		step = 1
+	if isinstance(y, (str, list, tuple)) and step >= len(y):
+		step = 1
+	if isinstance(step, Number) and step % 1 == 0:
+		step = int(step)
+	exclusive = not inclusive
+	return_list: list[int] | list[float] = []
+	if y is None:
+		inclusive = False
+		if not isinstance(x, Number) and isinstance(step, (int, float)):
+			if char_mode:
+				step = int(step)
+			i: int = 0
+			while i < len(x):
+				return_list.append(i)
+				i += step
+			if exclusive and len(return_list):
+				return_list = return_list[:-1]
+			return return_list
+		x = abs(x)
+		if isinstance(x, int) and isinstance(step, (int, float)):
+			i: int = 0
+			while i < x:
+				return_list.append(i)
+				i += step
+		if isinstance(x, float):
+			i: float = 0
+			while i < x:
+				return_list.append(i)
+				i += step
+		if inclusive and len(return_list):
+			return_list.append(x)
+		return return_list
+	if (isinstance(x, int) and isinstance(step, (int, float))) and not isinstance(y, Number):
+		if char_mode:
+			step = int(step)
+		y_length: int = len(y)
+		if x < 0 or x >= y_length:
+			return []
+		while x < y_length:
+			return_list.append(x)
+			x += step
+		if exclusive and len(return_list):
+			return_list = return_list[:-1]
+		return return_list
+	elif isinstance(x, int) and isinstance(y, int) and isinstance(step, (int, float)):
+		if char_mode:
+			step = int(step)
+		if x == y:
+			return []
+		if x > y:
+			while x >= y:
+				return_list.append(x)
+				x -= step
+		else:
+			while x <= y:
+				return_list.append(x)
+				x += step
+	elif isinstance(x, float) or isinstance(y, float):
+		if x == y:
+			return []
+		if x > y:
+			while x >= y:
+				return_list.append(x)
+				x -= step
+		else:
+			while x <= y:
+				return_list.append(x)
+				x += step
+	if x_is_a_parsable_char or y_is_a_parsable_char:
+		return_list = [chr(n) for n in return_list]
+	if exclusive and len(return_list):
+		return_list = return_list[:-1]
+	return return_list
+def rng(
+	x: Union[str, Iterable, Number],
+	y: Union[str, Iterable, Number, None] = None,
+	step: Number = 1,
+	inclusive: int | bool = True,
+	reverse: bool = False,
+	**kwargs
+) -> list[str | int | float]:
+	step: int | float = kwargs.get("s", kwargs.get("step", step))
+	incl_flags: list[str] = ["incl", "shamil", "shamil_akhri", "shaamil", "shaamil_akhri"]
+	rev_flags: list[str] = ["reversed", "rev", "ulat", "ulta", "ulti", "ulte"]
+	force_inclusive = isinstance(inclusive, int) and inclusive == 2
+	for flag in incl_flags:
+		if flag in kwargs:
+			val = kwargs[flag]
+			inclusive = isinstance(val, (int, bool)) and val in (1, 2, True)
+			if val == 2:
+				force_inclusive = True
+			break
+	for flag in rev_flags:
+		if flag in kwargs:
+			reverse = bool(kwargs[flag])
+			break
+	if not isinstance(step, Number) or isinstance(step, bool):
+		step = 1
+	try:
+		step_val = float(step)
+	except (ValueError, TypeError):
+		step_val = 1.0
+	if step_val <= 0:
+		step_val = 1.0
+	char_mode = False
+	def get_char_ord(s: str) -> int:
+		if not s:
+			return 0
+		stripped = s.strip()
+		target = stripped[0] if stripped else s[0]
+		return ord(target)
+	if y is None:
+		start_val = 0.0
+		if isinstance(x, str) and len(x) > 0:
+			char_mode = True
+			start_val = 97.0 if x[0].islower() else 65.0
+			end_val = float(get_char_ord(x))
+		elif isinstance(x, Iterable) and not isinstance(x, str):
+			end_val = float(len(x))
+		elif isinstance(x, Number) and not isinstance(x, bool):
+			try:
+				end_val = float(x)
+			except (ValueError, TypeError):
+				return []
+		else:
+			return []
+		if not char_mode and not force_inclusive:
+			inclusive = False
+	else:
+		if isinstance(x, str) and len(x) > 0:
+			char_mode = True
+			start_val = float(get_char_ord(x))
+		elif isinstance(x, Number) and not isinstance(x, bool):
+			start_val = float(x)
+		else:
+			start_val = 0.0
+		if isinstance(y, str) and len(y) > 0:
+			char_mode = True
+			end_val = float(get_char_ord(y))
+		elif isinstance(y, Iterable) and not isinstance(y, str):
+			end_val = float(len(y))
+			if not force_inclusive: inclusive = False
+			if start_val < 0 or start_val >= end_val:
+				return []
+		elif isinstance(y, Number) and not isinstance(y, bool):
+			end_val = float(y)
+		else:
+			return []
+	if force_inclusive:
+		inclusive = True
+	if not (math.isfinite(start_val) and math.isfinite(end_val) and math.isfinite(step_val)):
+		return []
+	result_floats = []
+	if start_val <= end_val:
+		current = start_val
+		while current < end_val or (inclusive and math.isclose(current, end_val, rel_tol=1e-12, abs_tol=1e-12)):
+			result_floats.append(current)
+			current += step_val
+			if current == start_val:
+				break
+	else:
+		current = start_val
+		while current > end_val or (inclusive and math.isclose(current, end_val, rel_tol=1e-12, abs_tol=1e-12)):
+			result_floats.append(current)
+			current -= step_val
+			if current == start_val:
+				break
+	if not result_floats:
+		return []
+	if reverse:
+		result_floats = result_floats[::-1]
+	if char_mode:
+		return [chr(int(round(n))) for n in result_floats if 0 <= int(round(n)) <= 0x10FFFF]
+	result_floats = [round(n, 1) for n in result_floats]
+	if all(n.is_integer() for n in result_floats):
+		return [int(round(n)) for n in result_floats]
+	return result_floats
+def f(*args) -> str:
+	formatted: str = ""
+	curframe: Optional[FrameType] = currentframe()
+	frames: list[Optional[FrameType]] = []
+	caller_locals: dict[str, Any] = {}
+	while curframe is not None:
+		frames.append(curframe)
+		curframe = curframe.f_back
+		# keep retrieving until you hit the oldest ancestor
+	frames = reversed(frames)
+	# reverse the frames to prioritize the closest local scope first
+	for scope in frames:
+		caller_locals.update(scope.f_globals | scope.f_locals)
+	blacklisted_keywords: list[str] = ['import', '__', 'open', 'exec', 'eval', 'del', 'lambda']
+	blacklisted_functions: list[str] = ['system', 'popen', 'subprocess']
+	blacklisted_items: list[str] = [*blacklisted_keywords, *blacklisted_functions]
+	for arg in args:
+		if isinstance(arg, bool):
+			arg = "Yes" if arg == True else "No"
+		try:
+			ast.parse(f"f'{arg}'")
+			arg_lower: str = arg.lower()
+			for item in blacklisted_items:
+				if item in arg_lower:
+					print(f"Forbidden keyword/function in input: '{item}'")
+					continue
+			# Evaluate the expression
+			arg = re.sub(r"(?<!\\)[\$\{]+([^\s\{\}\(\)\$]+(?:\(([\w\.\-]+(,\s*)?)*\))?)(\}(?!#{4}))?", r"{\1}", arg)
+			# (?<!\\) means recognize escapes, and only match if the dollar '$', and opening_brace '{'' are not precededed by a forward slash '\' (which is the standard pattern for regex escapes)
+			evaluation: str = eval(f"f'{arg}'", {"__builtins__": {}}, caller_locals)
+			WHITESPACE_CHAR = " "
+			# for readability, there should be a whitespace character after each argument, except the last one (though, for the last one, it does not really matter, as it usually goes unnoticed)
+			formatted += evaluation + WHITESPACE_CHAR
+		except Exception as e:
+			...
+	formatted = formatted.rstrip()
+	return formatted
+def printf(*args, **kwargs) -> None:
+	print(f(*args), **kwargs)
+kaho = printf
+def khali(x: Iterable) -> bool:
+	if x is None:
+		return True
+	if not isinstance(x, Iterable):
+		return not x
+	if isinstance(x, str):
+		return not x.strip()
+	return len(x) == 0
+is_empty = isempty = khali_he = khali
+# type checks
+is_none = isnone = is_null = isnull = lambda x: x is None
+isnt_none = isntnone = non_none = nonnone = lambda x: not is_none(x)
+isstr = is_str = isstring = is_string = hestr = he_str = hestring = he_string = lambda x: isinstance(x, str)
+isnt_string = isntstring = isnt_str = isntstr = non_string = nonstring = non_str = nonstr = lambda x: not is_string(x)
+isint = is_int = isinteger = is_integer = heint = he_int = heinteger = he_integer = lambda x: isinstance(x, int) and not isinstance(x, bool)
+isnt_integer = isntinteger = isnt_int = isntint = non_integer = noninteger = non_int = nonint = lambda x: not is_integer(x)
+
+def is_int_like(x: str) -> bool:
+	if isinstance(x, bool):
+		return True
+	x = str(x)
+	parsed: int = 0
+	try:
+		parsed = int(x)
+		return True
+	except ValueError:
+		...
+	return False
+he_int_jesa = he_int_jesi = he_parsable_int = is_parsable_int = is_int_like
+isflt = is_flt = isfloat = is_float = isdbl = is_dbl = isdouble = is_double = heflt = he_flt = hefloat = he_float = lambda x: isinstance(x, float) and not isinstance(x, bool)
+isnt_float = isntfloat = isnt_float = isntfloat = non_float = nonfloat = non_flt = nonflt = lambda x: not is_float(x)
+def is_float_like(x: str) -> bool:
+	x = str(x)
+	parsed: float = 0.0
+	try:
+		parsed = float(x)
+		return True
+	except ValueError:
+		...
+	return False
+he_flt_jesa = he_flt_jesi = he_parsable_flt = is_parsable_flt = is_flt_like = he_float_jesa = he_float_jesi = he_parsable_float = is_parsable_float = is_float_like = is_float_like
+isnr = is_nr = isnum = is_num = isnumber = is_number = henr = he_nr = henum = he_num = henumber = he_number = lambda x: isinstance(x, (int, float))
+is_boolean = isboolean = is_bool = isbool = hebool = he_bool = heboolean = he_boolean = hehaal = he_haal = lambda x: isinstance(x, bool)
+isnt_boolean = isntboolean = isnt_bool = isntbool = non_boolean = nonboolean = non_bool = nonbool = lambda x: not is_boolean(x)
+def is_bool_like(x: str) -> bool:
+	x = str(x)
+	parsed: bool = False
+	if x == "True":
+		parsed = True
+	elif x == "False":
+		parsed = False
+	return parsed
+islist = is_list = helist = he_list = lambda x: isinstance(x, list)
+isnt_list = isntlist = lambda x: not is_list(x)
+is_stringlist = is_stringarr = is_strlist = is_strarr = isstringlist = isstringarr = isstrlist = isstrarr = lambda x: isinstance(x, (list[str], tuple[str, ...]))
+isnt_stringlist = isnt_stringarr = isnt_strlist = isnt_strarr = isntstringlist = isntstringarr = isntstrlist = isntstrarr = non_stringlist = non_stringarr = non_strlist = non_strarr = nonstringlist = nonstringarr = nonstrlist = nonstrarr = lambda x: not is_stringlist(x)
+is_integerlist = is_integerarr = is_intlist = is_intarr = isintegerlist = isintegerarr = isintlist = isintarr = lambda x: isinstance(x, (list[int], tuple[int, ...]))
+isnt_integerlist = isnt_integerarr = isnt_intlist = isnt_intarr = isntintegerlist = isntintegerarr = isntintlist = isntintarr = non_integerlist = non_integerarr = non_intlist = non_intarr = nonintegerlist = nonintegerarr = nonintlist = nonintarr = lambda x: not is_integerlist(x)
+is_floatlist = is_floatarr = is_fltlist = is_fltarr = isfloatlist = isfloatarr = isfltlist = isfltarr = lambda x: isinstance(x, (list[float], tuple[float, ...]))
+isnt_floatlist = isnt_floatarr = isnt_fltlist = isnt_fltarr = isntfloatlist = isntfloatarr = isntfltlist = isntfltarr = non_floatlist = non_floatarr = non_fltlist = non_fltarr = nonfloatlist = nonfloatarr = nonfltlist = nonfltarr = lambda x: not is_floatlist(x)
+is_booleanlist = is_booleanarr = is_boollist = is_boolarr = isbooleanlist = isbooleanarr = isboollist = isboolarr = lambda x: isinstance(x, (list[bool], tuple[bool, ...]))
+isnt_booleanlist = isnt_booleanarr = isnt_boollist = isnt_boolarr = isntbooleanlist = isntbooleanarr = isntboollist = isntboolarr = non_booleanlist = non_booleanarr = non_boollist = non_boolarr = nonbooleanlist = nonbooleanarr = nonboollist = nonboolarr = lambda x: not is_booleanlist(x)
+is_iterable = isiterable = lambda x: isinstance(x, Iterable)
+isnt_iterable = isntiterable = non_iterable = noniterable = lambda x: not is_iterable(x)
+istuple = is_tuple = hetuple = he_tuple = lambda x: isinstance(x, tuple)
+isset = is_set = heset = he_set = lambda x: isinstance(x, set)
+isdict = is_dict = isdictionary = is_dictionary = hedict = he_dict = hedictionary = he_dictionary = lambda x: isinstance(x, dict)
+is_callable = iscallable = is_function = isfunction = is_func = isfunc = lambda x: callable(x)
+isnt_callable = isntcallable = non_callable = noncallable = lambda x: not is_callable(x)
+def split(src: str, regex: str|NoneType = None, maxsplits: int = IntInfinity, flags: int = 0) -> list[str]:
+	if not src or not isinstance(src, str) or not isinstance(regex, (str, NoneType)):
+		# allow regex to be empty, as it sometimes can be
+		return []
+	if regex is None:
+		# if the regex is None, split into words (hyphen, and quote preserved, for max reliability)
+		regex = r"([^\-\w\"\']|(?<!\w)[\-\"\'](?!\w))"
+	regex = str(regex)
+	if not isinstance(maxsplits, int):
+		maxsplits = IntInfinity
+	if maxsplits <= 0:
+		return [src]
+	if not isinstance(flags, int):
+		flags = 0
+	try:
+		regex = re.sub(r"(\?)(<\w+>)", r"\1P\2", regex)
+		raw_list: list[str] = re.split(regex, src, maxsplit=maxsplits, flags=flags)
+		result: list[str] = []
+		for x in raw_list:
+			if not x:
+				continue
+			result.append(x)
+		return result
+	except re.error as e:
+		# fallback to original splitting
+		# if regex splitting fails
+		print(f"re.warning:\n  * Bad regex split pattern. Falling back to the original `'string'.split`. *Reason*: {str(e).capitalize()}.")
+		return [x for x in src.split(regex) if x]
+def joined_words(*args: tuple[Any]) -> str:
+	"""
+	@param			args
+		:type			tuple[Any]
+		:description		arguments to join in "x, y, aur z" format
+	@return			
+		:type										  str <blankable, if len(args) == 0>
+		:description		the joined arguments (initially of type, Any)
+	"""
+	result: list[str] = []
+	for arg in args:
+		if arg is None:
+			continue
+		if isinstance(arg, (list, tuple)):
+			arg = joined_words(*arg)
+			arg = re.sub(r"(?<=, )aur (?=.+$)", "", str(arg))
+		if isinstance(arg, float):
+			arg = round(arg, 1)
+		if isinstance(arg, bool):
+			arg = "Han" if arg else "Nahi"
+		arg = str(arg)
+		if ", " in arg:
+			sub_args: list[str] = arg.split(", ")
+			for sub_arg in sub_args:
+				result.append(sub_arg)
+			continue
+		result.append(arg)
+	if len(result) < 2:
+		return ", ".join(result)
+	last: str = str(result.pop())
+	return ", ".join(result) + ", aur " + last
+jurewe = joined_words
+def split_into_words(s: str) -> list[str]:
+	if not isinstance(s, str) or not s.strip(): return ""
+	return re.findall(WORD_RE, s)
+find_words = findwords = to_words = towords = to_word_list = towordlist = pakro_words = pakrowords = pakro_alfaaz = pakroalfaaz = split_into_words
+def json_load(filename: str) -> dict | list:
+	if not isinstance(filename, str) or not filename.strip():
+		return {}
+	filename = os.path.normpath(filename)
+	if "." not in filename:
+		filename += ".json"
+	if not os.path.exists(filename):
+		return {}
+	contents: Any = {}
+	try:
+		with open(filename, mode="r") as file:
+			contents = json.load(file)
+	except Exception as e:
+		print(e)
+	# the loaded contents can be a list, too
+	# not always a dictionary
+	if isinstance(contents, dict) and "Obj" in globals():
+		contents = Obj(contents)
+	return contents
+load_json = loadjson = jsonload = json_load
+def replace(src: str, to_replace: str|dict|None = None, replacement: str|Callable = "", ignore_case: bool = False, case_insensitive: bool = False, count: int = IntInfinity) -> str:
+	if not src or not isinstance(src, str) or not ((isinstance(to_replace, str)) or (isinstance(to_replace, dict) and not replacement) or isinstance(replacement, (str, Callable))):
+		# allow empty replacement for removals
+		return ""
+	ignore_case = ignore_case or case_insensitive
+	if not ignore_case or not isinstance(ignore_case, bool):
+		ignore_case = False
+	if not isinstance(count, int) or count < 0:
+		count = IntInfinity
+	if isinstance(to_replace, str):
+		if not len(to_replace):
+			return src
+		if not re.search(r"[\(\)]", to_replace):
+			to_replace = f"({to_replace})"
+		to_replace = re.sub(r"(\?)(<\w+>)", r"\1P\2", to_replace)
+	if isinstance(replacement, str):
+		# if it's a string, rather than a callable---usually in the form of a lambda function
+		if re.search(r"[\$\\][&0]", replacement):
+			return src
+		replacement = re.sub(r"\$\{?(\d+)(\}(?!#{4}))?", r"\\\1", replacement) # the function sees and uses 4 hashes (####) as an escape sequence for a replacement regex group's closing brace
+		# achieve JavaScript-like numbered-group convention ^
+		replacement = re.sub(r"\$\{?([A-Za-z]\w*)(\}(?!#{4}))?", r"\\g<\1>", replacement) # the function sees and uses 4 hashes (####) as an escape sequence for a replacement regex group's closing brace
+		# achieve JavaScript-like named-group convention ^
+	flags: int = re.MULTILINE
+	if ignore_case:
+		flags |= re.IGNORECASE
+	result: str = ""
+	if not replacement and isinstance(to_replace, dict):
+		result = src
+		# for now
+		for key, value in to_replace.items():
+			if not key.strip():
+				continue
+			result = replace(result, key, value)
+		return result
+	if not isinstance(to_replace, str):
+		to_replace = ""
+	try:
+		result = re.sub(to_replace, replacement, src, flags=flags, count=count)
+	except re.error as e:
+		src_trunc: str = f"{src[:30]}... ..." if len(src) > 30 else src
+		print(f"re.warning:\n  * Bad regex, or replacement pattern '{to_replace}'. Returning the original source string '{src_trunc}' as-is. *Reason*: {str(e).capitalize()}.")
+		result = src
+	return result
+replacei = ireplace = replace_i = i_replace = functools.partial(replace, ignore_case=True)
+replaceone = replace_one = functools.partial(replace, count=1)
+replace_i_one = replace_one_i = replace_ione = replace_onei = replace_ins_first = replace_first_ins = replace_insfirst = functools.partial(replace, ignore_case=True, count=1)
+def find_matches(src: str, to_find: str) -> list[str]:
+	if not src or not isinstance(src, str) or not to_find or not isinstance(to_find, str):
+		return []
+	to_find = re.sub(r"(\?)(<\w+>)", r"\1P\2", to_find)
+	matches: list[str] = re.findall(to_find, src)
+	return matches
+def find_matches_i(src: str, to_find: str) -> list[str]:
+	if not src or not isinstance(src, str) or not to_find or not isinstance(to_find, str):
+		return []
+	to_find = re.sub(r"(\?)(<\w+>)", r"\1P\2", to_find)
+	matches: list[str] = re.findall(to_find, src, re.IGNORECASE)
+	return matches
+def find_matches_as_obj(src: str, to_find: str) -> obj[str, str]:
+	if not src or not isinstance(src, str) or not to_find or not isinstance(to_find, str):
+		return obj()
+	to_find = re.sub(r"(\?)(<\w+>)", r"\1P\2", to_find)
+	matches: obj[str, str] = obj()
+	if matches_found := re.search(to_find, src):
+		matches = matches_found.groupdict()
+	return matches
+def find_matches_as_obj_i(src: str, to_find: str) -> obj[str, str]:
+	if not src or not isinstance(src, str) or not to_find or not isinstance(to_find, str):
+		return obj()
+	to_find = re.sub(r"(\?)(<\w+>)", r"\1P\2", to_find)
+	matches: obj[str, str] = obj()
+	if matches_found := re.search(to_find, src, flags=re.IGNORECASE):
+		matches = matches_found.groupdict()
+	return matches
+def find_match(src: str, to_find: str) -> str:
+	if not src or not isinstance(src, str) or not to_find or not isinstance(to_find, str):
+		return ""
+	to_find = re.sub(r"(\?)(<\w+>)", r"\1P\2", to_find)
+	matches: list[str] = find_matches(src, to_find)
+	if len(matches) == 0:
+		return ""
+	return matches[0]
+def find_match_i(src: str, to_find: str) -> str:
+	if not src or not isinstance(src, str) or not to_find or not isinstance(to_find, str):
+		return ""
+	to_find = re.sub(r"(\?)(<\w+>)", r"\1P\2", to_find)
+	matches: list[str] = find_matches_i(src, to_find)
+	if len(matches) == 0 or not matches[0]:
+		return ""
+	return matches[0]
+def match(src: str, to_find: str) -> bool:
+	if not src or not isinstance(src, str) or not to_find or not isinstance(to_find, str):
+		return False
+	to_find = re.sub(r"(\?)(<\w+>)", r"\1P\2", to_find)
+	matches: list[str] = find_matches(src, to_find)
+	if len(matches) == 0:
+		return False
+	return True
+def match_i(src: str, to_find: str) -> bool:
+	if not src or not isinstance(src, str) or not to_find or not isinstance(to_find, str):
+		return False
+	to_find = re.sub(r"(\?)(<\w+>)", r"\1P\2", to_find)
+	matches: list[str] = find_matches_i(src, to_find)
+	if len(matches) == 0:
+		return False
+	return True
+hasmatch = has_match = match
+hasmatchi = has_match_i = match_i
+def find_words(src: Any) -> list[str]:
+	"""
+	@param			src
+		:type			Any
+		:description		the source to find the words from
+	@return			
+		:type										  list <blankable, if no words are found>
+		:description		a word list containing all the words from the object
+	"""
+	if not src:
+		return ""
+	src = str(src).strip()
+	word_list: list[str] = find_matches(src, r"(?:[A-Za-z]+\-)*[A-Za-z]+")
+	return word_list
+dhundo_alfaaz = dhundo_alfaz = words_of = to_words = find_words
+def startswith(x: str|list, y: str|list) -> bool:
+	if not isinstance(x, (str, list, tuple)):
+		return False
+	if isinstance_each([x, y], str):
+		try:
+			return re.search(f"^{y}", x)
+		except re.error as e:
+			print(f"re.warning:\n  * Bad regex. Switching to default `str.startswith` mode, now that the regex mode failed. *Reason*: {str(e).capitalize()}.")
+			return x.startswith(y)
+	elif isinstance(x, (list, tuple)):
+		if isinstance(x, tuple):
+			x = list(x)
+		if not isinstance(y, (list, tuple)):
+			y = [y]
+		if isinstance(y, tuple):
+			y = list(y)
+		if len(x) < len(y):
+			return False
+		return x[:len(y)] == y
+	return False
+starts_with = startswith
+def endswith(x: str|list, y: str|list) -> bool:
+	if not isinstance(x, (str, list, tuple)):
+		return False
+	if isinstance_each([x, y], str):
+		try:
+			return re.search(f"{y}$", x)
+		except re.error as e:
+			print(f"re.warning:\n  * Bad regex. Switching to default `str.endswith` mode, now that the regex mode failed. *Reason*: {str(e).capitalize()}.")
+			return x.endswith(y)
+	elif isinstance(x, (list, tuple)):
+		if isinstance(x, tuple):
+			x = list(x)
+		if not isinstance(y, (list, tuple)):
+			y = [y]
+		if isinstance(y, tuple):
+			y = list(y)
+		if len(x) < len(y):
+			return False
+		return x[-len(y):] == y
+	return False
+ends_with = endswith
+def upper(src: str) -> str:
+	if not isinstance(src, str):
+		return ""
+	result: str = src.upper()
+	return result
+def isupper(src: str) -> bool:
+	if not isinstance(src, str):
+		return False
+	return src.isupper()
+is_upper = isupper
+def lower(src: str) -> str:
+	if not isinstance(src, str):
+		return ""
+	result: str = src.lower()
+	return result
+def islower(src: str) -> bool:
+	if not isinstance(src, str):
+		return False
+	return src.islower()
+is_lower = islower
+def snake_case(src: str) -> str:
+	if not isinstance(src, str):
+		return ""
+	all_were_upper: bool = False
+	if src.upper() == src:
+		all_were_upper = True
+	result: str = src.casefold()
+	result = re.sub(r"[^\-\.\w\n]+", "_", result).strip("_")
+	if all_were_upper:
+		result = result.upper()
+	return result
+snakecase = snake_case
+def is_snake_case(src: str) -> bool:
+	if not isinstance(src, str):
+		return False
+	return src == snake_case(src)
+issnakecase = is_snakecase = is_snake_case
+def title_case(src: str) -> str:
+	if not isinstance(src, str):
+		return ""
+	result: str = src.title()
+	return result
+def is_title_case(src: str) -> bool:
+	if not isinstance(src, str):
+		return False
+	return src.istitle()
+istitle = is_title = istitlecase = is_titlecase = is_title_case
+def sentence_case(src: str) -> str:
+	if not isinstance(src, str):
+		return ""
+	result: str = src.capitalize()
+	return result
+sentcase = sent_case = sentence_case
+def is_sentence_case(src: str) -> bool:
+	if not isinstance(src, str):
+		return False
+	return src == sentence_case(src)
+issentcase = is_sentcase = is_sent_case = issentencecase = is_sentencecase = is_sentence_case
+class Money:
+	def __init__(self, amount=0, currency="Rs. "):
+		self.amount = amount if amount >= 0 else 0
+		self.currency = currency if currency and len(currency) <= 4 else "Rs. "
+	def set_currency(self, currency):
+		if currency and len(currency) <= 4:
+			self.currency = currency
+		return self
+	def set_amount(self, new_amount):
+		if new_amount >= 0:
+			self.amount = new_amount
+		return self
+	def add(self, *nums):
+		self.amount += sum(nums)
+		return self
+	def subtract(self, *nums):
+		self.amount -= sum(nums)
+		return self
+	def multiply(self, *nums):
+		for n in nums:
+			self.amount *= n
+		return self
+	def divide(self, *nums):
+		for n in nums:
+			if n == 0:
+				n = 1
+			self.amount /= n
+		return self
+	def __str__(self):
+		return f"{self.currency}{self.amount:.2f}"
+	def balance(self):
+		return str(self)
+class Pesa(Money):
+	def __init__(self, amount, currency):
+		super().__init__(amount, currency)
+pesa = Pesa
+def open_file_case_ins(filename: str, mode: str = 'r', **kwargs):
+	filename = str(filename)
+	if not mode or not isinstance(mode, str):
+		mode = "r"
+	if not filename or not os.path.isfile(filename):
+		raise FileNotFoundError(f"File '{filename}' doesn't exist")
+	directory, name = os.path.split(filename)
+	directory = directory or '.'  # Default to current directory if none specified
+	name_lower = name.lower()
+	for actual_file_name in os.listdir(directory):
+		if actual_file_name.lower() == name_lower:
+			actual_path = os.path.join(directory, actual_file_name)
+			if os.path.isfile(actual_path):
+				return open(actual_path, mode, **kwargs)
+open_case_ins = open_file_case_ins
+class File:
+	def __init__(self, path: Union[str, Path]):
+		self.pathname = Path(path)
+	def __str__(self) -> str:
+		return str(self.pathname)
+	def path(self) -> Path:
+		return self.pathname
+	def absolute_path(self) -> str:
+		return str(self.pathname.absolute())
+	def abs_path(self) -> str:
+		return self.absolute_path()
+	def is_file(self) -> bool:
+		return self.pathname.is_file()
+	def is_folder(self) -> bool:
+		return self.pathname.is_dir()
+	def exists(self) -> bool:
+		return self.pathname.exists()
+	def exists_file(self) -> bool:
+		return self.is_file() and self.exists()
+	def exists_folder(self) -> bool:
+		return self.is_folder() and self.exists()
+	mojud_file = mojud_he_file = he_mojud_file = found_file = exists_file
+	exists_directory = exists_dir = found_dir = mojud_folder = mojud_he_folder = he_mojud_folder = mojud_directory = mojud_he_directory = he_mojud_directory = exists_folder
+	mojud = mojud_he = he_mojud = found = exists_path = exists
+	@staticmethod
+	def create(fname: str, content: str = "") -> bool:
+		try:
+			if not fname or not content:
+				raise ValueError("File name, and content are required")
+			if re.search(r"(?<=\\w)\\s*[\\|\\+\\&\\,\\;]\\s*(?=\\w)", fname):
+				for subFileName in re.split(r"\\s*[\\|\\+\\&\\,\\;]\\s*", fname):
+					File.create(subFileName, content)
+				return True
+			with open(fname, 'w') as f:
+				f.write(content)
+			print(f"[KL.file.JobSuccess]:\nFile {fname} created successfully.")
+			return True
+		except ValueError as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		except PermissionError:
+			print(f"[KL.file.JobFailed]: Permission denied to create file {fname}")
+		except OSError as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		except Exception as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		return False
+	@staticmethod
+	def createBlankFile(fname: str) -> bool:
+		try:
+			if not fname:
+				raise ValueError("File name is required")
+			Path(fname).touch()
+			print(f"[KL.file.JobSuccess]:\nBlank file {fname} created successfully.")
+			return True
+		except ValueError as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		except PermissionError:
+			print(f"[KL.file.JobFailed]: Permission denied to create file {fname}")
+		except OSError as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		except Exception as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		return False
+	touch = createBlankFile
+	@staticmethod
+	def createFolder(folderName: str) -> bool:
+		try:
+			if not folderName:
+				raise ValueError("Folder name is required")
+			if re.search(r"(?<=\\w)\\s*[\\|\\+\\&\\,\\;]\\s*(?=\\w)", folderName):
+				for folder in re.split(r"\\s*[\\|\\+\\&\\,\\;]\\s*", folderName):
+					File.createFolder(folder)
+				return True
+			os.makedirs(folderName, exist_ok=True)
+			return True
+		except ValueError as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		except PermissionError:
+			print(f"[KL.file.JobFailed]: Permission denied to create folder {folderName}")
+		except OSError as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		except Exception as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		return False
+	@staticmethod
+	def read(fname: str) -> str:
+		try:
+			if not fname:
+				raise ValueError("File name is required")
+			with open_case_ins(fname, 'r') as f:
+				contents: str = f.read()
+				return contents
+		except ValueError as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		except FileNotFoundError:
+			print(f"[KL.file.JobFailed]: File {fname} does not exist")
+		except PermissionError:
+			print(f"[KL.file.JobFailed]: Permission denied to read file {fname}")
+		except OSError as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		except Exception as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		return ""
+	@staticmethod
+	def get_lines(fname: str) -> list[str]:
+		contents: str = File.read(fname)
+		lines: list[str] = []
+		if not contents.strip():
+			return False
+		if re.search(r"\n", contents):
+			split_content: list[str] = split(contents, r"\n")
+			for line in split_content:
+				lines.append(line)
+		else:
+			lines.append(contents)
+			# no lines found other than the first, append the contents as-is
+		return lines
+	readlines = read_lines = getlines = get_lines
+	@staticmethod
+	def readJson(fname: str) -> Optional[dict]:
+		try:
+			return json.loads(File.read(fname))
+		except json.JSONDecodeError as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		except Exception as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		return None
+	@staticmethod
+	def write(fname: str, content: str) -> bool:
+		try:
+			if not fname or not content:
+				raise ValueError("File name and content are required")
+			with open(fname, 'w') as f:
+				f.write(content)
+			print(f"[KL.file.JobSuccess]:\nFile {fname} written successfully.")
+			return True
+		except ValueError as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		except PermissionError:
+			print(f"[KL.file.JobFailed]: Permission denied to write to file {fname}")
+		except OSError as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		except Exception as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		return False
+	@staticmethod
+	def append(fname: str, content: str) -> bool:
+		try:
+			if not fname or not content:
+				raise ValueError("File name and content are required")
+			if re.search(r"(?<=\\w)\\s*[\\|\\+\\&\\,\\;]\\s*(?=\\w)", fname):
+				for subFileName in re.split(r"\\s*[\\|\\+\\&\\,\\;]\\s*", fname):
+					File.append(subFileName, content)
+				return True
+			with open(fname, 'a') as f:
+				f.write(content)
+			print(f"[KL.file.JobSuccess]:\nAppending to file {fname} was successful.")
+			return True
+		except ValueError as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		except PermissionError:
+			print(f"[KL.file.JobFailed]: Permission denied to append to file {fname}")
+		except OSError as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		except Exception as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		return False
+	@staticmethod
+	def delete(fname: str) -> bool:
+		try:
+			if not fname:
+				return
+			if re.search(r"(?<=\\w)\\s*[\\|\\+\\&\\,\\;]\\s*(?=\\w)", fname):
+				for subFileName in re.split(r"\\s*[\\|\\+\\&\\,\\;]\\s*", fname):
+					File.delete(subFileName)
+				return True
+			if os.path.isdir(fname):
+				shutil.rmtree(fname)
+			else:
+				os.remove(fname)
+			print(f"[KL.file.JobSuccess]:\nFile {fname} deleted successfully.")
+			return True
+		except FileNotFoundError:
+			print(f"[KL.file.JobFailed]: File {fname} does not exist")
+		except PermissionError:
+			print(f"[KL.file.JobFailed]: Permission denied to delete file {fname}")
+		except OSError as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		except Exception as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		return False
+	remove = delete
+	@staticmethod
+	def rename(fname: str, destinationString: str) -> bool:
+		try:
+			if not fname or not destinationString:
+				raise ValueError("File name and destination are required")
+			if re.search(r"(?<=\\w)\\s*[\\|\\+\\&\\,\\;]\\s*(?=\\w)", fname) and re.search(r"[\\\\\\/]", destinationString):
+				for subFileName in re.split(r"\\s*[\\|\\+\\&\\,\\;]\\s*", fname):
+					File.rename(subFileName, destinationString)
+				return True
+			os.replace(fname, destinationString)
+			print(f"[KL.file.JobSuccess]:\nFile {fname} was successfully moved/renamed to {destinationString}")
+			return True
+		except ValueError as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		except FileNotFoundError:
+			print(f"[KL.file.JobFailed]: File {fname} does not exist")
+		except PermissionError:
+			print(f"[KL.file.JobFailed]: Permission denied to rename file {fname}")
+		except OSError as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		except Exception as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		return False
+	move = rename
+	@staticmethod
+	def copy(from_path: str, to_path: str, overwrite: bool = True) -> bool:
+		try:
+			if not from_path or not to_path:
+				raise ValueError("Source and destination paths are required")
+			if re.search(r"(?<=\\w)\\s*[\\|\\+\\&\\,\\;]\\s*(?=\\w)", from_path):
+				for subFileName in re.split(r"\\s*[\\|\\+\\&\\,\\;]\\s*", from_path):
+					File.copy(subFileName, to_path, overwrite)
+				return True
+			shutil.copy2(from_path, to_path)
+			return True
+		except ValueError as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		except FileNotFoundError:
+			print(f"[KL.file.JobFailed]: File {from_path} does not exist")
+		except PermissionError:
+			print(f"[KL.file.JobFailed]: Permission denied to copy file {from_path}")
+		except OSError as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		except Exception as e:
+			print(f"[KL.file.JobFailed]: {e}")
+		return False
+file: File = File
+def encode(data: any) -> str:
+	try:
+			return base64.b64encode(str(data).encode()).decode()
+	except TypeError as e:
+			return ""
+def decode(data: str) -> str:
+	import binascii
+	try:
+			return base64.b64decode(data).decode()
+	except (TypeError, binascii.Error) as e:
+			return ""
+
+import time
+def time_it(fn):
+	if not callable(fn):
+		return 
+	def wrapper(*args, **kwargs):
+		start: float = timer.time()
+		return_value = fn(*args, **kwargs)
+		# if possible, get the return value
+		end: int = timer.time()
+		duration: int = end - start
+		print(f"@timeit:\n\tFunction `{fn.__name__}` took {duration:.3f} second(s) to fulfil its job")
+		return return_value
+	return wrapper
+def time_lia(fn):
+	if not callable(fn):
+		return 
+	def wrapper(*args, **kwargs):
+		start: float = timer.time()
+		return_value = fn(*args, **kwargs)
+		# if possible, get the return value
+		end: int = timer.time()
+		duration: int = end - start
+		print(f"@timelia:\n\tFunction `{fn.__name__}` ne apna kaam {duration:.1f} second(s) me kia")
+		return return_value
+	return wrapper
+timeme = time_me = timeit = time_it
+timelia = time_lia
+def internet_access() -> bool:
+	try:
+		requests.get("https://www.google.com", timeout=5)
+		return True
+	except requests.ConnectionError:
+		return False
+def fetch(url: str = "") -> dict|list:
+	if not url or not "requests" in globals():
+		return {}
+	try:
+		response = requests.get(url, timeout=60)
+		response.raise_for_status()
+		if not (response.status_code >= 200 and response.status_code <= 299):
+			return {}
+		return response.json()
+	except Exception as e:
+		print(f"Error fetching data: {e}")
+		return {}
+def filepath(to_filename: str) -> str:
+	if not isinstance(to_filename, str): 
+		return ""
+	if hasattr(sys, '_MEIPASS'):
+		base = Path(sys._MEIPASS)
+	elif getattr(sys, 'frozen', False):
+		base = Path(sys.executable).parent
+	else:
+		base = Path(__file__).resolve().parent
+	target = to_filename.strip().replace("\\", "/")
+	if target.startswith(".."):
+		if not (hasattr(sys, '_MEIPASS') or getattr(sys, 'frozen', False)):
+			base = base.parent
+		target = target[2:].lstrip("/")
+	else:
+		target = target.lstrip("/")
+	full_path: str = os.path.normpath(os.path.join(str(base), target))
+	# normalize the path, and make it cross-platform
+	return full_path
+file_path = get_path = to_path = path_to = ki_path = ki_location = ki_directory = filepath
+def asset(to_filename: str) -> str:
+	path: str = ""
+	try:
+		if either(hasattr(sys, '_MEIPASS'), getattr(sys, 'frozen', False)) and both("_filepaths" in globals(), "PROGRAMS_DIR" in dir(globals().get("_filepaths", {}))):
+			from _filepaths import PROGRAMS_DIR
+			path = os.path.join(PROGRAMS_DIR, to_filename)
+		else:
+			path = to_path(f"../{to_filename}")
+		# SEQUENCE IS MANDATORY
+		fallback_dirs: list[str] = [
+			f"../asset/{to_filename}",
+			f"../assets/{to_filename}",
+			f"../files/{to_filename}",
+			f"../data/{to_filename}",
+			f"../res/{to_filename}",
+			f"../resource/{to_filename}",
+			f"../resources/{to_filename}",
+			f"../____programs____/{to_filename}",
+			f"../____programs____/asset/{to_filename}",
+			f"../____programs____/assets/{to_filename}",
+			f"../____programs____/files/{to_filename}",
+			f"../____programs____/data/{to_filename}",
+			f"../____programs____/res/{to_filename}",
+			f"../____programs____/resource/{to_filename}",
+			f"../____programs____/resources/{to_filename}",
+			f"../_execute/{to_filename}",
+			f"../_execute/asset/{to_filename}",
+			f"../_execute/assets/{to_filename}",
+			f"../_execute/files/{to_filename}",
+			f"../_execute/data/{to_filename}",
+			f"../_execute/res/{to_filename}",
+			f"../_execute/resource/{to_filename}",
+			f"../_execute/resources/{to_filename}",
+			f"./{to_filename}",
+			f"./asset/{to_filename}",
+			f"./assets/{to_filename}",
+			f"./files/{to_filename}",
+			f"./data/{to_filename}",
+			f"./res/{to_filename}",
+			f"./resource/{to_filename}",
+			f"./resources/{to_filename}",
+			f"./____programs____/{to_filename}",
+			f"./____programs____/asset/{to_filename}",
+			f"./____programs____/assets/{to_filename}",
+			f"./____programs____/files/{to_filename}",
+			f"./____programs____/data/{to_filename}",
+			f"./____programs____/res/{to_filename}",
+			f"./____programs____/resource/{to_filename}",
+			f"./____programs____/resources/{to_filename}",
+			f"./_execute/{to_filename}",
+			f"./_execute/asset/{to_filename}",
+			f"./_execute/assets/{to_filename}",
+			f"./_execute/files/{to_filename}",
+			f"./_execute/data/{to_filename}",
+			f"./_execute/res/{to_filename}",
+			f"./_execute/resource/{to_filename}",
+			f"./_execute/resources/{to_filename}"
+		]
+		if not os.path.exists(path):
+			for fallback_dir in fallback_dirs:
+				fallback_dir = to_path(fallback_dir)
+				if os.path.exists(fallback_dir):
+					path = fallback_dir
+					break
+		return os.path.normpath(path)
+	except Exception as e:
+		return ""
+define_asset = to_asset = get_asset = new_asset = load_asset = naya_asset = asset
+## belongs at the bottom of KL_Py.py
+## a helper function for def= operator
+def get_initial_of(x: Any) -> Any:
+	if not x:
+		return None
+	out: Any
+	match x:
+		case "str":
+			out = ""
+		case "int":
+			out = 0 
+		case "flt" | "float" | "dbl" | "double" | "Number" | "nr":
+													  # a number is both a float, and int
+													  # lets just assume its a float
+			out = 0.0
+		case "bool" | "haal":
+			out = False
+		case "list":
+			out = []
+		case "tuple":
+			out = ()
+		case "set":
+			out = {}
+		case "Arr":
+			out = Arr()
+		case "numlist":
+			out = numlist()
+		case "intlist":
+			out = intlist()
+		case "fltlist":
+			out = fltlist()
+		case "dict" | "obj":
+			out = obj()
+		case _:
+			out = None
+	return out
+from hindGui import Text
+# ^ an overwrite fix
+# ^ needed
+# a helper constant for platform checks
+WINDOWS: Final[str] = "nt"
+INTERNAL_JSON: Final[str] = to_asset("json/")
+JSONS: Final[str] = INTERNAL_JSON
+def  json_load_internal(filename: str) -> dict | list:
+	if not isinstance(filename, str) or not filename.strip():
+		return {}
+	return json_load(to_asset(f"json/{filename}"))
+load_internal_json = loadinternaljson = jsonloadinternal = json_load_internal
+colors = COLORS = {}
+pakistani_names = PAKISTANI_NAMES = {}
+try:
+	colors = COLORS = load_internal_json("colors")
+	pakistani_names = PAKISTANI_NAMES = load_internal_json("pakistani_names")
+except Exception:
+	...
+
+
+
+
+if __name__ == "__main__":
+	print(Int("100", 2))
+	print(Flt("2.22"))
+	print(Int(2.22))
+	print(Flt(2.22))
+	print(Int(2))
+	print(Flt(2))
+	dictionary: obj = obj(key="value")
+	cloned = clone(dictionary)
+	cloned.key = 4
+	print(dictionary.entries())
+	print(cloned.entries())
+	name: lafz = "Misty"
+	print(name)
+	x: num = 4
+	print(x)
+	printf("$name dont! You are, but a $10+5-8 -year-old kid. $x")
+	print(isstr(""))
+	print(isint(3))
+	print(isflt(""))
+	print(isstr(None))
+	print(isstr(None))
+	print(isstr(None))
+	print(isstr(None))
+	print(isstr(None))
+	print(isstr(None))
+	print(isfunc(internet_access))
+	print(flatten([1, [2, [3, 4, [5, 6]]]]))
+	print(remove_duplicates([1, 3, 1, 5, 6, 3, 7, 8, 9]))
+	print(kism(7.5))
+	print(he_kism(7.5, float))
+	printf("hi, $75000.77778:,")
+	x = 12345.6789
+	print(f("$x", "$x:.2f", f"{x:,}", f"{x:,.2f}"))
+	array = intlist(1.4, 2.9, 3.5)
+	array2 = fltlist(2, 4, 6)
+	result = array * array2
+	print(result)
+	nlist: numlist = numlist(1, 3, 5, 7)
+	print(nlist.push([9, 11]))
+	array = Arr([1.2, 3, 5, 6, None, ""], fixed=False)
+	array.me_dalo("x")
+	array.me_dalo("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx0			xxx")
+	print(f"{array=}")
+	#pprint({"name": "Mike", "age": 17, "hobbies": ["horse riding", "country music", "farming"]})
+	print(Msg, Message, Error, Err)
+	@auto_id
+	@auto_class
+	class Book:
+		name: str
+		author: str
+		release: int
+	book1: Book = Book("To Kill A MockingBird", "Anonymous", 2003)
+	book2: Book = Book("The Subtle Art of Not Caring", "Mark Manson", 2007)
+	print(book1.name, book1.author, book1.release, book1.__id__, book1.__shanakht__)
+	print(book1.name, book1.author, book1.release, book1.__id__, book1.__shanakht__)
+	print(book2.name, book2.author, book2.release, book2.__id__, book2.__shanakht__)
+	print(book2.name, book2.author, book2.release, book2.__id__, book2.__shanakht__)
+	print(belongs_to(book1, Book))
+	print(isinstance_each([IOError, OSError], (Exception | BaseException)))
+	print(hissa(None, ["hello world", None]))
+	print(belongs_to(IOError | OSError, Exception))
+	print(chuno(rng(1, 10), koi=2))
+	my_dict: dict[str, dict[str, str] | int] = {"name": {"first": "Mike", "last": "Dawson"}, "age": 22000}
+	from _klang_builtins import cust_print
+	cust_print(my_dict)
+	print(deep_get(my_dict, "first"))
+	dt: Date = Date("2.44 am, Jan 24, 2002")
+	cust_print(dt.day_name(), dont_format_nums=True)
+	cust_print(dt.month_name(), dont_format_nums=True)
+	cust_print(dt.year(), dont_format_nums=True)
+	cust_print(dt.day_name(True), dont_format_nums=True)
+	cust_print(dt.month_name(True), dont_format_nums=True)
+	cust_print(dt.year(True), dont_format_nums=True)
+	dt.update(year=2021)
+	cust_print(dt.year(True), dont_format_nums=True)
+	print(Date("Jun 15 2026").is_weekend())
+	print(Date("Jun 15 2026").is_weekday())
+	print(obj(my_dict).ke("Name").mese("First", default="Anonymous"))
+	print(rng(10, 100, 10) [4-1])
+	print(Text, Bolo, Text == Bolo)
+	print(has_match("P@$$w0rd", STRICT_PWD_RE))
+	print(split_into_words("what a beautifully-crafted fun art, 'tisnit?"))
+	print(is_mail("abbaskhurram255@gmail.com"))
+	print(has_mail("abbaskhurram255@gmail.com 03012965459"))
+	print(catch_mail("abbaskhurram255@gmail.com 03012965459 abbaskhurram255@yahoo.com"))
+	print(catch_mail("abbaskhurram255@gmail.com 03012965459"))
+	print(catch_phone("abbaskhurram255@gmail.com 03012965459 abbaskhurram255@yahoo.com"))
+	print(is_pin(1535))
+	print(is_pin(153))
+	print(is_pin("1535"))
+	print(is_pin("153"))
+	print(ishex("#68fafe"))
+	countries: dict = load_json(r"json/countries.json")
+	print(countries)
+	arr = (1, 3.8, 7)
+	arr = _map(arr, str, lambda x: type(x) != float)
+	print(arr)
+	print(obj(my_dict).floor_key("NA"))
+	print(ltype(None))
+	print(ltype(Date()))
+	print(ltype(obj({1: "Lucien", 2: lambda: ...})))
+	print(ltype({"x": 1, "y": lambda: ...}))
+	print(ltype({"x": 1, "y": lambda: ...}))
+	print(ltype({"y": lambda: ...}))
+	print(ltype({"y": lambda: ...}))
+	print(ltype({"y": Book("x", "y", 2000)}))
+	print(ltype({"y": Book("x", "y", 2000)}))
+	print(rng("a", "z", shamil=Nahi))
+	print(rng(1, 10, inclusive=globals().get('shamil'.strip().replace(' ', '_').upper(), True)))
+	print(rng(1, 10, step=int('2' or '1'), inclusive=globals().get('shaamil akhri'.strip().replace(' ', '_').upper(), True)))
+	print(rng(1, 10, step=int('2' or '1'), inclusive=globals().get('bager akhri'.strip().replace(' ', '_').upper(), True)))
+	print(rng(1, 10, step=int('' or '1'), inclusive=globals().get('bager_akhri'.strip().replace(' ', '_').upper(), True)))
+	print(rng(20, step=.5, inclusive=globals().get(''.strip().replace(' ', '_').upper(), True)))
+	
+	# sucks >>
+	print("\n\nsucks:")
+	print(rng(20))
+	print("\n\n")
+	
+	print(rng(1, 10, step=float('2' or '1'), inclusive=globals().get('shaamil akhri'.strip().replace(' ', '_').upper(), True)))
+	print(rng(1, 10, step=float('2' or '1'), inclusive=globals().get('shaamil akhri'.strip().replace(' ', '_').upper(), True)))
+	print(rng(1, 10, step=float('' or '1'), inclusive=globals().get('bager akhri'.strip().replace(' ', '_').upper(), True)))
+	print(rng(1, 10, step=float('.5' or '1'), inclusive=globals().get(''.strip().replace(' ', '_').upper(), True)))
+	
+	print(rng('a', 'y', step=.5))
+	print(rng('w', 'y'))
+	print(rng(10))
+	print(rng(10, inclusive=FORCE_INCLUSIVE, step=float('2.5')))
+	
+	print(he_parsable_num("5.7"))
+	print(Flt("5.7"))
+	print(Int("5.7"))
+	
+	print(rng("b", "z", reverse=REVERSED, step=2))
+	print(rng(1, 44, step=float('5' or '1'), inclusive=globals().get('shamil akhri'.strip().replace(' ', '_').upper(), True), reverse=globals().get('nahi reverse'.strip().replace(' ', '_').upper(), False)))
+	print(rng(10, step=float('2' or '1'), inclusive=globals().get('shamil akhri'.strip().replace(' ', '_').upper(), True), reverse=globals().get('reverse'.strip().replace(' ', '_').upper(), False)))
+	print(rng(10, step=float('5' or '1'), inclusive=globals().get('zabardasti shamil akhri'.strip().replace(' ', '_').upper(), True), reverse=globals().get('reverse'.strip().replace(' ', '_').upper(), False)))
+	
+	print(rng('a', 'y', step=float('2' or '1'), inclusive=globals().get('shamil akhri'.strip().replace(' ', '_').upper(), True), reverse=globals().get(''.strip().replace(' ', '_').upper(), False)))
+	arr = rng(1, 10)
+	shuffle_inplace(arr)
+	print(arr)
+	colors["sub"] = {"sub2": {"sub3a": 15, "sub3b": 20, 8.3: 8.0}}
+	print(safe_get(colors, 8, default="Couldn't find"))
+	print(colors.sub.sub3B)
+	
+	print(Date("2026-07-22 12.01 am").day_nr())
+	print(Date("2026-07-22 12.01 am").time_and_day())
+	print(Date("2002-07-22 12.01 am").yr(2004).d(21).d(), nahi_format_nums=Han)
+	print(Date.day_today())