text: codepage  = "λƛ¬∧⟑∨⟇÷×«\n»°•ß†€"
  codepage += "½∆ø↔¢⌐æʀʁɾɽÞƈ∞¨ "
  codepage += "!\"#$%&'()*+,-./01"
  codepage += "23456789:;<=>?@A"
  codepage += "BCDEFGHIJKLMNOPQ"
  codepage += "RSTUVWXYZ[\\]`^_abc"
  codepage += "defghijklmnopqrs"
  codepage += "tuvwxyz{|}~↑↓∴∵›"
  codepage += "‹∷¤ð→←βτȧḃċḋėḟġḣ"
  codepage += "ḭŀṁṅȯṗṙṡṫẇẋẏż√⟨⟩"
  codepage += "‛₀₁₂₃₄₅₆₇₈¶⁋§ε¡"
  codepage += "∑¦≈µȦḂĊḊĖḞĠḢİĿṀṄ"
  codepage += "ȮṖṘṠṪẆẊẎŻ₌₍⁰¹²∇⌈"
  codepage += "⌊¯±₴…□↳↲⋏⋎꘍ꜝ℅≤≥"
  codepage += "≠⁼ƒɖ∪∩⊍£¥⇧⇩ǍǎǏǐǑ"
  codepage += "ǒǓǔ⁽‡≬⁺↵⅛¼¾Π„‟"
  
  assert len(codepage) == 256
   
  command_dict = {
      "¬": ("stack.append(int(not pop(stack)))", 1),
      "∧": ("rhs, lhs = pop(stack, 2); stack.append(lhs and rhs)", 2),
      "⟑": ("rhs, lhs = pop(stack, 2); stack.append(rhs and lhs)", 2),
      "∨": ("rhs, lhs = pop(stack, 2); stack.append(lhs or rhs)", 2),
      "⟇": ("rhs, lhs = pop(stack, 2); stack.append(rhs or lhs)", 2),
      "÷": ("for item in iterable(pop(stack)): stack.append(item)", 1),
      "•": ("rhs, lhs = pop(stack, 2); stack.append(log(lhs, rhs))", 2),
      "†": ("fn = pop(stack); stack += function_call(fn, stack)", 1),
      "€": ("rhs, lhs = pop(stack, 2); stack.append(split(lhs, rhs))", 2),
      "½": ("stack.append(halve(pop(stack)))", 1),
      "↔": ("rhs, lhs = pop(stack, 2); stack.append(combinations_replace_generate(lhs, rhs))", 2),
      "⌐": ("stack.append(complement(pop(stack)))", 1),
      "æ": ("stack.append(is_prime(pop(stack)))", 1),
      "ʀ": ("stack.append(orderless_range(0, int(add(pop(stack), 1))))", 1),
      "ʁ": ("stack.append(orderless_range(0, int(pop(stack))))", 1),
      "ɾ": ("stack.append(orderless_range(1, int(add(pop(stack), 1))))", 1),
      "ɽ": ("stack.append(orderless_range(1, int(pop(stack))))", 1),
      "ƈ": ("rhs, lhs = pop(stack, 2); stack.append(ncr(lhs, rhs))", 2),
      "∞": ("stack.append(Generator(lambda x: x))", 0),
      "!": ("stack.append(len(stack))", 0),
      '"': ("rhs, lhs = pop(stack, 2); stack.append([lhs, rhs])", 2),
      "$": ("top, over = pop(stack, 2); stack.append(top); stack.append(over)", 2),
      "%": ("rhs, lhs = pop(stack, 2); stack.append(modulo(lhs, rhs))", 2),
      "*": ("rhs, lhs = pop(stack, 2); stack.append(multiply(lhs, rhs))", 2),
      "+": ("rhs, lhs = pop(stack, 2); stack.append(add(lhs, rhs))", 2),
      ",": ("VY_print(pop(stack))", 1),
      "-": ("rhs, lhs = pop(stack, 2); stack.append(subtract(lhs, rhs))", 2),
      "/": ("rhs, lhs = pop(stack, 2); stack.append(divide(lhs, rhs))", 2),
      ":": ("temp = pop(stack); stack.append(temp); stack.append(deref(temp))", 1),
      "^": ("stack = stack[::-1]", 0),
      "_": ("pop(stack)", 1),
      "<": ("rhs, lhs = pop(stack, 2); stack.append(compare(lhs, rhs, Comparitors.LESS_THAN))", 2),
      ">": ("rhs, lhs = pop(stack, 2); stack.append(compare(lhs, rhs, Comparitors.GREATER_THAN))", 2),
      "=": ("rhs, lhs = pop(stack, 2); stack.append(compare(lhs, rhs, Comparitors.EQUALS))", 2),
      "?": ("stack.append(get_input(0))", 0),
      "A": ("stack.append(int(all(iterable(pop(stack)))))", 1),
      "B": ("stack.append(VY_int(pop(stack), 2))", 1),
      "C": ("stack.append(chrord(pop(stack)))", 1),
      "D": ("temp = pop(stack); stack.append(temp); stack.append(deref(temp)); stack.append(deref(stack[-1]))", 1),
      "E": ("stack.append(VY_eval(pop(stack)))", 1),
      "F": ("fn, vector = pop(stack, 2); stack.append(VY_filter(fn, vector))", 2),
      "G": ("stack.append(VY_max(iterable(pop(stack))))", 1),
      "H": ("stack.append(VY_int(pop(stack), 16))", 1),
      "I": ("stack.append(VY_int(pop(stack)))", 1),
      "J": ("rhs, lhs = pop(stack, 2); stack.append(join(lhs, rhs))", 2),
      "K": ("stack.append(divisors_of(pop(stack)))", 1),
      "L": ("top = pop(stack); stack.append(len(iterable(top)))", 1),
      "M": ("fn, vector = pop(stack, 2); stack.append(VY_map(fn, vector))", 2),
      "N": ("stack.append(negate(pop(stack)))", 1),
      "O": ("needle, haystack = pop(stack, 2); stack.append(iterable(haystack).count(needle))", 2),
      "P": ("rhs, lhs = pop(stack, 2); stack.append(VY_str(lhs).strip(VY_str(rhs)))", 2),
      "Q": ("exit()", 0),
      "R": ("fn, vector = pop(stack, 2); stack += VY_reduce(fn, vector)", 2),
      "S": ("stack.append(VY_str(pop(stack)))", 1),
      "T": ("stack.append([i for (i, x) in enumerate(pop(stack)) if bool(x)])", 1),
      "U": ("stack.append(Generator(uniquify(pop(stack))))", 1),
      "V": ("replacement, needle, haystack = pop(stack, 3); stack.append(replace(haystack, needle, replacement))", 3),
      "W": ("stack = [deref(stack)]", 0),
      "X": ("context_level += 1", 0),
      "Y": ("rhs, lhs = pop(stack, 2); stack.append(interleave(lhs, rhs))", 2),
      "Z": ("rhs, lhs = pop(stack, 2); stack.append(Generator(VY_zip(iterable(lhs), iterable(rhs))))", 2),
      "a": ("stack.append(int(any(iterable(pop(stack)))))", 1),
      "b": ("stack.append(VY_bin(pop(stack)))", 1),
      "c": ("needle, haystack = pop(stack, 2); haystack = iterable(haystack, str)\nif type(haystack) is str: needle = VY_str(needle)\nstack.append(int(needle in iterable(haystack, str)))", 2),
      "d": ("stack.append(multiply(pop(stack), 2))", 1),
      "e": ("rhs, lhs = pop(stack, 2); stack.append(exponate(lhs, rhs))", 2),
      "f": ("stack.append(flatten(iterable(pop(stack))))", 1),
      "g": ("stack.append(VY_min(iterable(pop(stack))))", 1),
      "h": ("stack.append(iterable(pop(stack))[0])", 1),
      "i": ("rhs, lhs = pop(stack, 2)\nstack.append(index(lhs, rhs))", 2),
      "j": ("rhs, lhs = pop(stack, 2); stack.append(join_on(lhs, rhs))", 2),
      "l": ("rhs, lhs = pop(stack, 2); stack.append(nwise_pair(lhs, rhs))", 2),
      "m": ("item = pop(stack); stack.append(mirror(item))", 1),
      "n": ("stack.append(context_values[context_level % len(context_values)])", 0),
      "o": ("needle, haystack = pop(stack, 2); stack.append(remove(haystack, needle))", 2),
      "p": ("rhs, lhs = pop(stack, 2); stack.append(prepend(lhs, rhs))", 2),
      "q": ("stack.append(uneval(VY_str(pop(stack))))", 1),
      "r": ("rhs, lhs = pop(stack, 2); stack.append(orderless_range(lhs, rhs))", 2),
      "s": ("stack.append(VY_sorted(pop(stack)))", 1),
      "t": ("stack.append(iterable(pop(stack))[-1])", 1),
      "u": ("stack.append(-1)", 0),
      "w": ("stack.append([pop(stack)])", 1),
      "x": ("stack += this_function(stack)", 0),
      "y": ("stack += uninterleave(pop(stack))", 1),
      "z": ("fn, vector = pop(stack, 2); stack += VY_zipmap(fn, vector)", 2),
      "↑": ("stack.append(max(pop(stack), key=lambda x: x[-1]))", 1),
      "↓": ("stack.append(min(pop(stack), key=lambda x: x[-1]))", 1),
      "∴": ("rhs, lhs = pop(stack, 2); stack.append(VY_max(lhs, rhs))", 2),
      "∵": ("rhs, lhs = pop(stack, 2); stack.append(VY_min(lhs, rhs))", 2),
      "β": ("alphabet, number = pop(stack, 2); stack.append(utilities.to_ten(number, alphabet))", 2),
      "τ": ("alphabet, number = pop(stack, 2); stack.append(utilities.from_ten(number, alphabet))", 2),
      "›": ("stack.append(add(pop(stack), 1))", 1),
      "‹": ("stack.append(subtract(pop(stack), 1))", 1),
      "∷": ("stack.append(modulo(pop(stack), 2))", 1),
      "¤": ("stack.append('')", 0),
      "ð": ("stack.append(' ')", 0),
      "ȧ": ("stack.append(VY_abs(pop(stack)))", 1),
      "ḃ": ("stack.append(int(not compare(pop(stack), 0, Comparitors.EQUALS)))", 1),
      "ċ": ("stack.append(compare(pop(stack), 1, Comparitors.NOT_EQUALS))", 1),
      "ḋ": ("rhs, lhs = pop(stack, 2); stack.append(VY_divmod(lhs, rhs))", 2), # Dereference because generators could accidentally get exhausted.
      "ė": ("stack.append(Generator(enumerate(iterable(pop(stack)))))", 1),
      "ḟ": ("rhs, lhs = pop(stack, 2); stack.append(find(lhs, rhs))", 2),
      "ġ": ("rhs = pop(stack)\nif VY_type(rhs) in [list, Generator]: stack.append(gcd(rhs))\nelse: stack.append(gcd(pop(stack), rhs))", 1),
      "ḣ": ("top = iterable(pop(stack)); stack.append(top[0]); stack.append(top[1:])", 1),
      "ḭ": ("rhs, lhs = pop(stack, 2); stack.append(integer_divide(lhs, rhs))", 2),
      "ŀ": ("start, needle, haystack = pop(stack, 3); stack.append(find(haystack, needle, start))", 3),
      "ṁ": ("top = iterable(pop(stack)); stack.append(divide(summate(top), len(top)))", 1),
      "ṅ": ("stack.append(first_n(pop(stack)))", 1),
      "ȯ": ("n, fn = pop(stack, 2); stack.append(first_n(fn, n))", 2),
      "ṗ": ("stack.append(powerset(iterable(pop(stack))))", 1),
      "ṙ": ("stack.append(VY_round(pop(stack)))", 1),
      "ṡ": ("fn , vector = pop(stack, 2); stack.append(VY_sorted(vector, fn))", 2),
      "ṫ": ("vector = iterable(pop(stack)); stack.append(vector[:-1]); stack.append(vector[-1])", 1),
      "ẇ": ("rhs, lhs = pop(stack, 2); stack.append(wrap(lhs, rhs))", 2),
      "ẋ": ("rhs, lhs = pop(stack, 2); main = None;\nif VY_type(lhs) is Function: main = pop(stack)\nstack.append(repeat(lhs, rhs, main))", 2),
      "ẏ": ("obj = iterable(pop(stack)); stack.append(Generator(range(0, len(obj))))", 1),
      "ż": ("obj = iterable(pop(stack)); stack.append(Generator(range(1, len(obj) + 1)))", 1),
      "√": ("stack.append(exponate(pop(stack), 0.5))", 1),
      "₀": ("stack.append(10)", 0),
      "₁": ("stack.append(100)", 0),
      "₂": ("stack.append(const_divisibility(pop(stack), 2, lambda item: len(item) % 2 == 0))", 1),
      "₃": ("stack.append(const_divisibility(pop(stack), 3, lambda item: len(item) == 1))", 1),
      "₄": ("stack.append(26)", 0),
      "₅": ("top = pop(stack); res = const_divisibility(top, 5, lambda item: (top, len(item)))\nif type(res) is tuple: stack += list(res)\nelse: stack.append(res)", 1),
      "₆": ("stack.append(64)", 0),
      "₇": ("stack.append(128)", 0),
      "₈": ("stack.append(256)", 0),
      "¶": ("stack.append('\\n')", 0),
      "⁋": ("stack.append(osabie_newline_join(pop(stack)))", 1),
      "§": ("stack.append(vertical_join(pop(stack)))", 1),
      "ε": ("padding, vector = pop(stack, 2); stack.append(vertical_join(vector, padding))", 2),
      "¡": ("stack.append(factorial(pop(stack)))", 1),
      "∑": ("stack.append(summate(pop(stack)))", 1),
      "¦": ("stack.append(cumulative_sum(iterable(pop(stack))))", 1),
      "≈": ("stack.append(int(len(set(iterable(pop(stack)))) == 1))", 1),
      "Ȧ": ("value, lst_index, vector = pop(stack, 3); stack.append(assigned(iterable(vector), lst_index, value))", 3),
      "Ḃ": ("stack += bifuricate(pop(stack))", 1),
      "Ċ": ("stack.append(counts(pop(stack)))", 1),
      "Ḋ": ("rhs, lhs = pop(stack, 2); ret = is_divisble(lhs, rhs)\nif type(ret) is tuple: stack += list(ret)\nelse: stack.append(ret)", 2),
      "Ė": ("stack += VY_exec(pop(stack))", 1),
      "Ḟ": ("""top = pop(stack)
  if VY_type(top) is Number:
      limit = int(top); vector = pop(stack)
  else:
      limit = -1; vector = top
  fn = pop(stack)
  stack.append(Generator(fn, limit=limit, initial=iterable(vector)))
  """, 2),
      "Ġ": ("stack.append(group_consecutive(iterable(pop(stack))))", 1),
      "Ḣ": ("stack.append(iterable(pop(stack))[1:])", 1),
      "İ": ("indexes, vector = pop(stack, 2); stack.append(indexed_into(vector, indexes))", 2),
      "Ŀ": ("new, original, value = pop(stack, 3)\nif Function in map(type, (new, original, value)): stack.append(repeat_no_collect(value, original, new))\nelse: stack.append(transliterate(iterable(original, str), iterable(new, str), iterable(value, str)))", 3),
      "Ṁ": ("item, index, vector = pop(stack, 3);\nif Function in map(type, (item, index, vector)): stack.append(map_every_n(vector, item, index))\nelse: stack.append(inserted(vector, item, index))", 3),
      "Ṅ": ("top = pop(stack);\nif VY_type(top) == Number:stack.append(Generator(partition(top)))\nelse: stack.append(' '.join([VY_str(x) for x in top]))", 1), #---------------------------
      "Ȯ": ("if len(stack) >= 2: stack.append(stack[-2])\nelse: stack.append(get_input(0))", 0),
      "Ṗ": ("stack.append(Generator(permutations(iterable(pop(stack)))))", 1),
      "Ṙ": ("stack.append(reverse(pop(stack)))", 1),
      "Ṡ": ("stack = [summate(stack)]", 0),
      "Ṫ": ("stack.append(iterable(pop(stack), str)[:-1])", 1),
      "Ẇ": ("rhs, lhs = pop(stack, 2); stack.append(split(lhs, rhs, True))", 2),
      "Ẋ": ("rhs, lhs = pop(stack, 2); stack.append(cartesian_product(lhs, rhs))", 2),
      "Ẏ": ("index, vector = pop(stack, 2); stack.append(one_argument_tail_index(vector, index, 0))", 2),
      "Ż": ("index, vector = pop(stack, 2); stack.append(one_argument_tail_index(vector, index, 1))", 2),
      "⁰": ("stack.append(input_values[0][0][-1])", 0),
      "¹": ("stack.append(input_values[0][0][-2])", 0),
      "²": ("x = pop(stack); stack.append(square(x))", 1),
      "∇": ("c, b, a = pop(stack, 3); stack.append(c); stack.append(a); stack.append(b)", 3),
      "⌈": ("stack.append(ceiling(pop(stack)))", 1),
      "⌊": ("stack.append(floor(pop(stack)))", 1),
      "¯": ("stack.append(deltas(pop(stack)))", 1),
      "±": ("stack.append(sign_of(pop(stack)))", 1),
      "₴": ("VY_print(pop(stack), end='')", 1),
      "…": ("top = pop(stack); stack.append(top); VY_print(top)", 0),
      "□": ("if inputs: stack.append(inputs)\nelse:\n    s, x = [], input()\n    while x:\n        s.append(Vy_eval(x)); x = input()", 0),
      "↳": ("rhs, lhs = pop(stack, 2); stack.append(rshift(lhs, rhs))", 2),
      "↲": ("rhs, lhs = pop(stack, 2); stack.append(lshift(lhs, rhs))", 2),
      "⋏": ("rhs, lhs = pop(stack, 2); stack.append(bit_and(lhs, rhs))", 2),
      "⋎": ("rhs, lhs = pop(stack, 2); stack.append(bit_or(lhs, rhs))", 2),
      "꘍": ("rhs, lhs = pop(stack, 2); stack.append(bit_xor(lhs, rhs))", 2),
      "ꜝ": ("stack.append(bit_not(pop(stack)))", 1),
      "℅": ("stack.append(random.choice(iterable(pop(stack))))", 1),
      "≤": ("rhs, lhs = pop(stack, 2); stack.append(compare(lhs, rhs, Comparitors.LESS_THAN_EQUALS))", 2),
      "≥": ("rhs, lhs = pop(stack, 2); stack.append(compare(lhs, rhs, Comparitors.GREATER_THAN_EQUALS))", 2),
      "≠": ("rhs, lhs = pop(stack, 2); stack.append(int(deref(lhs) != deref(rhs)))", 2),
      "⁼": ("rhs, lhs = pop(stack, 2); stack.append(int(deref(lhs) == deref(rhs)))", 2),
      "ƒ": ("stack.append(fractionify(pop(stack)))", 1),
      "ɖ": ("stack.append(decimalify(pop(stack)))", 1),
      "×": ("stack.append('*')", 0),
      "∪": ("rhs, lhs = pop(stack, 2); stack.append(set_union(lhs, rhs))", 2),
      "∩": ("rhs, lhs = pop(stack, 2); stack.append(set_intersection(lhs, rhs))", 2),
      "⊍": ("rhs, lhs = pop(stack, 2); stack.append(set_caret(lhs, rhs))", 2),
      "£": ("register = pop(stack)", 1),
      "¥": ("stack.append(register)", 0),
      "⇧": ("stack.append(graded(pop(stack)))", 1),
      "⇩": ("stack.append(graded_down(pop(stack)))", 1),
      "Ǎ": ("stack.append(two_power(pop(stack)))", 1),
      "ǎ": ("stack.append(nth_prime(pop(stack)))", 1),
      "Ǐ": ("stack.append(prime_factors(pop(stack)))", 1),
      "ǐ": ("stack.append(all_prime_factors(pop(stack)))", 1),
      "Ǒ": ("rhs, lhs = pop(stack, 2); stack.append(order(lhs, rhs))", 2),
      "ǒ": ("stack.append(is_empty(pop(stack)))", 1),
      "Ǔ": ("rhs, lhs = pop(stack, 2); stack += overloaded_iterable_shift(lhs, rhs, ShiftDirections.LEFT)", 2),
      "ǔ": ("rhs, lhs = pop(stack, 2); stack += overloaded_iterable_shift(lhs, rhs, ShiftDirections.RIGHT)", 2),
      "¢": ("replacement, needle, haystack = pop(stack, 3); stack.append(infinite_replace(haystack, needle, replacement))", 3),
      "↵": ("stack.append(split_newlines_or_pow_10(pop(stack)))", 1),
      "⅛": ("global_stack.append(pop(stack))", 1),
      "¼": ("stack.append(pop(global_stack))", 0),
      "¾": ("stack.append(deref(global_stack))", 0),
      "Π": ("stack.append(product(iterable(pop(stack))))", 1),
      "„": ("stack = iterable_shift(stack, ShiftDirections.LEFT)", 0),
      '‟': ("stack = iterable_shift(stack, ShiftDirections.RIGHT)", 0)
  }
  
  math_command_dict = {
      "S": ("arg = pop(stack); stack.append(vectorise(math.asin, arg))", 1),
      "C": ("arg = pop(stack); stack.append(vectorise(math.acos, arg))", 1),
      "T": ("arg = pop(stack); stack.append(vectorise(math.atan, arg))", 1),
      "q": ("coeff_a, coeff_b = pop(stack, 2); stack.append(polynomial([coeff_a, coeff_b, 0]))", 2),
      "Q": ("coeff_b, coeff_c = pop(stack, 2); stack.append(polynomial([1, coeff_b, coeff_c]))", 2),
      "P": ("coeff = iterable(pop(stack)); stack.append(polynomial(coeff));", 1),
      "s": ("arg = pop(stack); stack.append(vectorise(math.sin, arg))", 1),
      "c": ("arg = pop(stack); stack.append(vectorise(math.cos, arg))", 1),
      "t": ("arg = pop(stack); stack.append(vectorise(math.tan, arg))", 1),
      "ƈ": ("rhs, lhs = pop(stack, 2); stack.append(divide(factorial(lhs), factorial(subtract(lhs, rhs))))", 2),
      "±": ("rhs, lhs = pop(stack, 2); stack.append(vectorise(math.copysign, lhs, rhs))", 2),
      "K": ("arg = pop(stack); stack.append(summate(join(0, divisors_of(arg)[:-1])))", 1),
      "²": ("arg = pop(stack); stack.append(is_square(arg))", 1),
      "e": ("arg = pop(stack); stack.append(vectorise(math.exp, arg))", 1),
      "E": ("arg = pop(stack); stack.append(vectorise(math.expm1, arg))", 1),
      "L": ("arg = pop(stack); stack.append(vectorise(math.log, arg))", 1),
      "l": ("arg = pop(stack); stack.append(vectorise(math.log2, arg))", 1),
      "τ": ("arg = pop(stack); stack.append(vectorise(math.log10, arg))", 1),
      "d": ("rhs, lhs = pop(stack, 2); stack.append(distance_between(lhs, rhs))", 2),
      "D": ("arg = pop(stack); stack.append(vectorise(math.degrees, arg))", 1),
      "R": ("arg = pop(stack); stack.append(vectorise(math.radians, arg))", 1),
      "≤": ("arg = pop(stack); stack.append(compare(VY_abs(arg), 1, Comparitors.LESS_THAN_EQUALS))", 1),
      "Ṗ": ("stack.append(next_prime(pop(stack)))", 1),
      "ṗ": ("stack.append(prev_prime(pop(stack)))", 1),
      "p": ("stack.append(closest_prime(pop(stack)))", 1),
      "ṙ": ("stack.append(unsympy(sympy.prod(map(sympy.poly('x').__sub__, iterable(pop(stack)))).all_coeffs()[::-1]))",1),
      "Ṙ": ("stack.append(random.random())", 0),
      "W": ("rhs, lhs = pop(stack, 2); stack.append(vectorise(round, lhs, rhs))", 2) # if you think I'm making this work with strings, then you can go commit utter go awayance. smh.
  }
  
  string_command_dict = {
      "o": ("needle, haystack = pop(stack, 2); stack.append(infinite_replace(haystack, needle, ''))", 2),
      "V": ("replacement, needle, haystack = pop(stack, 3); stack.append(infinite_replace(haystack, needle, replacement))", 3),
      "c": ("value = pop(stack); stack.append('«' + utilities.from_ten(utilities.to_ten(value, utilities.base27alphabet), encoding.codepage_string_compress) + '«')", 1),
      "C": ("number = pop(stack); stack.append('»' + utilities.from_ten(number, encoding.codepage_number_compress) + '»')", 1),
      "Ċ": ("stack.append(centre(pop(stack)))", 1),
      "m": ("stack.append(palindromise(iterable(pop(stack))))", 1),
      "e": ("stack.append(run_length_encode(iterable(pop(stack), str)))", 1), 
      "d": ("stack.append(run_length_decode(pop(stack)))", 1),
      "D": ("stack.append(dictionary_compress(pop(stack)))", 1),
      "W": ("stack.append(split_on_words(VY_str(pop(stack))))", 1),
      "ṙ": ("replacent, pattern, source = pop(stack, 3); stack.append(regex_replace(VY_str(source), VY_str(pattern), replacent))", 3),
      "p": ("rhs, lhs = pop(stack, 2); stack.append(int(str(lhs).startswith(str(rhs))))", 2),
      "P": ("rhs, lhs = pop(stack, 2); stack.append(pluralise(lhs, rhs))", 2),
      "ṁ": ("stack.append(vertical_mirror(pop(stack)))", 1),
      "Ṁ": ("stack.append(vertical_mirror(pop(stack), ['()[]{}<>/\\\\', ')(][}{><\\\\/']))", 1),
      "¦": ("rhs, lhs = pop(stack, 2); stack.append(vertical_mirror(lhs, rhs))", 2)
  }
  
  list_command_dict = {
      "…": ("value, vector = pop(stack, 2); stack.append(distribute(vector, value))", 2),
      "↓": ("fn, vector = pop(stack, 2); stack.append(min(VY_zipmap(fn, vector), key=lambda x: x[-1]))", 2),
      "↑": ("fn, vector = pop(stack, 2); stack.append(max(VY_zipmap(fn, vector), key=lambda x: x[-1]))", 2),
      "×": ("vector = pop(stack); stack.append(all_combinations(vector));", 1),
      "F": ("stack.append(Generator(fibonacci(), is_numeric_sequence=True))", 0),
      "!": ("stack.append(Generator(factorials(), is_numeric_sequence=True))", 0),
      "U": ("stack.append(nub_sieve(iterable(pop(stack))))", 1),
      "T": ("stack.append(transpose(pop(stack)))", 1),
      "D": ("stack.append(Generator(diagonals(iterable(pop(stack), list))))", 1),
      "S": ("stack.append(Generator(sublists(iterable(pop(stack), list))))", 1),
      "Ṫ": ("rhs, lhs = pop(stack, 2); print(lhs, rhs) ;stack.append(Generator(itertools.zip_longest(*iterable(lhs), fillvalue=rhs)))", 2),
      "℅": ("top = iterable(pop(stack)); stack.append(random.sample(top, len(top)))", 1),
      "•": ("rhs, lhs = pop(stack, 2); stack.append(dot_product(iterable(lhs), iterable(rhs)))", 2),
      "Ṁ": ("rhs, lhs = pop(stack, 2); stack.append(matrix_multiply(iterable(lhs), iterable(rhs)))", 2),
      "Ḋ": ("stack.append(determinant(pop(stack)))", 1),
      "/": ("stack.append(diagonal_main(deref(pop(stack))))", 1),
      "\\": ("stack.append(diagonal_anti(deref(pop(stack))))", 1),
      "R": ("fn, vector = pop(stack, 2); stack.append(foldl_rows(fn, deref(vector)))", 2),
      "C": ("fn, vector = pop(stack, 2); stack.append(foldl_cols(fn, deref(vector)))", 2)
  }
  
  misc_command_dict = {
      "U": ("if not online_version: stack.append(request(pop(stack)))", 1),
      "M": ("function, indexes, original = pop(stack, 3); stack.append(map_at(function, iterable(original), iterable(indexes)))", 3),
      ",": ("VY_print(pop(stack), end=' ')", 1),
      "…": ("top = pop(stack); stack.append(top); VY_print(top, end=' ')", 1),
      "t": ("vectorise(time.sleep, pop(stack))")
  
  }
  