interpreter.py

import cmath, copy, functools, hashlib, itertools, locale, math, operator, re, sys, time

from .utils import attrdict, lazy_import

random, sympy, urllib_request = lazy_import('random sympy urllib.request')

code_page  = '''¡¢£¤¥¦©¬®µ½¿€ÆÇÐÑ×ØŒÞßæçðıȷñ÷øœþ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~¶'''
code_page += '''°¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾ƁƇƊƑƓƘⱮƝƤƬƲȤɓƈɗƒɠɦƙɱɲƥʠɼʂƭʋȥẠḄḌẸḤỊḲḶṂṆỌṚṢṬỤṾẈỴẒȦḂĊḊĖḞĠḢİĿṀṄȮṖṘṠṪẆẊẎŻạḅḍẹḥịḳḷṃṇọṛṣṭ§Äẉỵẓȧḃċḋėḟġḣŀṁṅȯṗṙṡṫẇẋẏż«»‘’“”'''

# Unused symbols for single-byte atoms/quicks: (quƁƘȤɦɱɲƥʠʂȥḥḳṇẉỵẓėġṅẏ

str_digit = '0123456789'
str_lower = 'abcdefghijklmnopqrstuvwxyz'
str_upper = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

inf = float('inf')
nan = float('nan')
sys.setrecursionlimit(1 << 30)

def arities(links):
	return [link.arity for link in links]

def at_index(index, array):
	array = iterable(array)
	if not array:
		return 0
	low_index = math.floor(index) - 1
	high_index = math.ceil(index) - 1
	if low_index == high_index:
		return array[low_index % len(array)]
	return [array[low_index % len(array)], array[high_index % len(array)]]

def at_index_ndim(indices, array):
	retval = array
	for index in indices:
		retval = at_index(index, retval)
	return retval

def base_decompression(integer, digits):
	digits = iterable(digits, make_range=True)
	return [digits[i-1] for i in to_base(integer, len(digits))]

def bounce(array):
	return array[:-1] + array[::-1]

def carmichael(n):
	n = int(n)
	if n < 1:
		return 0
	c = 1
	for p, k in sympy.ntheory.factor_.factorint(n).items():
		c = lcm(c, 2 ** (k - 2) if p == 2 < k else (p - 1) * p ** (k - 1))
	return c

def create_chain(chain, arity = -1, isForward = True):
	return attrdict(
		arity = arity,
		chain = chain,
		call = lambda x = None, y = None: variadic_chain(chain, isForward and (x, y) or (y, x))
	)

def create_literal(string):
	return attrdict(
		arity = 0,
		call = lambda: python_eval(string, False)
	)

def conv_dyadic_integer(link, larg, rarg):
	try:
		iconv_larg = int(larg)
		try:
			iconv_rarg = int(rarg)
			return link(iconv_larg, iconv_rarg)
		except:
			return iconv_larg
	except:
		try:
			return int(rarg)
		except:
			return 0

def conv_monadic_integer(link, arg):
	try:
		return link(int(arg))
	except:
		return 0

def convolve(left, right):
	left, right = iterable(left, make_range = True), iterable(right, make_range = True)
	result = [0]*(len(left)+len(right)-1)
	for i,x in enumerate(left):
		for j,y in enumerate(right):
			result[i+j] += x*y
	return result

def convolve_power(polynomial, exponent):
	retval = [1]
	for _ in range(exponent):
		retval = convolve(retval, polynomial)
	return retval

def copy_to(atom, value):
	atom.call = lambda: value
	return value

def determinant(matrix):
	matrix = sympy.Matrix(matrix)
	if matrix.is_square:
		return simplest_number(matrix.det())
	return simplest_number(math.sqrt((matrix * matrix.transpose()).det()))

def div(dividend, divisor, floor = False):
	if divisor == 0:
		return dividend * inf
	if divisor == inf:
		return 0
	if floor or (type(dividend) == int and type(divisor) == int and not dividend % divisor):
		return int(dividend // divisor)
	return dividend / divisor

def depth(link):
	if type(link) != list:
		return 0
	if not link:
		return 1
	return 1 + max(map(depth, link))

def diagonals(matrix):
	shifted = [None] * len(matrix)
	for index, row in enumerate(map(iterable, reversed(matrix))):
		shifted[~index] = index * [None] + row
	return rotate_left(zip_ragged(shifted), len(matrix) - 1)

def distinct_sieve(array):
	array = iterable(array, make_digits = True)
	result = []
	for (i, x) in enumerate(array):
		result.append(1 if i == array.index(x) else 0)
	return result

def dot_product(left, right, truncate = False):
	left, right = iterable(left), iterable(right)
	if complex in map(type, left + right):
		right = [complex(t).conjugate() for t in right]
	if truncate:
		product = sum(map(operator.mul, left, right))
	else:
		product = sum(dyadic_link(atoms['×'], (left, right)))
	if product.imag == 0:
		product = product.real
		if type(product) != int and product.is_integer():
			product = int(product)
	return product

def dyadic_chain(chain, args):
	larg, rarg = args
	for link in chain:
		if link.arity < 0:
			link.arity = 2
	if chain and arities(chain[0:3]) == [2, 2, 2]:
		ret = dyadic_link(chain[0], args)
		chain = chain[1:]
	elif leading_nilad(chain):
		ret = niladic_link(chain[0])
		chain = chain[1:]
	else:
		ret = larg
	while chain:
		if arities(chain[0:3]) == [2, 2, 0] and leading_nilad(chain[2:]):
			ret = dyadic_link(chain[1], (dyadic_link(chain[0], (ret, rarg)), niladic_link(chain[2])))
			chain = chain[3:]
		elif arities(chain[0:2]) == [2, 2]:
			ret = dyadic_link(chain[0], (ret, dyadic_link(chain[1], args)))
			chain = chain[2:]
		elif arities(chain[0:2]) == [2, 0]:
			ret = dyadic_link(chain[0], (ret, niladic_link(chain[1])))
			chain = chain[2:]
		elif arities(chain[0:2]) == [0, 2]:
			ret = dyadic_link(chain[1], (niladic_link(chain[0]), ret))
			chain = chain[2:]
		elif chain[0].arity == 2:
			ret = dyadic_link(chain[0], (ret, rarg))
			chain = chain[1:]
		elif chain[0].arity == 1:
			ret = monadic_link(chain[0], ret)
			chain = chain[1:]
		else:
			output(ret)
			ret = niladic_link(chain[0])
			chain = chain[1:]
	return ret

def dyadic_link(link, args, conv = True, lflat = False, rflat = False):
	larg, rarg = args
	lflat = lflat or not hasattr(link, 'ldepth')
	rflat = rflat or not hasattr(link, 'rdepth')
	larg_depth = lflat or depth(larg)
	rarg_depth = rflat or depth(rarg)
	if (lflat or link.ldepth == larg_depth) and (rflat or link.rdepth == rarg_depth):
		if conv and hasattr(link, 'conv'):
			return link.conv(link.call, larg, rarg)
		return link.call(larg, rarg)
	conv = conv and hasattr(link, 'conv')
	if not lflat and larg_depth < link.ldepth:
		return dyadic_link(link, ([larg], rarg))
	if not rflat and rarg_depth < link.rdepth:
		return dyadic_link(link, (larg, [rarg]))
	if not rflat and (lflat or larg_depth - rarg_depth < link.ldepth - link.rdepth):
		return [dyadic_link(link, (larg, y)) for y in rarg]
	if not lflat and (rflat or larg_depth - rarg_depth > link.ldepth - link.rdepth):
		return [dyadic_link(link, (x, rarg)) for x in larg]
	return [dyadic_link(link, (x, y)) for x, y in zip(*args)] + larg[len(rarg) :] + rarg[len(larg) :]

def enumerate_md(array, upper_level = []):
	for i, item in enumerate(array):
		if type(item) != list:
			yield [upper_level + [i + 1], item]
		else:
			yield from enumerate_md(item, upper_level + [i + 1])

def equal(array):
	array = iterable(array)
	return int(all(item == array[0] for item in array))

def extremes(min_or_max, link, array):
	x,y = array
	x = iterable(x, make_range=True)
	if not x:
		return []
	results = [variadic_link(link, (t, y)) for t in x]
	best = min_or_max(results)
	return [t for t, ft in zip(x, results) if ft == best]

def filter_array(sand, mesh, is_in = True):
	mesh = {repr(element) for element in iterable(mesh)}
	return [element for element in iterable(sand) if (repr(element) in mesh) == is_in]

def flatten(argument):
	flat = []
	if type(argument) == list:
		for item in argument:
			flat += flatten(item)
	else:
		flat.append(argument)
	return flat

def foldl(*args):
	return reduce(*args, arity = 2)

def from_base(digits, base):
	integer = 0
	for digit in digits:
		integer = base * integer + digit
	return integer

def from_diagonals(diagonals):
	upper_right = 1
	while len(diagonals[upper_right - 1]) > 1:
		upper_right += 1
	diagonals = rotate_left(diagonals, upper_right)
	shift = len(diagonals) - upper_right
	index = 0
	while shift:
		diagonals[index] = shift * [None] + diagonals[index]
		index += 1
		shift -= 1
	return zip_ragged(diagonals)

def from_exponents(exponents):
	integer = 1
	for index, exponent in enumerate(exponents):
		integer *= sympy.ntheory.generate.prime(index + 1) ** exponent
	return integer

def from_factorial_base(digits):
	placeValue = 1
	integer = 0
	for nextPlaceIndex, digit in enumerate(digits[::-1], 1):
		integer += digit * placeValue
		placeValue *= nextPlaceIndex
	return integer

def from_primorial_base(digits):
	integer = digits and digits[-1] or 0
	for placeIndex, digit in enumerate(digits[-2::-1], 1):
		integer += digit * sympy.ntheory.generate.primorial(placeIndex)
	return integer

def simplest_number(number):
	if abs(number ** 2) != number ** 2:
		return number
	if number % 1:
		return float(number)
	return int(number)

def get_request(url):
	url = ''.join(map(str, url))
	url = (re.match(r"[A-Za-z][A-Za-z0-9+.-]*://", url) == None and "http://" or "") + url
	response = urllib_request.request.urlopen(url).read()
	try:
		return list(response.decode('utf-8'))
	except:
		return list(response.decode('latin-1'))

def grid(array):
	if depth(array) == 1:
		return join(array, ' ')
	if depth(array) == 2 and equal(map(len, array)):
		array = [[str(entry) for entry in row] for row in array]
		width = max(max([len(entry) for entry in row]) if row else 0 for row in array)
		array = [[list(entry.rjust(width)) for entry in row] for row in array]
		return join([join(row, ' ') for row in array], '\n')
	if depth(array) == 3 and all(type(item) == str for item in flatten(array)):
		array = [[''.join(entry) for entry in row] for row in array]
		width = max(max([len(entry) for entry in row]) if row else 0 for row in array)
		array = [[list(entry.ljust(width)) for entry in row] for row in array]
		return join([join(row, ' ') for row in array], '\n')
	return join(array, '\n')

def group(array):
	array = iterable(array, make_digits = True)
	grouped = {}
	for index, item in enumerate(array):
		item = repr(item)
		if item in grouped:
			grouped[item].append(index + 1)
		else:
			grouped[item] = [index + 1]
	try:
		return [grouped[key] for key in sorted(grouped, key = eval)]
	except TypeError:
		return [grouped[key] for key in sorted(grouped)]

def group_md(array):
	array = iterable(array, make_digits = True)
	grouped = {}
	for index, item in enumerate_md(array):
		item = repr(item)
		if item in grouped:
			grouped[item].append(index)
		else:
			grouped[item] = [index]
	try:
		return [grouped[key] for key in sorted(grouped, key = eval)]
	except TypeError:
		return [grouped[key] for key in sorted(grouped)]

def group_equal(array):
	array = iterable(array, make_digits = True)
	groups = []
	for x in array:
		if groups and groups[-1][0] == x:
			groups[-1].append(x)
		else:
			groups.append([x])
	return groups

def group_lengths(array):
	array = iterable(array, make_digits = True)
	lengths = []
	previous_item = None
	for x in array:
		if lengths and previous_item == x:
			lengths[-1] += 1
		else:
			lengths.append(1)
		previous_item = x
	return lengths

def identity(argument):
	return argument

def iterable(argument, make_copy = False, make_digits = False, make_range = False):
	the_type = type(argument)
	if the_type == list:
		return copy.deepcopy(argument) if make_copy else argument
	if the_type != str and make_digits:
		return to_base(argument, 10)
	if the_type != str and make_range:
		return list(range(1, int(argument) + 1))
	return [argument]

def index_of(haystack, needle):
	for index, item in enumerate(iterable(haystack)):
		if item == needle:
			return 1 + index
	return 0

def index_of_md(haystack, needle):
	for index, item in enumerate_md(haystack):
		if item == needle:
			return index
	return []

def indices_md(array, upper_level = []):
	a_indices = []
	for i, item in enumerate(array):
		if type(item) != list:
			a_indices.append(upper_level + [i + 1])
		else:
			a_indices.extend(indices_md(item, upper_level = upper_level + [i + 1]))
	return a_indices

def isqrt(number):
	a = number
	b = (a + 1) // 2
	while b < a:
		a = b
		b = (a + number // a) // 2
	return int(a)

def is_palindrome(argument):
	argument = iterable(argument, make_digits = True)
	return int(argument == argument[::-1])

def is_string(argument):
	if type(argument) != list:
		return False
	return all(map(lambda t: type(t) == str, argument))

def jelly_eval(code, arguments):
	return variadic_chain(parse_code(code)[-1] if code else '', arguments)

def jelly_hash(spec, object):
	if len(spec) > 2:
		spec = [spec[0], spec[1:]]
	if type(spec[0]) == list:
		digits = [code_page.find(item) if type(item) == str else item for item in spec[0]]
		magic = from_base([digit + 1 for digit in digits], 250) + 1
	else:
		magic = spec[0] + 1

	buckets = spec[1] if type(spec[1]) == list else range(1, spec[1] + 1)

	shake = hashlib.shake_256(repr(object).encode('utf-8')).digest(512)
	longs = [int.from_bytes(shake[i : i + 8], 'little') for i in range(0, 512, 8)]
	temp = sum(((magic >> i) - (magic >> i + 1)) * longs[i] for i in range(64))
	hash = temp % 2**64 * len(buckets) >> 64
	return buckets[hash - 1]

def jelly_uneval(argument, top = True):
	the_type = type(argument)
	if the_type in (float, int):
		return jelly_uneval_real(argument)
	if the_type == complex:
		return jelly_uneval_real(argument.real) + 'ı' + jelly_uneval_real(argument.imag)
	if the_type == str:
		return '”' + argument
	if all(map(is_string, argument)):
		strings = [''.join(string) for string in argument]
		if all(map(lambda t: code_page.find(t) < 250, ''.join(strings))):
			return '“' + '“'.join(strings) + '”'
	if is_string(argument):
		string = ''.join(argument)
		if all(map(lambda t: code_page.find(t) < 250, string)):
			return '“' + string + '”'
	middle = ','.join(jelly_uneval(item, top = False) for item in argument)
	return middle if top else '[' + middle + ']'

def jelly_uneval_real(number):
	string = str(number if number % 1 else int(number))
	return string.lstrip('0') if number else string

def jellify(element, dirty = False):
	if element is None:
		return []
	if type(element) == str and dirty:
		return list(element)
	if type(element) in (int, float, complex) or (type(element) == str and len(element) == 1):
		return element
	try:
		return [jellify(item, dirty) for item in element]
	except:
		if element.is_integer:
			return int(element)
		if element.is_real:
			return float(element)
		return complex(element)

def join(array, glue):
	array = iterable(array, make_copy = True)
	last = array.pop() if array else []
	glue = iterable(glue)
	ret = []
	for item in array:
		ret += iterable(item) + glue
	return ret + iterable(last)

def last_input():
	if len(sys.argv) > 3:
		return python_eval(sys.argv[-1])
	return python_eval(input())

def leading_nilad(chain):
	return chain and arities(chain) + [1] < [0, 2] * len(chain)

def lcm(x, y):
	return x * y // (math.gcd(x, y) or 1)

def loop_until_loop(link, args, return_all = False, return_loop = False, vary_rarg = True):
	ret, rarg = args
	cumret = []
	while True:
		cumret.append(ret)
		larg = ret
		ret = variadic_link(link, (larg, rarg))
		if vary_rarg:
			rarg = larg
		if ret in cumret:
			if return_all:
				return cumret
			if return_loop:
				return cumret[index_of(cumret, ret) - 1 :]
			return larg

def nfind(links, args):
	larg, rarg = args
	larg = larg or 0
	matches = variadic_link(links[1], args) if len(links) == 2 else last_input()
	found = []
	while len(found) < matches:
		if variadic_link(links[0], (larg, rarg)):
			found.append(larg)
		larg += 1
	return found

def matrix_to_list(matrix):
	return [[simplest_number(entry) for entry in row] for row in matrix.tolist()]

def max_arity(links):
	return max(arities(links)) if min(arities(links)) > -1 else (~max(arities(links)) or -1)

def maximal_indices(iterable):
	maximum = max(iterable or [0])
	return [u + 1 for u, v in enumerate(iterable) if v == maximum]

def maximal_indices_md(iterable, upper_level = [], maximum = None):
	if maximum == None:
		maximum = max(flatten(iterable) or [0])
	result = []
	for i, item in enumerate(iterable):
		if type(item) != list:
			if item == maximum:
				result.append(upper_level + [i + 1])
		else:
			result.extend(maximal_indices_md(item, upper_level = upper_level + [i + 1], maximum = maximum))
	return result

def median(array):
	array = sorted(array)
	return div(array[(len(array) - 1) // 2] + array[len(array) // 2], 2)

def mode(array):
	frequencies = {}
	maxfreq = 0
	retval = []
	for element in array:
		string = repr(element)
		frequencies[string] = frequencies.get(string, 0) + 1
		maxfreq = max(frequencies[string], maxfreq)
	for element in array:
		string = repr(element)
		if frequencies[string] == maxfreq:
			retval.append(element)
			frequencies[string] = 0
	return retval

def modinv(a, m):
	i, _, g = sympy.numbers.igcdex(a, m)
	return i % m if g == 1 else 0

def modulus(dividend, divisor):
	try:
		return dividend % divisor
	except:
		return nan

def mold(content, shape):
	for index in range(len(shape)):
		if type(shape[index]) == list:
			mold(content, shape[index])
		else:
			item = content.pop(0)
			shape[index] = item
			content.append(item)
	return shape

def monadic_chain(chain, arg):
	init = True
	ret = arg
	larg_save = atoms['⁸'].call
	while True:
		if init:
			for link in chain:
				if link.arity < 0:
					link.arity = 1
			if leading_nilad(chain):
				ret = niladic_link(chain[0])
				chain = chain[1:]
			init = False
		if not chain:
			break
		if arities(chain[0:2]) == [2, 1]:
			ret = dyadic_link(chain[0], (ret, monadic_link(chain[1], arg)))
			chain = chain[2:]
		elif arities(chain[0:2]) == [2, 0]:
			ret = dyadic_link(chain[0], (ret, niladic_link(chain[1])))
			chain = chain[2:]
		elif arities(chain[0:2]) == [0, 2]:
			ret = dyadic_link(chain[1], (niladic_link(chain[0]), ret))
			chain = chain[2:]
		elif chain[0].arity == 2:
			ret = dyadic_link(chain[0], (ret, arg))
			chain = chain[1:]
		elif chain[0].arity == 1:
			if not chain[1:] and hasattr(chain[0], 'chain'):
				arg = ret
				chain = chain[0].chain
				atoms['⁸'].call = lambda literal = arg: literal
				init = True
			else:
				ret = monadic_link(chain[0], ret)
				chain = chain[1:]
		else:
			output(ret)
			ret = niladic_link(chain[0])
			chain = chain[1:]
	atoms['⁸'].call = larg_save
	return ret

def monadic_link(link, arg, flat = False, conv = True):
	flat = flat or not hasattr(link, 'ldepth')
	arg_depth = flat or depth(arg)
	if flat or link.ldepth == arg_depth:
		if conv and hasattr(link, 'conv'):
			return link.conv(link.call, arg)
		return link.call(arg)
	conv = conv and hasattr(link, 'conv')
	if link.ldepth > arg_depth:
		return monadic_link(link, [arg], conv = conv)
	return [monadic_link(link, z, conv = conv) for z in arg]

def multiset_difference(left, right):
	result = iterable(left)[::-1]
	for element in iterable(right):
		if element in result:
			result.remove(element)
	return result[::-1]

def multiset_intersect(left, right):
	right = iterable(right, make_copy = True)
	result = []
	for element in iterable(left):
		if element in right:
			result.append(element)
			right.remove(element)
	return result

def multiset_symdif(left, right):
	return multiset_union(multiset_difference(left, right), multiset_difference(right, left))

def multiset_union(left, right):
	return iterable(left) + multiset_difference(right, left)

def nCr(left, right):
	if type(left) == int and type(right) == int:
		if right < 0:
			right = left - right
		if right < 0 or (left > 0 and right > left):
			return 0
		if left > 0:
			right = min(right, left - right)
		result = 1
		for i in range(right):
			result = result * (left - i) // (i + 1)
		return result
	return div(Pi(left), Pi(left - right) * Pi(right))

def niladic_chain(chain):
	while len(chain) == 1 and hasattr(chain[0], 'chain'):
		chain = chain[0].chain
	if not chain or chain[0].arity > 0:
		return monadic_chain(chain, 0)
	return monadic_chain(chain[1:], chain[0].call())

def niladic_link(link):
	return link.call()

def ntimes(links, args, cumulative = False):
	ret, rarg = args
	repetitions = variadic_link(links[1], args) if len(links) == 2 else last_input()
	repetitions = overload((int, bool), repetitions)
	if cumulative:
		cumret = [0] * repetitions
	for index in range(repetitions):
		if cumulative:
			cumret[index] = ret
		larg = ret
		ret = variadic_link(links[0], (larg, rarg))
		rarg = larg
	return cumret + [ret] if cumulative else ret

def odd_even(array):
	array = iterable(array, make_range = True)
	return [[t for t in array[::2]], [t for t in array[1::2]]]

def order(number, divisor):
	if number == 0 or abs(divisor) == 1:
		return inf
	if divisor == 0:
		return 0
	ret = 0
	while True:
		number, residue = divmod(number, divisor)
		if residue:
			break
		ret += 1
	return ret

def overload(operators, *args):
	for operator in operators:
		try:
			ret = operator(*args)
		except:
			pass
		else:
			return ret

def integer_partitions(n, I=1):
	result = [[n,]]
	for i in range(I, n//2 + 1):
		for p in integer_partitions(n-i, i):
			result.append([i,] + p)
	return result

def neighbors(links, array):
	array = iterable(array, make_digits = True)
	chain = dyadic_chain if links[-1].arity == 2 else monadic_chain
	return [chain(links, list(pair)) for pair in zip(array, array[1:])]

def partitions(array):
	array = iterable(array, make_digits = True)
	ret = []
	for index in range(1, len(array)):
		for subarray in partitions(array[index:]):
			subarray.insert(0, array[:index])
			ret.append(subarray)
	ret.append([array])
	return ret

def parse_code(code):
	lines = regex_flink.findall(code)
	links = [[] for line in lines]
	for index, line in enumerate(lines):
		chains = links[index]
		for word in regex_chain.findall(line):
			chain = []
			arity, start, isForward = chain_separators.get(word[:1], default_chain_separation)
			for token in regex_token.findall(start + word):
				if token in atoms:
					chain.append(atoms[token])
				elif token in quicks:
					popped = []
					while not quicks[token].condition(popped) and (chain or chains):
						popped.insert(0, chain.pop() if chain else chains.pop())
					chain += quicks[token].quicklink(popped, links, index)
				elif token in hypers:
					x = chain.pop() if chain else chains.pop()
					chain.append(hypers[token](x, links))
				else:
					chain.append(create_literal(regex_liter.sub(parse_literal, token)))
			chains.append(create_chain(chain, arity, isForward))
	return links

def parse_literal(literal_match):
	literal = literal_match.group(0)
	if literal[0] in '”⁾':
		return repr(literal[1:].replace('¶', '\n'))
	elif literal[0] == '“':
		if literal[-1] in '«»‘’”':
			mode = literal[-1]
			literal = literal[:-1]
		else:
			mode = ''
		parsed = literal.split('“')[1:]
		if   mode == '»':
			parsed = [sss(string).replace('¶', '\n') for string in parsed]
		elif mode == '‘':
			parsed = [[code_page.find(char) for char in string] for string in parsed]
		elif mode == '’':
			parsed = [from_base([code_page.find(char) + 1 for char in string], 250) for string in parsed]
		else:
			parsed = [string.replace('¶', '\n') for string in parsed]
		if mode not in '‘’':
			parsed = [[string] if len(string) == 1 else string for string in parsed]
		if len(parsed) == 1:
			parsed = parsed[0]
	elif literal[0] == '⁽':
		parsed = from_base([code_page.find(char) + 1 for char in literal[1:]], 250)
		parsed += parsed > 31500 and -62850 or 750
	else:
		parsed = eval('+ 1j *'.join([
			repr(eval('* 10 **'.join(['-1' if part == '-' else (part + '5' if part[-1:] == '.' else part) or repr(2 * index + 1)
			for index, part in enumerate(component.split('ȷ'))])) if component else index)
			for index, component in enumerate(literal.split('ı'))
		]))
	return repr(parsed) + ' '

def partition_at(booleans, array, border = 1):
	booleans = iterable(booleans)
	array = iterable(array)
	chunks = [[], []]
	index = 0
	while index < len(array):
		if index < len(booleans) and booleans[index]:
			chunks.append([])
			chunks[-border].append(array[index])
		else:
			chunks[-1].append(array[index])
		index += 1
	return chunks[1:]

def pemutation_at_index(index, array = None):
	result = []
	if array is None:
		divisor = 1
		count = 0
		while divisor < index:
			count += 1
			divisor *= count
		values = list(range(1, count + 1))
	else:
		values = iterable(array, make_copy = True, make_range = True)
		try:
			divisor = math.factorial(len(values))
		except:
			divisor = functools.reduce(operator.mul, range(1, len(values) + 1), 1)
	index -= 1
	index %= divisor
	while values:
		divisor //= len(values)
		quotient, index = divmod(index, divisor)
		result.append(values.pop(quotient))
	return result

def permutation_index(array):
	result = 1
	array = iterable(array)
	length = len(array)
	for index in range(length):
		k = sum(1 for value in array[index + 1:] if value < array[index])
		try:
			factor = math.factorial(length - index - 1)
		except:
			factor = functools.reduce(operator.mul, range(1, length - index), 1)
		result += k * factor
	return result

def Pi(number):
	if type(number) == int:
		if number < 0:
			return inf
		try:
			return math.factorial(number)
		except:
			return functools.reduce(operator.mul, range(1, number + 1), 1)
	return math.gamma(number + 1)

def powerset(array):
	array = iterable(array, make_range = True)
	ret = []
	for t in range(len(array) + 1):
		ret += jellify(itertools.combinations(array, t))
	return ret

def prefix(links, outmost_links, index):
	ret = [attrdict(arity = max(1, links[0].arity))]
	if len(links) == 1:
		ret[0].call = lambda x, y = None: [variadic_link(links[0], (t, y)) for t in split_prefix(x)]
	else:
		ret[0].call = lambda x, y = None: [variadic_link(links[0], (t, y)) for t in split_rolling(x, niladic_link(links[1]))]
	return ret

def primerange(start, end):
	if start > end:
		return list(sympy.primerange(end, start + 1))[::-1]
	else:
		return list(sympy.primerange(start, end + 1))

def python_eval(string, dirty = True):
	try:
		return jellify(eval(string), dirty)
	except SyntaxError:
		exec(string)
		return []

def quickchain(arity, min_length):
	return attrdict(
		condition =
			(lambda links: len(links) >= min_length and links[0].arity == 0)
			if arity == 0 else
			lambda links:
				len(links) - sum(map(leading_nilad, split_suffix(links)[:-1])) >= min_length,
		quicklink = lambda links, outmost_links, index: [attrdict(
			arity = arity,
			call = lambda x = None, y = None: variadic_chain(links, (x, y))
		)]
	)

def random_int(pool):
	if not pool:
		return 0
	if type(pool) == list:
		return random.choice(pool)
	return random.randint(1, pool)

def reduce(links, outmost_links, index, arity = 1):
	ret = [attrdict(arity = arity)]
	if len(links) == 1:
		ret[0].call = lambda x, *y: reduce_simple(x, links[0], *y)
	else:
		ret[0].call = lambda x, *y: [reduce_simple(t, links[0], *y) for t in split_fixed(iterable(x), links[1].call())]
	return ret

def reduce_simple(array, link, *init):
	array = iterable(array)
	return functools.reduce(lambda x, y: dyadic_link(link, (x, y)), array, *init)

def reduce_cumulative(links, outmost_links, index):
	ret = [attrdict(arity = 1)]
	if len(links) == 1:
		ret[0].call = lambda t: list(itertools.accumulate(iterable(t), lambda x, y: dyadic_link(links[0], (x, y))))
	else:
		ret[0].call = lambda z: [reduce_simple(t, links[0]) for t in split_rolling(iterable(z), links[1].call())]
	return ret

def rld(runs):
	return list(itertools.chain(*[[u] * v for u, v in runs]))

def rle(array):
	return [[group[0], len(group)] for group in group_equal(array)]

def rotate_left(array, units):
	array = iterable(array)
	length = len(array)
	return array[units % length :] + array[: units % length] if length else []

def shift_left(number, bits):
	if type(number) == int and type(bits) == int:
		return number << bits
	return number * 2 ** bits

def shift_right(number, bits):
	if type(number) == int and type(bits) == int:
		return number >> bits
	return div(number, 2 ** bits, floor = True)

def shuffle(array):
	array = iterable(array, make_copy = True, make_range = True)
	random.shuffle(array)
	return array

def sparse(link, args, indices, indices_literal = False):
	larg = args[0]
	if not indices_literal:
		indices = iterable(variadic_link(indices, args))
	indices = [index - 1 if index > 0 else index - 1 + len(larg) for index in indices]
	ret = iterable(variadic_link(link, args))
	return [ret[t % len(ret)] if t in indices else u for t, u in enumerate(larg)]

def split_around(array, needle):
	chunk = []
	window = len(needle)
	index = 0
	while index < len(array):
		if array[index : index + window] == needle:
			yield chunk
			chunk = []
			index += window
		else:
			chunk.append(array[index])
			index += 1
	yield chunk

def split_at(array, needle):
	chunk = []
	for element in array:
		if element == needle:
			yield chunk
			chunk = []
		else:
			chunk.append(element)
	yield chunk

def split_evenly(array, chunks):
	array = iterable(array)
	min_width, overflow = divmod(len(array), chunks)
	ret = []
	high = 0
	for index in range(chunks):
		low = high
		high = low + min_width + (index < overflow)
		ret.append(array[low : high])
	return ret

def split_fixed(array, width):
	if width < 0:
		return split_fixed_out(array, -width)
	array = iterable(array)
	return [array[index : index + width] for index in range(0, len(array), width)]

def split_fixed_out(array, width):
	array = iterable(array)
	return [array[:index] + array[index + width:] for index in range(0, len(array), width)]

def split_key(control, data):
	groups = {}
	order = []
	count = 0
	for key, item in zip(control, data):
		key = repr(key) if type(key) == list else key
		if key not in groups:
			order.append(key)
			groups[key] = []
		groups[key].append(item)
		count += 1
	result = [groups[key] for key in order]
	if count < len(data):
		result.append(data[count:])
	return result

def split_once(array, needle):
	array = iterable(array, make_digits = True)
	index = index_of(array, needle)
	return [array[0 : index - 1], array[index :]] if index else [array]

def split_prefix(array):
	array = iterable(array)
	return [array[:index + 1] for index in range(len(array))]

def split_rolling(array, width):
	if width < 0:
		return split_rolling_out(array, -width)
	array = iterable(array)
	return [array[index : index + width] for index in range(len(array) - width + 1)]

def split_rolling_out(array, width):
	array = iterable(array)
	return [array[:index] + array[index + width:] for index in range(len(array) - width + 1)]

def split_suffix(array):
	array = iterable(array)
	return [array[index:] for index in range(len(array))]

def sss(compressed):
	from . import dictionary
	decompressed = ''
	integer = from_base([code_page.find(char) + 1 for char in compressed], 250)
	while integer:
		integer, mode = divmod(integer, 3)
		if mode == 0:
			integer, code = divmod(integer, 96)
			decompressed += code_page[code + 32]
		else:
			flag_swap = False
			flag_space = decompressed != ''
			if mode == 2:
				integer, flag = divmod(integer, 3)
				flag_swap = flag != 1
				flag_space ^= flag != 0
			integer, short = divmod(integer, 2)
			the_dictionary = (dictionary.long, dictionary.short)[short]
			integer, index = divmod(integer, len(the_dictionary))
			word = the_dictionary[index]
			if flag_swap:
				word = word[0].swapcase() + word[1:]
			if flag_space:
				word = ' ' + word
			decompressed += word
	return decompressed

def stringify(iterable, recurse = True):
	if type(iterable) != list:
		return iterable
	if len(iterable) == 1:
		return stringify(iterable[0])
	if str in map(type, iterable) and not list in map(type, iterable) or not iterable:
		return ''.join(map(str, iterable))
	iterable = [stringify(item) for item in iterable]
	return stringify(iterable, False) if recurse else iterable

def suffix(links, outmost_links, index):
	ret = [attrdict(arity = max(1, links[0].arity))]
	if len(links) == 1:
		ret[0].call = lambda x, y = None: [variadic_link(links[0], (t, y)) for t in split_suffix(x)]
	else:
		ret[0].call = lambda x, y = None: [variadic_link(links[0], (t, y)) for t in split_fixed(x, niladic_link(links[1]))]
	return ret

def symmetric_mod(number, half_divisor):
	modulus = number % (2 * half_divisor)
	return modulus - 2 * half_divisor * (modulus > half_divisor)

def tie(links, outmost_links, index):
	ret = [attrdict(arity= max(1, *arities(links)))]
	n = 2 if links[-1].arity else links[-1].call()
	def _make_tie():
		i = 0
		while True:
			yield links[i]
			i = (i + 1) % n
	cycle = _make_tie()
	ret[0].call = lambda x = None, y = None: variadic_link(next(cycle), (x, y))
	return ret

def time_format(bitfield):
	time_string = ':'.join(['%H'] * (bitfield & 4 > 0) + ['%M'] * (bitfield & 2 > 0) + ['%S'] * (bitfield & 1 > 0))
	return list(time.strftime(time_string))

def translate(mapping, array):
	array = iterable(array, make_copy = True)
	mapping = iterable(mapping, make_copy = True)
	while mapping:
		source = iterable(mapping.pop(0))
		destination = iterable(mapping.pop(0))
		for (index, item) in enumerate(array):
			if item in source:
				array[index] = destination[min(source.index(item), len(destination) - 1)]
	return array

def trim(trimmee, trimmer, left = False, right = False):
	lindex = 0
	rindex = len(trimmee)
	if left:
		while lindex < rindex and trimmee[lindex] in trimmer:
			lindex += 1
	if right:
		while lindex < rindex and trimmee[rindex - 1] in trimmer:
			rindex -= 1
	return trimmee[lindex:rindex]

def try_eval(string):
	try:
		return python_eval(string)
	except:
		return jellify(string, True)

def to_base(integer, base, bijective = False):
	if integer == 0:
		return [0] * (not bijective)
	if bijective:
		base = abs(base)
	if base == 0:
		return [integer]
	if base == -1:
		digits = [1, 0] * abs(integer)
		return digits[:-1] if integer > 0 else digits
	sign = -1 if integer < 0 and base > 0 else 1
	integer *= sign
	if base == 1:
		return [sign] * integer
	digits = []
	while integer:
		integer -= bijective
		integer, digit = divmod(integer, base)
		digit += bijective
		if digit < 0:
			integer += 1
			digit -= base
		digits.append(sign * digit)
	return digits[::-1]

def to_case(argument, lower = False, swap = False, title = False, upper = False):
	ret = []
	last_item = ' '
	for item in argument:
		if type(item) == str:
			if lower:
				ret.append(item.lower())
			elif swap:
				ret.append(item.swapcase())
			elif title:
				ret.append(item.lower() if type(last_item) == str and last_item in str_upper + str_lower else item.upper())
			elif upper:
				ret.append(item.upper())
		else:
			ret.append(item)
		last_item = item
	return ret

def to_exponents(integer):
	if integer == 1:
		return []
	pairs = sympy.ntheory.factor_.factorint(integer)
	exponents = []
	for prime in sympy.ntheory.generate.primerange(2, max(pairs) + 1):
		if prime in pairs:
			exponents.append(pairs[prime])
		else:
			exponents.append(0)
	return exponents

def to_factorial_base(integer):
	radix = 1
	digits = []
	while integer:
		integer, remainder = divmod(integer, radix)
		digits.append(remainder)
		radix += 1
	return digits[::-1] or [0]

def to_primorial_base(integer):
	placeIndex = 1
	integer, remainder = divmod(integer, 2)
	digits = [remainder]
	while integer:
		placeIndex += 1
		integer, remainder = divmod(integer, sympy.ntheory.generate.prime(placeIndex))
		digits.append(remainder)
	return digits[::-1]

def unicode_to_jelly(string):
	return ''.join(chr(code_page.find(char)) for char in str(string).replace('\n', '¶') if char in code_page)

def unique(array):
	array = iterable(array, make_digits = True)
	result = []
	for element in array:
		if not element in result:
			result.append(element)
	return result

def untruth_md(indices, shape = None, upper_level = []):
	if not shape:
		shape = [max(index_zipped) for index_zipped in zip(*indices)]
	upper_len = len(upper_level)
	if upper_len < len(shape) - 1:
		return [untruth_md(indices, shape = shape, upper_level = upper_level + [i + 1]) for i in range(shape[upper_len])]
	else:
		return [1 if (upper_level + [i + 1] in indices) else 0 for i in range(shape[-1])]

def variadic_chain(chain, args):
	args = list(filter(None.__ne__, args))
	larg_save = atoms['⁸'].call
	rarg_save = atoms['⁹'].call
	if len(args) == 0:
		return niladic_chain(chain)
	if len(args) == 1:
		atoms['⁸'].call = lambda literal = args[0]: literal
		ret = monadic_chain(chain, args[0])
	if len(args) == 2:
		atoms['⁸'].call = lambda literal = args[0]: literal
		atoms['⁹'].call = lambda literal = args[1]: literal
		ret = dyadic_chain(chain, args)
	atoms['⁸'].call = larg_save
	atoms['⁹'].call = rarg_save
	return ret

def variadic_link(link, args, flat = False, lflat = False, rflat = False):
	if link.arity < 0:
		args = list(filter(None.__ne__, args))
		link.arity = len(args)
	if link.arity == 0:
		return niladic_link(link)
	if link.arity == 1:
		return monadic_link(link, args[0], flat)
	if link.arity == 2:
		return dyadic_link(link, args, lflat, rflat)

def while_loop(link, condition, args, cumulative = False):
	ret, rarg = args
	cumret = []
	while variadic_link(condition, (ret, rarg)):
		if cumulative:
			cumret.append(ret)
		larg = ret
		ret = variadic_link(link, (larg, rarg))
		rarg = larg
	return cumret + [ret] if cumulative else ret

def windowed_exists(needle, haystack):
	haystack = iterable(haystack, make_digits = True)
	needle = iterable(needle, make_digits = True)
	needle_length = len(needle)
	for index in range(len(haystack)):
		if haystack[index : index + needle_length] == needle:
			return 1
	return 0

def windowed_index_of(haystack, needle):
	haystack = iterable(haystack, make_digits = True)
	needle = iterable(needle, make_digits = True)
	needle_length = len(needle)
	for index in range(len(haystack)):
		if haystack[index : index + needle_length] == needle:
			return 1 + index
	return 0

def windowed_sublists(array):
	array = iterable(array, make_range = True)
	return [sublist for width in range(1, len(array) + 1) for sublist in split_rolling(array, width)]

def output(argument, end = '', transform = stringify):
	if locale.getdefaultlocale()[1][0:3] == 'UTF':
		print(transform(argument), end = end)
	else:
		print(unicode_to_jelly(transform(argument)), end = unicode_to_jelly(end))
	sys.stdout.flush()
	return argument

def zip_ragged(array):
	return jellify(map(lambda t: filter(None.__ne__, t), itertools.zip_longest(*map(iterable, array))))

atoms = {
	'³': attrdict(
		arity = 0,
		call = lambda: 100
	),
	'⁴': attrdict(
		arity = 0,
		call = lambda: 16
	),
	'⁵': attrdict(
		arity = 0,
		call = lambda: 10
	),
	'⁶': attrdict(
		arity = 0,
		call = lambda: ' '
	),
	'⁷': attrdict(
		arity = 0,
		call = lambda: '\n'
	),
	'⁸': attrdict(
		arity = 0,
		call = lambda: []
	),
	'⁹': attrdict(
		arity = 0,
		call = lambda: 256
	),
	'A': attrdict(
		arity = 1,
		ldepth = 0,
		call = abs
	),
	'Ȧ': attrdict(
		arity = 1,
		call = lambda z: int(iterable(z) > [] and all(flatten(z)))
	),
	'Ạ': attrdict(
		arity = 1,
		call = lambda z: int(all(iterable(z)))
	),
	'a': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = lambda x, y: x and y
	),
	'ȧ': attrdict(
		arity = 2,
		call = lambda x, y: x and y
	),
	'ạ': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = lambda x, y: abs(x - y)
	),
	'B': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: to_base(z, 2)
	),
	'Ḅ': attrdict(
		arity = 1,
		ldepth = 1,
		call = lambda z: from_base(z, 2)
	),
	'Ḃ': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: z % 2
	),
	'b': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = lambda x, y: to_base(x, y)
	),
	'ḅ': attrdict(
		arity = 2,
		ldepth = 1,
		rdepth = 0,
		call = lambda x, y: from_base(x, y)
	),
	'ḃ': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = lambda x, y: to_base(x, y, bijective = True)
	),
	'C': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: 1 - z
	),
	'Ċ': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: overload((math.ceil, lambda t: t.imag, identity), z)
	),
	'c': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = nCr
	),
	'ċ': attrdict(
		arity = 2,
		call = lambda x, y: iterable(x).count(y)
	),
	'ƈ': attrdict(
		arity = 0,
		call = lambda: sys.stdin.read(1) or []
	),
	'D': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: to_base(z, 10)
	),
	'Ḍ': attrdict(
		arity = 1,
		ldepth = 1,
		call = lambda z: from_base(z, 10)
	),
	'Ḋ': attrdict(
		arity = 1,
		call = lambda z: iterable(z, make_range = True)[1:]
	),
	'd': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = lambda x, y: list(divmod(x, y))
	),
	'ḍ': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = lambda x, y: int(y % x == 0 if x else y == 0)
	),
	'ḋ': attrdict(
		arity = 2,
		ldepth = 1,
		rdepth = 1,
		call = lambda x, y: dot_product(x, y, truncate = True)
	),
	'E': attrdict(
		arity = 1,
		call = equal
	),
	'Ẹ': attrdict(
		arity = 1,
		call = lambda z: int(any(iterable(z)))
	),
	'Ė': attrdict(
		arity = 1,
		call = lambda z: [[t + 1, u] for t, u in enumerate(iterable(z))]
	),
	'e': attrdict(
		arity = 2,
		call = lambda x, y: int(x in iterable(y))
	),
	'ẹ': attrdict(
		arity = 2,
		call = lambda x, y: [t + 1 for t, u in enumerate(iterable(x, make_digits = True)) if u == y]
	),
	'F': attrdict(
		arity = 1,
		call = flatten
	),
	'Ḟ': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: overload((math.floor, lambda t: t.real, identity), z)
	),
	'f': attrdict(
		arity = 2,
		call = filter_array
	),
	'ḟ': attrdict(
		arity = 2,
		call = lambda x, y: filter_array(x, y, False)
	),
	'G': attrdict(
		arity = 1,
		call = grid
	),
	'Ġ': attrdict(
		arity = 1,
		call = group
	),
	'g': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = math.gcd
	),
	'Ɠ': attrdict(
		arity = 0,
		call = lambda: python_eval(input())
	),
	'ɠ': attrdict(
		arity = 0,
		call = lambda: jellify(input(), dirty = True)
	),
	'H': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: div(z, 2)
	),
	'Ḥ': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: z * 2
	),
	'Ḣ': attrdict(
		arity = 1,
		call = lambda z: iterable(z).pop(0) if iterable(z) else 0
	),
	'ḣ': attrdict(
		arity = 2,
		rdepth = 0,
		call = lambda x, y: iterable(x)[:y]
	),
	'I': attrdict(
		arity = 1,
		ldepth = 1,
		call = lambda z: [z[i] - z[i - 1] for i in range(1, len(z))]
	),
	'İ': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: div(1, z)
	),
	'Ị': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: int(abs(z) <= 1)
	),
	'J': attrdict(
		arity = 1,
		call = lambda z: list(range(1, len(iterable(z)) + 1))
	),
	'i': attrdict(
		arity = 2,
		call = index_of
	),
	'ḥ': attrdict(
		arity = 2,
		call = jelly_hash
	),
	'ị': attrdict(
		arity = 2,
		ldepth = 0,
		call = at_index
	),
	'j': attrdict(
		arity = 2,
		call = join
	),
	'K': attrdict(
		arity = 1,
		call = lambda z: join(z, ' ')
	),
	'Ḳ': attrdict(
		arity = 1,
		call = lambda z: jellify(split_at(iterable(z), ' '))
	),
	'k': attrdict(
		arity = 2,
		call = lambda x, y: partition_at(x, y, border = 2)
	),
	'L': attrdict(
		arity = 1,
		call = lambda z: len(iterable(z))
	),
	'Ḷ': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: list(range(int(z)))
	),
	'l': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = lambda x, y: overload((math.log, cmath.log), x, y)
	),
	'ḷ': attrdict(
		arity = 2,
		call = lambda x, y: x
	),
	'M': attrdict(
		arity = 1,
		call = maximal_indices
	),
	'Ṃ': attrdict(
		arity = 1,
		call = lambda z: min(iterable(z)) if iterable(z) else 0
	),
	'Ṁ': attrdict(
		arity = 1,
		call = lambda z: max(iterable(z)) if iterable(z) else 0
	),
	'm': attrdict(
		arity = 2,
		rdepth = 0,
		call = lambda x, y: iterable(x)[::y] if y else iterable(x) + iterable(x)[::-1]
	),
	'ṁ': attrdict(
		arity = 2,
		call = lambda x, y: mold(iterable(x, make_copy = True), iterable(y, make_copy = True, make_range = True))
	),
	'ṃ': attrdict(
		arity = 2,
		ldepth = 0,
		call = base_decompression
	),
	'N': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: -z
	),
	'Ṅ': attrdict(
		arity = 1,
		call = lambda z: output(z, end = '\n')
	),
	'Ṇ': attrdict(
		arity = 1,
		call = lambda z: int(not(z))
	),
	'n': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = lambda x, y: int(x != y)
	),
	'O': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: ord(z) if type(z) == str else z
	),
	'Ọ': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: chr(int(z)) if type(z) != str else z
	),
	'Ȯ': attrdict(
		arity = 1,
		call = output
	),
	'o': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = lambda x, y: x or y
	),
	'ọ': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = order
	),
	'ȯ': attrdict(
		arity = 2,
		call = lambda x, y: x or y
	),
	'P': attrdict(
		arity = 1,
		call = lambda z: functools.reduce(lambda x, y: dyadic_link(atoms['×'], (x, y)), z, 1) if type(z) == list else z
	),
	'Ṗ': attrdict(
		arity = 1,
		call = lambda z: iterable(z, make_range = True)[:-1]
	),
	'p': attrdict(
		arity = 2,
		call = lambda x, y: jellify(itertools.product(iterable(x, make_range = True), iterable(y, make_range = True)))
	),
	'ṗ': attrdict(
		arity = 2,
		rdepth = 0,
		call = lambda x, y: jellify(itertools.product(*([iterable(x, make_range = True)] * y)))
	),
	'Q': attrdict(
		arity = 1,
		call = unique
	),
	'R': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: list(range(1, int(z) + 1))
	),
	'Ṛ': attrdict(
		arity = 1,
		call = lambda z: iterable(z, make_digits = True)[::-1]
	),
	'Ṙ': attrdict(
		arity = 1,
		call = lambda z: output(z, transform = jelly_uneval)
	),
	'r': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = lambda x, y: list(range(int(x), int(y) + 1) or range(int(x), int(y) - 1, -1))
	),
	'ṙ': attrdict(
		arity = 2,
		rdepth = 0,
		call = rotate_left
	),
	'ṛ': attrdict(
		arity = 2,
		call = lambda x, y: y
	),
	'S': attrdict(
		arity = 1,
		call = lambda z: functools.reduce(lambda x, y: dyadic_link(atoms['+'], (x, y)), z, 0) if type(z) == list else z
	),
	'Ṡ': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: overload((lambda t: (t > 0) - (t < 0), lambda t: t.conjugate()), z)
	),
	'Ṣ': attrdict(
		arity = 1,
		call = lambda z: sorted(iterable(z, make_digits = True))
	),
	's': attrdict(
		arity = 2,
		rdepth = 0,
		call = lambda x, y: split_fixed(iterable(x, make_range = True), y)
	),
	'ṡ': attrdict(
		arity = 2,
		rdepth = 0,
		call = lambda x, y: split_rolling(iterable(x, make_range = True), y)
	),
	'ṣ': attrdict(
		arity = 2,
		call = lambda x, y: jellify(split_at(iterable(x, make_digits = True), y))
	),
	'T': attrdict(
		arity = 1,
		call = lambda z: [u + 1 for u, v in enumerate(z) if v]
	),
	'Ṭ': attrdict(
		arity = 1,
		ldepth = 1,
		call = lambda z: [int(t + 1 in iterable(z)) for t in range(max(iterable(z) or [0]))]
	),
	'Ṫ': attrdict(
		arity = 1,
		call = lambda z: iterable(z).pop() if iterable(z) else 0
	),
	't': attrdict(
		arity = 2,
		call = lambda x, y: trim(x, iterable(y), left = True, right = True)
	),
	'ṫ': attrdict(
		arity = 2,
		rdepth = 0,
		call = lambda x, y: iterable(x)[y - 1 :]
	),
	'ṭ': attrdict(
		arity = 2,
		call = lambda x, y: iterable(y) + [x]
	),
	'U': attrdict(
		arity = 1,
		ldepth = 1,
		call = lambda z: z[::-1]
	),
	'Ụ': attrdict(
		arity = 1,
		call = lambda z: sorted(range(1, len(iterable(z)) + 1), key = lambda t: iterable(z)[t - 1])
	),
	'V': attrdict(
		arity = 1,
		ldepth = 1,
		call = lambda z: jelly_eval(''.join(map(str, z)), [])
	),
	'Ṿ': attrdict(
		arity = 1,
		call = lambda z: jellify(jelly_uneval(z))
	),
	'v': attrdict(
		arity = 2,
		ldepth = 1,
		call = lambda x, y: jelly_eval(''.join(map(str, x)), [y])
	),
	'W': attrdict(
		arity = 1,
		call = lambda z: [z]
	),
	'Ẇ': attrdict(
		arity = 1,
		call = windowed_sublists
	),
	'Ẉ': attrdict(
		arity = 1,
		call = lambda z: [len(iterable(t, make_digits = True)) for t in iterable(z, make_range = True)]
	),
	'w': attrdict(
		arity = 2,
		call = windowed_index_of
	),
	'ẇ': attrdict(
		arity = 2,
		call = windowed_exists
	),
	'X': attrdict(
		arity = 1,
		call = random_int
	),
	'Ẋ': attrdict(
		arity = 1,
		call = shuffle
	),
	'x': attrdict(
		arity = 2,
		ldepth = 1,
		call = lambda x, y: rld(zip(x, y if depth(y) else [y] * len(x)))
	),
	'ẋ': attrdict(
		arity = 2,
		rdepth = 0,
		call = lambda x, y: iterable(x) * int(y)
	),
	'Y': attrdict(
		arity = 1,
		call = lambda z: join(z, '\n')
	),
	'Ỵ': attrdict(
		arity = 1,
		call = lambda z: jellify(split_at(iterable(z), '\n'))
	),
	'Ẏ': attrdict(
		arity = 1,
		call = lambda z: sum(map(iterable, iterable(z)), [])
	),
	'y': attrdict(
		arity = 2,
		call = translate
	),
	'Z': attrdict(
		arity = 1,
		call = zip_ragged
	),
	'Ż': attrdict(
		arity = 1,
		call = lambda z: [0] + iterable(z, make_range = True)
	),
	'z': attrdict(
		arity = 2,
		call = lambda x, y: jellify(itertools.zip_longest(*map(iterable, x), fillvalue = y))
	),
	'ż': attrdict(
		arity = 2,
		call = lambda x, y: zip_ragged([x, y])
	),
	'§': attrdict(
		arity = 1,
		ldepth = 1,
		call = sum
	),
	'Ä': attrdict(
		arity = 1,
		ldepth = 1,
		call = lambda z: list(itertools.accumulate(z))
	),
	'!': attrdict(
		arity = 1,
		ldepth = 0,
		call = Pi
	),
	'<': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = lambda x, y: int(x < y)
	),
	'=': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = lambda x, y: int(x == y)
	),
	'>': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = lambda x, y: int(x > y)
	),
	':': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = lambda x, y: div(x, y, floor = True)
	),
	',': attrdict(
		arity = 2,
		call = lambda x, y: [x, y]
	),
	';': attrdict(
		arity = 2,
		call = lambda x, y: iterable(x) + iterable(y)
	),
	'+': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = operator.add
	),
	'_': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = operator.sub
	),
	'×': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = operator.mul
	),
	'÷': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = div
	),
	'%': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = modulus
	),
	'*': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = operator.pow
	),
	'&': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		conv = conv_dyadic_integer,
		call = operator.and_
	),
	'^': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		conv = conv_dyadic_integer,
		call = operator.xor
	),
	'|': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		conv = conv_dyadic_integer,
		call = operator.or_
	),
	'~': attrdict(
		arity = 1,
		ldepth = 0,
		conv = conv_monadic_integer,
		call = lambda z: ~z
	),
	'²': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: z ** 2
	),
	'½': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: overload((math.sqrt, cmath.sqrt), z)
	),
	'°': attrdict(
		arity = 1,
		ldepth = 0,
		call = math.radians
	),
	'¬': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: int(not z)
	),
	'‘': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: z + 1
	),
	'’': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: z - 1
	),
	'«': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = min
	),
	'»': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = max
	),
	'⁼': attrdict(
		arity = 2,
		call = lambda x, y: int(x == y)
	),
	'⁻': attrdict(
		arity = 2,
		call = lambda x, y: int(x != y)
	),
	'®': attrdict(
		arity = 0,
		call = lambda: 0
	),
	'¹': attrdict(
		arity = 1,
		call = identity
	),
	'ÆA': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: overload((math.acos, cmath.acos), z)
	),
	'ÆẠ': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: overload((math.cos, cmath.cos), z)
	),
	'ÆC': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: sympy.ntheory.generate.primepi(z)
	),
	'ÆĊ': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: int(sympy.functions.combinatorial.numbers.catalan(z))
	),
	'Æc': attrdict(
		arity = 1,
		ldepth = 0,
		call = carmichael
	),
	'ÆD': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: sympy.ntheory.factor_.divisors(z)
	),
	'ÆḌ': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: sympy.ntheory.factor_.divisors(z)[:-1]
	),
	'Æd': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: int(sympy.ntheory.factor_.divisor_count(z))
	),
	'Æḍ': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: int(sympy.ntheory.factor_.divisor_count(z) - 1)
	),
	'ÆḊ': attrdict(
		arity = 1,
		ldepth = 2,
		call = determinant
	),
	'ÆE': attrdict(
		arity = 1,
		ldepth = 0,
		call = to_exponents
	),
	'ÆẸ': attrdict(
		arity = 1,
		ldepth = 1,
		call = from_exponents
	),
	'ÆF': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: [[x, y] for x, y in sorted(sympy.ntheory.factor_.factorint(z).items())]
	),
	'Æe': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: overload((math.exp, cmath.exp), z)
	),
	'Æf': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: rld(sorted(sympy.ntheory.factor_.factorint(z).items()))
	),
	'ÆḞ': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: int(sympy.functions.combinatorial.numbers.fibonacci(z))
	),
	'Æi': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: [z.real, z.imag]
	),
	'Æị': attrdict(
		arity = 1,
		ldepth = 1,
		call = lambda z: complex(*z[:2])
	),
	'ÆĿ': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: int(sympy.functions.combinatorial.numbers.lucas(z))
	),
	'Æl': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: overload((math.log, cmath.log), z)
	),
	'Æm': attrdict(
		arity = 1,
		ldepth = 1,
		call = lambda z: div(sum(z), len(z))
	),
	'Æṁ': attrdict(
		arity = 1,
		ldepth = 1,
		call = median
	),
	'Æṃ': attrdict(
		arity = 1,
		ldepth = 1,
		call = mode
	),
	'ÆN': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: sympy.ntheory.generate.prime(z)
	),
	'Æn': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: sympy.ntheory.generate.nextprime(z)
	),
	'ÆP': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: int(sympy.primetest.isprime(z))
	),
	'Æp': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: sympy.ntheory.generate.prevprime(z)
	),
	'ÆR': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: list(sympy.ntheory.generate.primerange(2, z + 1))
	),
	'Ær': attrdict(
		arity = 1,
		ldepth = 1,
		call = lambda z: jellify(from_base(z[::-1], sympy.poly('x')).all_roots())
	),
	'Æṛ': attrdict(
		arity = 1,
		ldepth = 1,
		call = lambda z: jellify(sympy.prod(map(sympy.poly('x').__sub__, z)).all_coeffs()[::-1])
	),
	'ÆT': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: overload((math.tan, cmath.tan), z)
	),
	'ÆṬ': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: overload((math.atan, cmath.atan), z)
	),
	'ÆṪ': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: sympy.ntheory.factor_.totient(z) if z > 0 else 0
	),
	'Æṭ': attrdict(
		arity = 1,
		ldepth = 2,
		call = lambda z: sum(sum(r[i : i+1]) for i, r in enumerate(z))
	),
	'ÆS': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: overload((math.sin, cmath.sin), z)
	),
	'ÆṢ': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: overload((math.asin, cmath.asin), z)
	),
	'Æs': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: int(sympy.ntheory.factor_.divisor_sigma(z))
	),
	'Æṣ': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: int(sympy.ntheory.factor_.divisor_sigma(z) - z)
	),
	'Æv': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: len(sympy.ntheory.factor_.factorint(z))
	),
	'Ʋ': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: int(isqrt(z) ** 2 == z)
	),
	'ƽ': attrdict(
		arity = 1,
		ldepth = 0,
		call = isqrt
	),
	'Æ°': attrdict(
		arity = 1,
		ldepth = 0,
		call = math.degrees
	),
	'Æ!': attrdict(
		arity = 1,
		ldepth = 0,
		call = to_factorial_base
	),
	'Æ¡': attrdict(
		arity = 1,
		ldepth = 1,
		call = from_factorial_base
	),
	'Æ?': attrdict(
		arity = 1,
		ldepth = 0,
		call = to_primorial_base
	),
	'Æ¿': attrdict(
		arity = 1,
		ldepth = 1,
		call = from_primorial_base
	),
	'Œ!': attrdict(
		arity = 1,
		call = lambda z: jellify(itertools.permutations(iterable(z, make_range = True)))
	),
	'Œ?': attrdict(
		arity = 1,
		ldepth = 0,
		call = pemutation_at_index
	),
	'Œ¿': attrdict(
		arity = 1,
		call = permutation_index
	),
	'ŒB': attrdict(
		arity = 1,
		ldepth = 1,
		call = lambda z: bounce(z)
	),
	'ŒḄ': attrdict(
		arity = 1,
		call = lambda z: bounce(iterable(z, make_range = True))
	),
	'ŒḂ': attrdict(
		arity = 1,
		call = is_palindrome
	),
	'Œb': attrdict(
		arity = 1,
		call = lambda z: partitions(z) if z else [[]]
	),
	'Œc': attrdict(
		arity = 1,
		rdepth = 0,
		call = lambda z: jellify(itertools.combinations(iterable(z, make_range = True), 2))
	),
	'Œċ': attrdict(
		arity = 1,
		rdepth = 0,
		call = lambda z: jellify(itertools.combinations_with_replacement(iterable(z, make_range = True), 2))
	),
	'ŒD': attrdict(
		arity = 1,
		ldepth = 2,
		call = diagonals
	),
	'ŒḌ': attrdict(
		arity = 1,
		ldepth = 2,
		call = from_diagonals
	),
	'ŒḊ': attrdict(
		arity = 1,
		call = depth
	),
	'Œd': attrdict(
		arity = 1,
		ldepth = 2,
		call = lambda z: diagonals([r[::-1] for r in z])
	),
	'Œḍ': attrdict(
		arity = 1,
		ldepth = 2,
		call = lambda z: [r[::-1] for r in from_diagonals(z)]
	),
	'ŒĖ': attrdict(
		arity = 1,
		call = lambda z: list(enumerate_md(z))
	),
	'Œe': attrdict(
		arity = 1,
		call = lambda z: [t for t in iterable(z, make_range = True)[1::2]]
	),
	'ŒG': attrdict(
		arity = 1,
		ldepth = 1,
		call = get_request
	),
	'ŒĠ': attrdict(
		arity = 1,
		call = group_md
	),
	'Œg': attrdict(
		arity = 1,
		ldepth = 1,
		call = group_equal
	),
	'ŒH': attrdict(
		arity = 1,
		call = lambda z: split_evenly(iterable(z, make_range = True), 2)
	),
	'œị': attrdict(
		arity = 2,
		ldepth = 1,
		call = at_index_ndim
	),
	'ŒJ': attrdict(
		arity = 1,
		call = indices_md
	),
	'Œl': attrdict(
		arity = 1,
		ldepth = 1,
		call = lambda z: to_case(z, lower = True)
	),
	'ŒM': attrdict(
		arity = 1,
		call = maximal_indices_md
	),
	'Œo': attrdict(
		arity = 1,
		call = lambda z: [t for t in iterable(z, make_range = True)[::2]]
	),
	'ŒP': attrdict(
		arity = 1,
		call = powerset
	),
	'ŒṖ': attrdict(
		arity = 1,
		call = partitions
	),
	'Œṗ': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: sorted(integer_partitions(z), key = len, reverse = True)
	),
	'Œp': attrdict(
		arity = 1,
		call = lambda z: jellify(itertools.product(*[iterable(t, make_range = True) for t in z]))
	),
	'ŒQ': attrdict(
		arity = 1,
		call = distinct_sieve
	),
	'ŒR': attrdict(
		arity = 1,
		ldepth = 0,
		call = lambda z: list(range(-abs(int(z)), abs(int(z)) + 1))
	),
	'ŒṘ': attrdict(
		arity = 1,
		call = lambda z: jellify(repr(z))
	),
	'Œr': attrdict(
		arity = 1,
		ldepth = 1,
		call = rle
	),
	'Œṙ': attrdict(
		arity = 1,
		ldepth = 2,
		call = rld
	),
	'Œs': attrdict(
		arity = 1,
		ldepth = 1,
		call = lambda z: to_case(z, swap = True)
	),
	'ŒT': attrdict(
		arity = 1,
		call = time_format
	),
	'ŒṬ': attrdict(
		arity = 1,
		ldepth = 2,
		call = untruth_md
	),
	'ŒṪ': attrdict(
		arity = 1,
		call = lambda z: [t for t, u in enumerate_md(iterable(z)) if u]
	),
	'Œt': attrdict(
		arity = 1,
		ldepth = 1,
		call = lambda z: to_case(z, title = True)
	),
	'ŒV': attrdict(
		arity = 1,
		ldepth = 1,
		call = lambda z: python_eval(''.join(map(str, z)))
	),
	'ŒỤ': attrdict(
		arity = 1,
		call = lambda z: sorted(indices_md(iterable(z)), key = lambda t: at_index_ndim(t, iterable(z)))
	),
	'Œu': attrdict(
		arity = 1,
		ldepth = 1,
		call = lambda z: to_case(z, upper = True)
	),
	'Œœ': attrdict(
		arity = 1,
		call = odd_even
	),
	'Œɠ': attrdict(
		arity = 1,
		call = group_lengths
	),
	'œ?': attrdict(
		arity = 2,
		ldepth = 0,
		call = pemutation_at_index
	),
	'œ¿': attrdict(
		arity = 2,
		call = lambda x, y: permutation_index([y.index(value) for value in x])
	),
	'æ.': attrdict(
		arity = 2,
		ldepth = 1,
		rdepth = 1,
		call = dot_product
	),
	'æ%': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = symmetric_mod
	),
	'æ*': attrdict(
		arity = 2,
		ldepth = 2,
		rdepth = 0,
		call = lambda x, y: matrix_to_list((sympy.Matrix(x) ** y))
	),
	'æ×': attrdict(
		arity = 2,
		ldepth = 2,
		rdepth = 2,
		call = lambda x, y: matrix_to_list((sympy.Matrix(x) * sympy.Matrix(y)))
	),
	'æA': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = math.atan2
	),
	'æR': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = primerange
	),
	'æC': attrdict(
		arity = 2,
		ldepth = 1,
		rdepth = 0,
		call = convolve_power
	),
	'æc': attrdict(
		arity = 2,
		ldepth = 1,
		rdepth = 1,
		call = convolve
	),
	'æċ': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = lambda x, y: from_base([1] + [0] * len(to_base(x, y)), y)
	),
	'æḟ': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = lambda x, y: from_base([1] + [0] * (len(to_base(x, y)) - 1), y)
	),
	'æi': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = modinv
	),
	'æị': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = complex
	),
	'æl': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = lcm
	),
	'ær': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = round
	),
	'æp': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = lambda x, y: float('%%.%dg'%y%x)
	),
	'æ«': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = shift_left
	),
	'æ»': attrdict(
		arity = 2,
		ldepth = 0,
		rdepth = 0,
		call = shift_right
	),
	'œ!': attrdict(
		arity = 2,
		rdepth = 0,
		call = lambda x, y: jellify(itertools.permutations(iterable(x, make_range = True), y))
	),
	'œc': attrdict(
		arity = 2,
		rdepth = 0,
		call = lambda x, y: jellify(itertools.combinations(iterable(x, make_range = True), y))
	),
	'œċ': attrdict(
		arity = 2,
		rdepth = 0,
		call = lambda x, y: jellify(itertools.combinations_with_replacement(iterable(x, make_range = True), y))
	),
	'œẹ': attrdict(
		arity = 2,
		call = lambda x, y: [t for t, u in enumerate_md(iterable(x)) if u == y]
	),
	'œi': attrdict(
		arity = 2,
		call = index_of_md
	),
	'œl': attrdict(
		arity = 2,
		call = lambda x, y: trim(x, iterable(y), left = True)
	),
	'œP': attrdict(
		arity = 2,
		call = lambda x, y: partition_at([int(t + 1 in iterable(x)) for t in range(max(iterable(x) or [0]))], y, border = 0)
	),
	'œṖ': attrdict(
		arity = 2,
		call = lambda x, y: partition_at([int(t + 1 in iterable(x)) for t in range(max(iterable(x) or [0]))], y)
	),
	'œp': attrdict(
		arity = 2,
		call = lambda x, y: partition_at(x, y, border = 0)
	),
	'œṗ': attrdict(
		arity = 2,
		call = partition_at
	),
	'œr': attrdict(
		arity = 2,
		call = lambda x, y: trim(x, iterable(y), right = True)
	),
	'œS': attrdict(
		arity = 2,
		call = lambda x, y: time.sleep(overload((float, bool), y)) or x
	),
	'œs': attrdict(
		arity = 2,
		rdepth = 0,
		call = lambda x, y: split_evenly(iterable(x, make_range = True), y)
	),
	'œṡ': attrdict(
		arity = 2,
		rdepth = 0,
		call = split_once
	),
	'œṣ': attrdict(
		arity = 2,
		call = lambda x, y: jellify(split_around(iterable(x, make_digits = True), iterable(y)))
	),
	'œ&': attrdict(
		arity = 2,
		call = multiset_intersect
	),
	'œ-': attrdict(
		arity = 2,
		call = multiset_difference
	),
	'œ^': attrdict(
		arity = 2,
		call = multiset_symdif
	),
	'œ|': attrdict(
		arity = 2,
		call = multiset_union
	),
	'Ø0': attrdict(
		arity = 0,
		call = lambda: [0, 0]
	),
	'Ø1': attrdict(
		arity = 0,
		call = lambda: [1, 1]
	),
	'Ø2': attrdict(
		arity = 0,
		call = lambda: [2, 2]
	),
	'Ø.': attrdict(
		arity = 0,
		call = lambda: [0, 1]
	),
	'ؽ': attrdict(
		arity = 0,
		call = lambda: [1, 2]
	),
	'Ø+': attrdict(
		arity = 0,
		call = lambda: [1, -1]
	),
	'Ø-': attrdict(
		arity = 0,
		call = lambda: [-1, 1]
	),
	'Ø(': attrdict(
		arity = 0,
		call = lambda: list('()')
	),
	'Ø<': attrdict(
		arity = 0,
		call = lambda: list('<>')
	),
	'Ø[': attrdict(
		arity = 0,
		call = lambda: list('[]')
	),
	'Ø{': attrdict(
		arity = 0,
		call = lambda: list('{}')
	),
	'Ø^': attrdict(
		arity = 0,
		call = lambda: list('/\\')
	),
	'Ø⁵': attrdict(
		arity = 0,
		call = lambda: 250
	),
	'Ø⁷': attrdict(
		arity = 0,
		call = lambda: 128
	),
	'Ø°': attrdict(
		arity = 0,
		call = lambda: 360
	),
	'Ø%': attrdict(
		arity = 0,
		call = lambda: 2 ** 32
	),
	'ØA': attrdict(
		arity = 0,
		call = lambda: list(str_upper)
	),
	'ØẠ': attrdict(
		arity = 0,
		call = lambda: list(str_upper + str_lower)
	),
	'ØB': attrdict(
		arity = 0,
		call = lambda: list(str_digit + str_upper + str_lower)
	),
	'ØḄ': attrdict(
		arity = 0,
		call = lambda: list('bcdfghjklmnpqrstvwxyz')
	),
	'ØḂ': attrdict(
		arity = 0,
		call = lambda: list('BCDFGHJKLMNPQRSTVWXYZ')
	),
	'ØC': attrdict(
		arity = 0,
		call = lambda: list('BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz')
	),
	'ØD': attrdict(
		arity = 0,
		call = lambda: list(str_digit)
	),
	'ØH': attrdict(
		arity = 0,
		call = lambda: list(str_digit + 'ABCDEF')
	),
	'ØJ': attrdict(
		arity = 0,
		call = lambda: list(code_page)
	),
	'ØP': attrdict(
		arity = 0,
		call = lambda: math.pi
	),
	'ØṖ': attrdict(
		arity = 0,
		call = lambda: list(map(chr, range(32, 127)))
	),
	'ØQ': attrdict(
		arity = 0,
		call = lambda: [list('QWERTYUIOP'), list('ASDFGHJKL'), list('ZXCVBNM')]
	),
	'ØV': attrdict(
		arity = 0,
		call = lambda: list('ṘV')
	),
	'ØW': attrdict(
		arity = 0,
		call = lambda: list(str_upper + str_lower + str_digit + '_')
	),
	'ØY': attrdict(
		arity = 0,
		call = lambda: list('BCDFGHJKLMNPQRSTVWXZbcdfghjklmnpqrstvwxz')
	),
	'ØỴ': attrdict(
		arity = 0,
		call = lambda: list('bcdfghjklmnpqrstvwxz')
	),
	'ØẎ': attrdict(
		arity = 0,
		call = lambda: list('BCDFGHJKLMNPQRSTVWXZ')
	),
	'Øa': attrdict(
		arity = 0,
		call = lambda: list(str_lower)
	),
	'Øb': attrdict(
		arity = 0,
		call = lambda: list(str_upper + str_lower + str_digit + '+/')
	),
	'Øc': attrdict(
		arity = 0,
		call = lambda: list('AEIOUaeiou')
	),
	'Øe': attrdict(
		arity = 0,
		call = lambda: math.e
	),
	'Øẹ': attrdict(
		arity = 0,
		call = lambda: list('aeiou')
	),
	'Øė': attrdict(
		arity = 0,
		call = lambda: list('AEIOU')
	),
	'Øh': attrdict(
		arity = 0,
		call = lambda: list(str_digit + 'abcdef')
	),
	'Øp': attrdict(
		arity = 0,
		call = lambda: (1 + math.sqrt(5)) / 2
	),
	'Øq': attrdict(
		arity = 0,
		call = lambda: [list('qwertyuiop'), list('asdfghjkl'), list('zxcvbnm')]
	),
	'Øv': attrdict(
		arity = 0,
		call = lambda: list('Ṙv')
	),
	'Øy': attrdict(
		arity = 0,
		call = lambda: list('AEIOUYaeiouy')
	),
	'Øỵ': attrdict(
		arity = 0,
		call = lambda: list('aeiouy')
	),
	'Øẏ': attrdict(
		arity = 0,
		call = lambda: list('AEIOUY')
	)
}

quicks = {
	'©': attrdict(
		condition = lambda links: links,
		quicklink = lambda links, outmost_links, index: [attrdict(
			arity = links[0].arity,
			call = lambda x = None, y = None: copy_to(atoms['®'], variadic_link(links[0], (x, y)))
		)]
	),
	'ß': attrdict(
		condition = lambda links: True,
		quicklink = lambda links, outmost_links, index: [create_chain(outmost_links[index])]
	),
	'¢': attrdict(
		condition = lambda links: True,
		quicklink = lambda links, outmost_links, index: [create_chain(outmost_links[index - 1], 0)]
	),
	'Ç': attrdict(
		condition = lambda links: True,
		quicklink = lambda links, outmost_links, index: [create_chain(outmost_links[index - 1], 1)]
	),
	'ç': attrdict(
		condition = lambda links: True,
		quicklink = lambda links, outmost_links, index: [create_chain(outmost_links[index - 1], 2)]
	),
	'Ñ': attrdict(
		condition = lambda links: True,
		quicklink = lambda links, outmost_links, index: [create_chain(outmost_links[(index + 1) % len(outmost_links)], 1)]
	),
	'ñ': attrdict(
		condition = lambda links: True,
		quicklink = lambda links, outmost_links, index: [create_chain(outmost_links[(index + 1) % len(outmost_links)], 2)]
	),
	'¦': attrdict(
		condition = lambda links: len(links) == 2,
		quicklink = lambda links, outmost_links, index: [attrdict(
			arity = max_arity(links + [atoms['¹']]),
			call = lambda x, y = None: sparse(links[0], (x, y), links[1])
		)]
	),
	'¡': attrdict(
		condition = lambda links: len(links) == 2,
		quicklink = lambda links, outmost_links, index: ([links.pop(0)] if len(links) == 2 and links[0].arity == 0 else []) + [attrdict(
			arity = max_arity(links),
			call = lambda x = None, y = None: ntimes(links, (x, y))
		)]
	),
	'¿': attrdict(
		condition = lambda links: len(links) == 2,
		quicklink = lambda links, outmost_links, index: [attrdict(
			arity = max(link.arity for link in links),
			call = lambda x = None, y = None: while_loop(links[0], links[1], (x, y))
		)]
	),
	'/': attrdict(
		condition = lambda links: links and links[0].arity,
		quicklink = reduce
	),
	'\\': attrdict(
		condition = lambda links: links and links[0].arity,
		quicklink = reduce_cumulative
	),
	'Ƒ': attrdict(
		condition = lambda links: links,
		quicklink = lambda links, outmost_links, index: [attrdict(
			arity = max(1, links[0].arity),
			call = lambda x, y = None: int(x == variadic_link(links[0], (x, y)))
		)]
	),
	'ƒ': attrdict(
		condition = lambda links: links and links[0].arity,
		quicklink = foldl
	),
	'Ɲ': attrdict(
		condition = lambda links: links and not leading_nilad(links),
		quicklink = lambda links, outmost_links, index: [attrdict(
			arity = 1,
			call = lambda z: neighbors(links, z)
		)]
	),
	'Ƥ': attrdict(
		condition = lambda links: links and links[0].arity,
		quicklink = prefix
	),
	'ÐƤ': attrdict(
		condition = lambda links: links and links[0].arity,
		quicklink = suffix
	),
	'ƙ': attrdict(
		condition = lambda links: links and links[0].arity,
		quicklink = lambda links, outmost_links, index: [attrdict(
			arity = 2,
			call = lambda x, y: [monadic_link(links[0], g) for g in split_key(iterable(x, make_digits = True), iterable(y, make_digits = True))]
		)]
	),
	'ɼ': attrdict(
		condition = lambda links: links,
		quicklink = lambda links, outmost_links, index: [attrdict(
			arity = max(0, links[0].arity - 1),
			call = lambda z = None: copy_to(atoms['®'], variadic_link(links[0], (niladic_link(atoms['®']), z)))
		)]
	),
	'Ƭ': attrdict(
		condition = lambda links: links,
		quicklink = lambda links, outmost_links, index: [attrdict(
			arity = links[0].arity,
			call = lambda x = None, y = None: loop_until_loop(links[0], (x, y), return_all = True, vary_rarg = False)
		)]
	),
	'ƭ': attrdict(
		condition = lambda links: links and (
			(links[-1].arity == 0 and len(links) - 1 == links[-1].call()) or
			(links[-1].arity and len(links) == 2)),
		quicklink = tie
	),
	'¤': quickchain(0, 2),
	'$': quickchain(1, 2),
	'Ɗ': quickchain(1, 3),
	'Ʋ': quickchain(1, 4),
	'¥': quickchain(2, 2),
	'ɗ': quickchain(2, 3),
	'ʋ': quickchain(2, 4),
	'#': attrdict(
		condition = lambda links: len(links) == 2,
		quicklink = lambda links, outmost_links, index: ([links.pop(0)] if len(links) == 2 and links[0].arity == 0 else []) + [attrdict(
			arity = max_arity(links),
			call = lambda x = None, y = None: nfind(links, (x, y))
		)]
	),
	'?': attrdict(
		condition = lambda links: len(links) == 3,
		quicklink = lambda links, outmost_links, index: [attrdict(
			arity = max(link.arity for link in links),
			call = lambda x = None, y = None: variadic_link(links[0], (x, y)) if variadic_link(links[2], (x, y)) else variadic_link(links[1], (x, y))
		)]
	),
	'`': attrdict(
		condition = lambda links: links,
		quicklink = lambda links, outmost_links, index: [attrdict(
			arity = 1,
			call = lambda z: dyadic_link(links[0], (z, z))
		)]
	),
	'⁺': attrdict(
		condition = lambda links: links,
		quicklink = lambda links, outmost_links, index: links * 2
	),
	'С': attrdict(
		condition = lambda links: len(links) == 2,
		quicklink = lambda links, outmost_links, index: ([links.pop(0)] if len(links) == 2 and links[0].arity == 0 else []) + [attrdict(
			arity = max(link.arity for link in links),
			call = lambda x = None, y = None: ntimes(links, (x, y), cumulative = True)
		)]
	),
	'п': attrdict(
		condition = lambda links: len(links) == 2,
		quicklink = lambda links, outmost_links, index: [attrdict(
			arity = max(link.arity for link in links),
			call = lambda x = None, y = None: while_loop(links[0], links[1], (x, y), cumulative = True)
		)]
	),
	'Ðe': attrdict(
		condition = lambda links: links,
		quicklink = lambda links, outmost_links, index: [attrdict(
			arity = max(1, links[0].arity),
			call = lambda x, y = None: sparse(links[0], (x, y), range(2, len(x) + 2, 2), indices_literal = True)
		)]
	),
	'Ðf': attrdict(
		condition = lambda links: links,
		quicklink = lambda links, outmost_links, index: [attrdict(
			arity = links[0].arity,
			call = lambda x, y = None: list(filter(lambda t: variadic_link(links[0], (t, y)), iterable(x, make_range = True)))
		)]
	),
	'Ðḟ': attrdict(
		condition = lambda links: links,
		quicklink = lambda links, outmost_links, index: [attrdict(
			arity = links[0].arity,
			call = lambda x, y = None: list(itertools.filterfalse(lambda t: variadic_link(links[0], (t, y)), iterable(x, make_range = True)))
		)]
	),
	'ÐL': attrdict(
		condition = lambda links: links,
		quicklink = lambda links, outmost_links, index: [attrdict(
			arity = links[0].arity,
			call = lambda x = None, y = None: loop_until_loop(links[0], (x, y))
		)]
	),
	'ÐĿ': attrdict(
		condition = lambda links: links,
		quicklink = lambda links, outmost_links, index: [attrdict(
			arity = links[0].arity,
			call = lambda x = None, y = None: loop_until_loop(links[0], (x, y), return_all = True)
		)]
	),
	'ÐḶ': attrdict(
		condition = lambda links: links,
		quicklink = lambda links, outmost_links, index: [attrdict(
			arity = links[0].arity,
			call = lambda x = None, y = None: loop_until_loop(links[0], (x, y), return_loop = True)
		)]
	),
	'ÐṂ': attrdict(
		condition = lambda links: links,
		quicklink = lambda links, outmost_links, index: [attrdict(
			arity = links[0].arity,
			call = lambda x, y = None: extremes(min, links[0], (x, y))
		)]
	),
	'ÐṀ': attrdict(
		condition = lambda links: links,
		quicklink = lambda links, outmost_links, index: [attrdict(
			arity = links[0].arity,
			call = lambda x, y = None: extremes(max, links[0], (x, y))
		)]
	),
	'Ðo': attrdict(
		condition = lambda links: links,
		quicklink = lambda links, outmost_links, index: [attrdict(
			arity = max(1, links[0].arity),
			call = lambda x, y = None: sparse(links[0], (x, y), range(1, len(x) + 1, 2), indices_literal = True)
		)]
	),
}

hypers = {
	'"': lambda link, none = None: attrdict(
		arity = 2,
		call = lambda x, y: [dyadic_link(link, (u, v)) for u, v in zip(iterable(x), iterable(y))] + iterable(x)[len(iterable(y)) :] + iterable(y)[len(iterable(x)) :]
	),
	"'": lambda link, none = None: attrdict(
		arity = link.arity,
		call = lambda x = None, y = None: variadic_link(link, (x, y), flat = True, lflat = True, rflat = True)
	),
	'@': lambda link, none = None: attrdict(
		arity = 2,
		call = lambda x, y: dyadic_link(link, (y, x))
	),
	'{': lambda link, none = None: attrdict(
		arity = 2,
		call = lambda x, y: monadic_link(link, x)
	),
	'}': lambda link, none = None: attrdict(
		arity = 2,
		call = lambda x, y: monadic_link(link, y)
	),
	'€': lambda link, none = None: attrdict(
		arity = max(1, link.arity),
		call = lambda x, y = None: [variadic_link(link, (t, y)) for t in iterable(x, make_range = True)]
	),
	'Þ': lambda link, none = None: attrdict(
		arity = link.arity,
		call = lambda x, y = None: sorted(iterable(x, make_range = True), key=lambda t: variadic_link(link, (t, y)))
	),
	'þ': lambda link, none = None: attrdict(
		arity = 2,
		call = lambda x, y: [[dyadic_link(link, (u, v)) for u in iterable(x, make_range = True)] for v in iterable(y, make_range = True)]
	),
	'Ѐ': lambda link, none = None: attrdict(
		arity = max(1, link.arity),
		call = lambda x, y = None: [variadic_link(link, (x, t)) for t in iterable(y, make_range = True)]
	),
	'£': lambda index, links: attrdict(
		arity = index.arity,
		call = lambda x = None, y = None: niladic_chain(links[(variadic_link(index, (x, y)) - 1) % (len(links) - 1)])
	),
	'Ŀ': lambda index, links: attrdict(
		arity = max(1, index.arity),
		call = lambda x, y = None: monadic_chain(links[(variadic_link(index, (x, y)) - 1) % (len(links) - 1)], x)
	),
	'ŀ': lambda index, links: attrdict(
		arity = 2,
		call = lambda x, y: dyadic_chain(links[(variadic_link(index, (x, y)) - 1) % (len(links) - 1)], (x, y))
	)
}

# Aliases

quicks['Ƈ'] = quicks['Ðf']
hypers['Ɱ'] = hypers['Ѐ']
atoms ['Ẓ'] = atoms ['ÆP']

chain_separators = {
	'ø': (0, '', True),
	'µ': (1, '', True),
	')': (1, '€', True),
	'ð': (2, '', True),
	'ɓ': (2, '', False)
}
default_chain_separation = (-1, '', True)
str_arities = ''.join(chain_separators.keys())
str_strings = '“[^«»‘’”]*[«»‘’”]?'
str_charlit = '”.'
str_chrpair = '⁾..'
str_intpair = '⁽..'
str_realdec = '(?:0|-(?![1-9.])|-?\d*\.\d*|-?\d+)'
str_realnum = str_realdec.join(['(?:', '?ȷ', '?|', ')'])
str_complex = str_realnum.join(['(?:', '?ı', '?|', ')'])
str_literal = '(?:%s)' % '|'.join([str_strings, str_charlit, str_chrpair, str_complex, str_intpair])
str_litlist = '\[*' + str_literal + '(?:(?:\]*,\[*)' + str_literal + ')*' + '\]*'
str_nonlits = '|'.join(map(re.escape, list(atoms) + list(quicks) + list(hypers)))

regex_chain = re.compile('(?:^(?:' + str_nonlits + '|' + str_litlist + '| )+|[' + str_arities + '])(?:' + str_nonlits + '|' + str_litlist + '| )*')
regex_liter = re.compile(str_literal)
regex_token = re.compile(str_nonlits + '|' + str_litlist)
regex_flink = re.compile('(?=.)(?:[' + str_arities + ']|' + str_nonlits + '|' + str_litlist + '| )*¶?')