diff --git a/src/build/lib/thunno2/__init__.py b/src/build/lib/thunno2/__init__.py new file mode 100644 index 0000000..630741f --- /dev/null +++ b/src/build/lib/thunno2/__init__.py @@ -0,0 +1 @@ +from thunno2 import * diff --git a/src/build/lib/thunno2/autoexplanation.py b/src/build/lib/thunno2/autoexplanation.py new file mode 100644 index 0000000..46152e0 --- /dev/null +++ b/src/build/lib/thunno2/autoexplanation.py @@ -0,0 +1,97 @@ +from thunno2.tokens import * +from thunno2.lexer import * + + +def auto_explain(code, indent=0, comment_indent=0, tkn=True, post_indent=0): + if tkn: + _, lexed = tokenise(code) + else: + lexed = code + ret = "" + index = 0 + for chars, info, other in lexed: + if "single function" in info or info in ( + "outer product", + "apply to x", + "apply to y", + "execute without popping", + "apply to every nth item", + ): + if len(chars) == 2: + i = 1 + elif len(chars) == 4: + i = 2 + else: + if chars[-2] in DIGRAPHS: + i = 2 + else: + i = 1 + ret += ( + " " * (index + indent) + + chars[:-i] + + (len(code) - index - len(chars) + i) * " " + + post_indent * " " + + " # " + + " " * comment_indent + + info + + ":\n" + + " " * (index + indent + len(chars) - i) + + chars[-i:] + + (len(code) - index - len(chars)) * " " + + post_indent * " " + + " # " + + " " * comment_indent + ) + ret += other.keywords[0] + "\n" + else: + ret += ( + " " * (index + indent) + + chars + + (len(code) - index - len(chars)) * " " + + post_indent * " " + + " # " + + " " * comment_indent + ) + if isinstance(other, list): + ret += info + ":\n" + ret += auto_explain( + code[index + 1 :], index + indent + 1, comment_indent + 1 + ) + elif info == "if statement": + t, f = other + ret += info + ":\n" + ret += auto_explain( + t, + index + indent + 1, + comment_indent + 1, + False, + len(code) - len("".join(x[0] for x in t)) - index - 1, + ) + index += len("".join(x[0] for x in t)) + 1 + if f: + ret += ( + " " * (index + indent) + + ":" + + (len(code) - index - 1) * " " + + post_indent * " " + + " # " + + " " * comment_indent + + "else:\n" + ) + ret += auto_explain( + f, + index + indent + 1, + comment_indent + 1, + False, + len(code) - len("".join(x[0] for x in f)) - index - 1, + ) + index += len("".join(x[0] for x in f)) + 1 + elif info not in ("command", "digraph"): + ret += info + "\n" + else: + ret += ( + dict([(j, i) for i, j in full_list[::-1]])[chars].replace("_", " ") + + "\n" + ) + index += len(chars) + return ret diff --git a/src/build/lib/thunno2/canvas.py b/src/build/lib/thunno2/canvas.py new file mode 100644 index 0000000..2f3ef0d --- /dev/null +++ b/src/build/lib/thunno2/canvas.py @@ -0,0 +1,53 @@ +class Canvas: + def __init__(self): + self.board = [] + self.x, self.y = 0, 0 + self.len_x, self.len_y = 0, 0 + + def __str__(self): + return "\n".join(map("".join, self.board)) + + def add_xy(self, d): + x, y = [(0, -1), (1, -1), (1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1)][d] + self.x += x + self.y += y + + def extend(self, direction): + if direction == 0: + self.board = [[" " for _ in range(self.len_x)], *self.board] + self.len_y += 1 + elif direction == 1: + self.board = [[*row, " "] for row in self.board] + self.len_x += 1 + elif direction == 2: + self.board = [*self.board, [" " for _ in range(self.len_x)]] + self.len_y += 1 + elif direction == 3: + self.board = [[" ", *row] for row in self.board] + self.len_x += 1 + + def decide_extend(self): + if self.y < 0: + self.y = 0 + self.extend(0) + if self.x >= self.len_x: + self.extend(1) + if self.y >= self.len_y: + self.extend(2) + if self.x < 0: + self.x = 0 + self.extend(3) + + def draw(self, text, dirs): + for c, d in zip(text, dirs): + self.add_xy(d) + self.decide_extend() + self.board[self.y][self.x] = c + + def clear(self): + self.board = [] + self.x, self.y = 0, 0 + self.len_x, self.len_y = 0, 0 + + +canvas = Canvas() diff --git a/src/build/lib/thunno2/codepage.py b/src/build/lib/thunno2/codepage.py new file mode 100644 index 0000000..4226427 --- /dev/null +++ b/src/build/lib/thunno2/codepage.py @@ -0,0 +1,41 @@ +# This codepage is exactly the same as the Jelly codepage +# (https://github.com/DennisMitchell/jellylanguage/blob/master/jelly/interpreter.py#L7) + +"""The 256-character Single Byte Character Set for encoding Thunno 2 programs (https://en.wikipedia.org/wiki/SBCS)""" + +CODEPAGE = ( + r"""¡¢£¤¥¦©¬®µ½¿€ÆÇÐÑ×ØŒÞßæçðıȷñ÷øœþ !"#$%&'()*+,-./0123456789:;<=>?""" + r"""@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~¶""" + r"""°¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾ƁƇƊƑƓƘⱮƝƤƬƲȤɓƈɗƒɠɦƙɱɲƥʠɼʂƭʋȥẠḄḌẸḤỊḲḶṂṆỌṚṢṬỤṾẈỴẒȦḂ""" + r"""ĊḊĖḞĠḢİĿṀṄȮṖṘṠṪẆẊẎŻạḅḍẹḥịḳḷṃṇọṛṣṭ§Äẉỵẓȧḃċḋėḟġḣŀṁṅȯṗṙṡṫẇẋẏż«»‘’“”""" +) + +assert len(CODEPAGE) == 256 + + +def codepage_index(*chars): + for char in chars: + if char in CODEPAGE: + yield CODEPAGE.index(char) + else: + yield -1 + + +def utf8_to_thunno2(string): + ret = "" + for char in string: + if ord(char) < 256: + ret += CODEPAGE[ord(char)] + else: + ret += char + return ret + + +def thunno2_to_utf8(string): + ret = "" + for char in string: + if char in CODEPAGE: + ret += chr(CODEPAGE.index(char)) + else: + ret += char + return ret diff --git a/src/build/lib/thunno2/commands.py b/src/build/lib/thunno2/commands.py new file mode 100644 index 0000000..44de017 --- /dev/null +++ b/src/build/lib/thunno2/commands.py @@ -0,0 +1,1700 @@ +from thunno2.dictionary import * +from thunno2.helpers import * +import sys + +"""Creative Commons Legal Code + +CC0 1.0 Universal + + CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE + LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN + ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS + INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES + REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS + PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM + THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED + HEREUNDER. + +Statement of Purpose + +The laws of most jurisdictions throughout the world automatically confer +exclusive Copyright and Related Rights (defined below) upon the creator +and subsequent owner(s) (each and all, an "owner") of an original work of +authorship and/or a database (each, a "Work"). + +Certain owners wish to permanently relinquish those rights to a Work for +the purpose of contributing to a commons of creative, cultural and +scientific works ("Commons") that the public can reliably and without fear +of later claims of infringement build upon, modify, incorporate in other +works, reuse and redistribute as freely as possible in any form whatsoever +and for any purposes, including without limitation commercial purposes. +These owners may contribute to the Commons to promote the ideal of a free +culture and the further production of creative, cultural and scientific +works, or to gain reputation or greater distribution for their Work in +part through the use and efforts of others. + +For these and/or other purposes and motivations, and without any +expectation of additional consideration or compensation, the person +associating CC0 with a Work (the "Affirmer"), to the extent that he or she +is an owner of Copyright and Related Rights in the Work, voluntarily +elects to apply CC0 to the Work and publicly distribute the Work under its +terms, with knowledge of his or her Copyright and Related Rights in the +Work and the meaning and intended legal effect of CC0 on those rights. + +1. Copyright and Related Rights. A Work made available under CC0 may be +protected by copyright and related or neighboring rights ("Copyright and +Related Rights"). Copyright and Related Rights include, but are not +limited to, the following: + + i. the right to reproduce, adapt, distribute, perform, display, + communicate, and translate a Work; + ii. moral rights retained by the original author(s) and/or performer(s); +iii. publicity and privacy rights pertaining to a person's image or + likeness depicted in a Work; + iv. rights protecting against unfair competition in regards to a Work, + subject to the limitations in paragraph 4(a), below; + v. rights protecting the extraction, dissemination, use and reuse of data + in a Work; + vi. database rights (such as those arising under Directive 96/9/EC of the + European Parliament and of the Council of 11 March 1996 on the legal + protection of databases, and under any national implementation + thereof, including any amended or successor version of such + directive); and +vii. other similar, equivalent or corresponding rights throughout the + world based on applicable law or treaty, and any national + implementations thereof. + +2. Waiver. To the greatest extent permitted by, but not in contravention +of, applicable law, Affirmer hereby overtly, fully, permanently, +irrevocably and unconditionally waives, abandons, and surrenders all of +Affirmer's Copyright and Related Rights and associated claims and causes +of action, whether now known or unknown (including existing as well as +future claims and causes of action), in the Work (i) in all territories +worldwide, (ii) for the maximum duration provided by applicable law or +treaty (including future time extensions), (iii) in any current or future +medium and for any number of copies, and (iv) for any purpose whatsoever, +including without limitation commercial, advertising or promotional +purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each +member of the public at large and to the detriment of Affirmer's heirs and +successors, fully intending that such Waiver shall not be subject to +revocation, rescission, cancellation, termination, or any other legal or +equitable action to disrupt the quiet enjoyment of the Work by the public +as contemplated by Affirmer's express Statement of Purpose. + +3. Public License Fallback. Should any part of the Waiver for any reason +be judged legally invalid or ineffective under applicable law, then the +Waiver shall be preserved to the maximum extent permitted taking into +account Affirmer's express Statement of Purpose. In addition, to the +extent the Waiver is so judged Affirmer hereby grants to each affected +person a royalty-free, non transferable, non sublicensable, non exclusive, +irrevocable and unconditional license to exercise Affirmer's Copyright and +Related Rights in the Work (i) in all territories worldwide, (ii) for the +maximum duration provided by applicable law or treaty (including future +time extensions), (iii) in any current or future medium and for any number +of copies, and (iv) for any purpose whatsoever, including without +limitation commercial, advertising or promotional purposes (the +"License"). The License shall be deemed effective as of the date CC0 was +applied by Affirmer to the Work. Should any part of the License for any +reason be judged legally invalid or ineffective under applicable law, such +partial invalidity or ineffectiveness shall not invalidate the remainder +of the License, and in such case Affirmer hereby affirms that he or she +will not (i) exercise any of his or her remaining Copyright and Related +Rights in the Work or (ii) assert any associated claims and causes of +action with respect to the Work, in either case contrary to Affirmer's +express Statement of Purpose. + +4. Limitations and Disclaimers. + + a. No trademark or patent rights held by Affirmer are waived, abandoned, + surrendered, licensed or otherwise affected by this document. + b. Affirmer offers the Work as-is and makes no representations or + warranties of any kind concerning the Work, express, implied, + statutory or otherwise, including without limitation warranties of + title, merchantability, fitness for a particular purpose, non + infringement, or the absence of latent or other defects, accuracy, or + the present or absence of errors, whether or not discoverable, all to + the greatest extent permissible under applicable law. + c. Affirmer disclaims responsibility for clearing rights of other persons + that may apply to the Work or any use thereof, including without + limitation any person's Copyright and Related Rights in the Work. + Further, Affirmer disclaims responsibility for obtaining any necessary + consents, permissions or other rights required for any use of the + Work. + d. Affirmer understands and acknowledges that Creative Commons is not a + party to this document and has no duty or obligation with respect to + this CC0 or use of the Work. +""" + + +class TerminateProgramException(BaseException): + pass + + +class Stack(list): + # Push one item to the front + def push(self, item): + self.insert(0, item) + + # Remove n items from the front + def rmv(self, num, default=0): + for _ in range(num): + if list(self): + yield self.pop(0) + else: + if (not ctx.vyxal_mode) or ctx.context is None: + if ctx.other_il: + x = ctx.other_il.pop(0) + ctx.other_il.append(x) + yield x + else: + yield default + else: + yield ctx.context + + +class Context: + def __init__(self): + self.stack = Stack() + self.og_input_list = [] + self.other_il = [] + self.implicit_print = True + self.warnings = False + self.context = None + self.vyxal_mode = False + + +ctx = Context() + + +class VoidType: + def __call__(self, *args, **kwds): + return () + + def __eq__(self, other): + return isinstance(other, VoidType) + + def __ne__(self, other): + return not isinstance(other, VoidType) + + def __bool__(self): + return False + + def __int__(self): + return 0 + + def __float__(self): + return 0.0 + + def __str__(self): + return "Void" + + def __repr__(self): + return "Void" + + def __iter__(self): + yield from [] + + +Void = VoidType() + + +def recursively_vectorise(lst, dct): + for item in lst: + if isinstance(item, list): + yield list(recursively_vectorise(item, dct)) + else: + for key, val in dct.items(): + if isinstance(item, key): + try: + yield val(item) + except Exception as E: + if ctx.warnings: + print("TRACEBACK: [ERROR - CAUGHT]", file=sys.stderr) + print(E, file=sys.stderr) + pass + break + else: + if ctx.warnings: + print("TRACEBACK: [UNEXPECTED TYPE]", file=sys.stderr) + print("Got", type(item), file=sys.stderr) + yield Void + + +def recursively_distribute(x, y, dct, main=1): + if (not isinstance(x, list)) and (not isinstance(y, list)): + for (a, b), f in dct.items(): + if isinstance(x, a) and isinstance(y, b): + yield f(x, y) + break + else: + if ctx.warnings: + print("TRACEBACK: [UNEXPECTED TYPE]", file=sys.stderr) + print("Got", (type(x), type(y)), file=sys.stderr) + yield Void + elif isinstance(x, list) and not isinstance(y, list): + r = [] + for i in x: + if isinstance(i, list): + r += (next(recursively_distribute(i, y, dct, 0)),) + else: + for (a, b), f in dct.items(): + if isinstance(i, a) and isinstance(y, b): + r += (f(i, y),) + break + else: + if ctx.warnings: + print("TRACEBACK: [UNEXPECTED TYPE]", file=sys.stderr) + print("Got", (type(i), type(y)), file=sys.stderr) + yield r + elif isinstance(y, list) and not isinstance(x, list): + r = [] + for i in y: + if isinstance(i, list): + r += (next(recursively_distribute(x, i, dct, 0)),) + else: + for (a, b), f in dct.items(): + if isinstance(x, a) and isinstance(i, b): + r += (f(x, i),) + break + else: + if ctx.warnings: + print("TRACEBACK: [UNEXPECTED TYPE]", file=sys.stderr) + print("Got", (type(x), type(i)), file=sys.stderr) + yield r + else: + if not (x + y): + if main: + yield [] + elif not x: + yield from y + elif not y: + yield from x + else: + if main: + yield list(recursively_distribute(x[0], y[0], dct, 0)) + list( + recursively_distribute(x[1:], y[1:], dct, 0) + ) + else: + yield from list(recursively_distribute(x[0], y[0], dct, 0)) + list( + recursively_distribute(x[1:], y[1:], dct, 0) + ) + + +def repeat_to_longest(*lsts): + max_len = max(map(len, lsts)) + for inner_list in lsts: + if not inner_list: + yield Void + else: + yield (inner_list * max_len)[:max_len] + + +class Overload: + def __init__( + self, + pop, #: int, # How many items do we need to pop? + funcs, #: dict[tuple[type], Callable], # A mapping of the type overloads to functions + vectorise, #: #int, # What vectorisation type? + # 0 = no vectorisation, + # 1 = monadic recursive vectorisation, + # 2 = dyadic recursive vectorisation, + # 3 = triadic one-level vectorisation + keywords, #: tuple[str] # This is just an experiment with tokens, might not be implemented + ): + self.pop = pop + self.funcs = {k if isinstance(k, tuple) else (k,): v for k, v in funcs.items()} + self.vectorise = vectorise + self.keywords = keywords + + def __call__(self, pop=True): + if pop: + items = list(ctx.stack.rmv(self.pop)) + else: + items = list((ctx.stack + ctx.other_il + [0] * self.pop)[: self.pop]) + if self.vectorise == 0: + for typ, fun in self.funcs.items(): + if all(isinstance(x, y) for x, y in zip(items, typ)): + try: + r = fun(*items) + if not isinstance(r, tuple): + return (r,) + else: + return r + except Exception as E: + if ctx.warnings: + print("TRACEBACK: [ERROR - CAUGHT]", file=sys.stderr) + print(E, file=sys.stderr) + return Void + if ctx.warnings: + print("TRACEBACK: [UNEXPECTED TYPE]", file=sys.stderr) + print("Got", (*map(type, items),), file=sys.stderr) + return Void + elif self.vectorise == 1: + if len(items) == 1: + if isinstance(items[0], list): + try: + return (list(recursively_vectorise(items[0], self.funcs)),) + except Exception as E: + if ctx.warnings: + print("TRACEBACK: [ERROR - CAUGHT]", file=sys.stderr) + print(E, file=sys.stderr) + return Void + else: + for typ, fun in self.funcs.items(): + if isinstance(items[0], typ): + try: + r = fun(*items) + if not isinstance(r, tuple): + return (r,) + else: + return r + except Exception as E: + if ctx.warnings: + print( + "TRACEBACK: [ERROR - CAUGHT]", file=sys.stderr + ) + print(E, file=sys.stderr) + else: + if ctx.warnings: + print("TRACEBACK: [UNEXPECTED TYPE]", file=sys.stderr) + print("Got", type(items[0]), file=sys.stderr) + else: + if ctx.warnings: + print("TRACEBACK: [IMPLEMENTATION FAULT]", file=sys.stderr) + print("Expected 1 item, got", len(items), file=sys.stderr) + return Void + elif self.vectorise == 2: + try: + r = tuple(recursively_distribute(items[0], items[1], self.funcs)) + return r + except Exception as E: + if ctx.warnings: + print("TRACEBACK: [ERROR - CAUGHT]", file=sys.stderr) + print(E, file=sys.stderr) + return Void + elif self.vectorise == 3: + if not any(isinstance(it, list) for it in items): + for typ, fun in self.funcs.items(): + if all(isinstance(x, y) for x, y in zip(items, typ)): + try: + r = fun(*items) + if not isinstance(r, tuple): + return (r,) + else: + return r + except Exception as E: + if ctx.warnings: + print("TRACEBACK: [ERROR - CAUGHT]", file=sys.stderr) + print(E, file=sys.stderr) + return Void + else: + if ctx.warnings: + print("TRACEBACK: [UNEXPECTED TYPE]", file=sys.stderr) + print("Got", (*map(type, items),), file=sys.stderr) + return Void + lst = [ + i if isinstance(i, list) else [i] * safe_max_len(*items) for i in items + ] + ret = [] + for il in itertools.zip_longest(*lst): + if None in il: + ret.append(first_non_none(il)) + else: + for typ, fun in self.funcs.items(): + if all(isinstance(x, y) for x, y in zip(il, typ)): + try: + ret.append(fun(*il)) + except Exception as E: + if ctx.warnings: + print( + "TRACEBACK: [ERROR - CAUGHT]", file=sys.stderr + ) + print(E, file=sys.stderr) + pass + break + else: + if ctx.warnings: + print("TRACEBACK: [UNEXPECTED TYPE]", file=sys.stderr) + print("Got", (*map(type, items),), file=sys.stderr) + return (ret,) + if ctx.warnings: + print("TRACEBACK: [IMPLEMENTATION FAULT]", file=sys.stderr) + print("Unknown vectorisation argument", self.vectorise, file=sys.stderr) + return Void + + +Number = ((int, float),) +Iterable = ((list, str),) +Any = ((int, float, list, str),) + +# Which characters start digraphs? +DIGRAPHS = "ØøƵ" + +"""DICTIONARY""" + +commands = { + "A": Overload( + 1, {Number: abs, str: isalpha}, 1, ("abs", "absolute", "isalpha", "is_alpha") + ), + "B": Overload( + 2, + { + (int, int): ntb, + (str, int): to_custom_base_string, + (int, str): length_to_base, + (str, str): length_custom_base_string, + (float, Any): pass_, + }, + 2, + ("to_base", "from_decimal"), + ), + "C": Overload( + 1, {Number: chr2, str: ord2}, 1, ("chr", "character", "ord", "ordinal") + ), + "D": Overload(1, {Any: duplicate}, 0, ("dup", "duplicate")), + "E": Overload(1, {Number: is_even, str: eval2}, 1, ("even", "is_even", "eval")), + "F": Overload(1, {Number: factors, str: substrings}, 1, ("factors", "substrings")), + "G": Overload(1, {Number: max2, Iterable: max3}, 0, ("max", "maximum", "greatest")), + "H": Overload( + 1, {(int, str): from_hex, float: pass_}, 1, ("from_hex", "from_hexadecimal") + ), + "I": Overload( + 2, + { + (Number[0], Number[0]): binary_range, + (Number[0], Iterable[0]): slice1, + (Iterable[0], Number[0]): slice2, + (list, list): interleave_lst, + (str, str): interleave_str, + }, + 0, + ("inclusive_range", "slice", "interleave"), + ), + "J": Overload(1, {Number: str, Iterable: empty_join}, 0, ("empty_join", "str")), + # K is defined in the run function + "L": Overload( + 1, + {Number: lowered_range, str: str.lower}, + 1, + ("lowered_range", "zero_range", "lower", "lowercase"), + ), + "M": Overload(1, {Number: min2, Iterable: min3}, 0, ("min", "minimum")), + "N": Overload(1, {(Number[0], str): safe_int}, 1, ("int", "integer")), + "O": Overload( + 1, {Number: two_power, str: str.split}, 1, ("two_power", "space_split") + ), + "P": Overload( + 1, {Number: is_prime, str: str.swapcase}, 1, ("prime", "is_prime", "swapcase") + ), + "Q": Overload( + 2, + {((Number[0], str), (Number[0], str)): not_equal}, + 2, + ("not_equal", "inequality"), + ), + "R": Overload( + 1, + {Number: one_range, str: str.upper}, + 1, + ("one_range", "range", "upper", "uppercase"), + ), + "S": Overload(1, {Number: digit_sum, Iterable: it_sum}, 0, ("sum",)), + "T": Overload(0, {Any: (lambda: 10)}, 0, ("ten",)), + "U": Overload( + 1, + {Number: uniquify_num, str: uniquify_str, list: uniquify_lst}, + 0, + ("uniquify",), + ), + "V": Overload( + 1, + {Number: round, str: rot_13, list: indices_where_truthy}, + 0, + ("where_truthy", "rot13"), + ), + "W": Overload(1, {Any: wrap}, 0, ("wrap",)), + # X is defined in the run function + # Y is defined in the run function + "Z": Overload( + 2, + { + (Number[0], Number[0]): range_zip1, + (Number[0], Iterable[0]): range_zip2, + (Iterable[0], Number[0]): range_zip3, + (Iterable[0], Iterable[0]): zip2, + }, + 0, + ("zip",), + ), + "a": Overload( + 2, + { + (Any[0], list): append, + (list, Any[0]): swapped_append, + (Any[0], Any[0]): append2, + }, + 0, + ("append",), + ), + "b": Overload( + 2, + { + (int, (int, str)): convert_from_base, + (str, (int, str)): convert_from_custom_base, + (float, Any): pass_, + (Any, float): pass_, + }, + 2, + ("from_base", "to_decimal"), + ), + "c": Overload( + 2, + { + (Number[0], Number[0]): nCr, + (Any, str): string_count, + (Any, list): list_count, + }, + 0, + ("ncr", "count"), + ), + "d": Overload(1, {Number: digits, str: list}, 1, ("digits", "characters", "chars")), + "e": Overload( + 1, {Number: ten_power, str: comma_split}, 1, ("ten_power", "comma_split") + ), + "f": Overload(1, {Number: prime_factors, str: case}, 1, ("prime_factors", "case")), + "g": Overload( + 1, + {Number: digits_gcd, str: ords_gcd, list: gcd}, + 0, + ("gcd", "greatest_common_divisor"), + ), + "h": Overload(1, {Number: num_head, Iterable: head}, 0, ("head", "first")), + "i": Overload( + 2, + { + (Number[0], Number[0]): num_ind0, + (Number[0], Iterable[0]): indexing_0, + (Iterable[0], Number[0]): swapped_ind0, + (str, Iterable[0]): length_ind0, + (list, Iterable[0]): vectorised_ind0, + }, + 0, + ("indexing", "zero_indexing"), + ), + "j": Overload( + 2, {(Any, Number[0]): num_join, (Any, Iterable[0]): join}, 0, ("join",) + ), + # k is defined in the run function + "l": Overload(1, {Number: num_length, Iterable: len}, 0, ("len", "length")), + "m": Overload( + 1, {Number: num_mean, str: ord_mean, list: mean}, 0, ("mean", "avg", "average") + ), + # n is defined in the run function + "o": Overload( + 2, + { + (Number[0], Number[0]): num_rmv, + (Any[0], list): list_rmv, + (list, Any[0]): swapped_list_rmv, + (Any[0], str): str_rmv, + }, + 0, + ("rmv", "remove"), + ), + "p": Overload( + 1, + {Number: digit_product, str: ord_product, list: product}, + 0, + ("product", "prod"), + ), + # q is defined in the run function + "r": Overload(1, {Number: digit_reverse, Iterable: reverse}, 0, ("reverse",)), + "s": Overload(2, {(Any[0], Any[0]): swap}, 0, ("swap",)), + "t": Overload(1, {Number: num_tail, Iterable: tail}, 0, ("tail", "last")), + "u": Overload(0, {Any: (lambda: -1)}, 0, ("negative_one",)), + "v": Overload( + 3, + { + (Any[0], Any[0], list): list_replace, + (Any[0], Any[0], Any[0]): string_replace, + }, + 0, + ("replace",), + ), + "w": Overload( + 1, + {Number: factorial, str: remove_whitespace}, + 1, + ("factorial", "remove_whitespace"), + ), + # x is defined in the run function + # y is defined in the run function + "z": Overload( + 1, {Number: num_uninterleave, Iterable: uninterleave}, 0, ("uninterleave",) + ), + "Ȧ": Overload( + 1, + {Number: bool2, str: isalphanum, list: any2}, + 0, + ("any", "is_alphanum", "is_alpha_num"), + ), + "Ḃ": Overload(1, {(int, str): from_binary, float: pass_}, 1, ("from_binary",)), + "Ċ": Overload( + 1, + {Number: codepage_chr, str: codepage_ord}, + 1, + ("codepage_chr", "codepage_character", "codepage_ord", "codepage_ordinal"), + ), + "Ḋ": Overload( + 2, + { + (Number[0], Number[0]): is_divisible, + (str, Number[0]): length_divisible1, + (Number[0], str): length_divisible2, + (str, str): length_divisible3, + }, + 2, + ("divisible", "is_divisible"), + ), + "Ė": Overload( + 1, + {Number: inclusive_zero_range, Iterable: zero_enumerate}, + 0, + ("enumerate", "inclusive_zero_range"), + ), + "Ḟ": Overload(1, {Any: recursive_flatten}, 0, ("flatten", "recursive_flatten")), + "Ġ": Overload( + 2, + { + (Number[0], Number[0]): dyadic_gcd, + (str, Number[0]): ordinal_gcd1, + (Number[0], str): ordinal_gcd2, + (str, str): longest_common_substring, + }, + 2, + ("dyadic_gcd",), + ), + "Ḣ": Overload( + 1, {Number: num_head_extract, Iterable: head_extract}, 0, ("head_extract",) + ), + "İ": Overload( + 2, + { + (Number[0], Number[0]): num_ind1, + (Number[0], Iterable[0]): indexing_1, + (Iterable[0], Number[0]): swapped_ind1, + (str, Iterable[0]): length_ind1, + (list, Iterable[0]): vectorised_ind1, + }, + 0, + ("one_indexing",), + ), + "Ŀ": Overload( + 3, + { + (Any[0], Number[0], Any[0]): ljust1, + (Number[0], Any[0], Any[0]): ljust2, + (Any[0], Any[0], Any[0]): ljust3, + }, + 3, + ("ljust", "left_justify"), + ), + "Ṁ": Overload( + 1, {Number: num_mode, Iterable: mode}, 0, ("mode", "most_common_element") + ), + "Ṅ": Overload( + 1, {Number: negate, str: rle}, 1, ("negate", "neg", "rle", "run_length_encode") + ), + "Ȯ": Overload( + 2, + { + ((str, int, float), Iterable[0]): index_of, + (list, (str, int, float)): swapped_index_of, + (Number[0], (str, int, float)): num_index_of, + (list, Iterable[0]): vectorised_index_of, + }, + 0, + ("index_of", "find"), + ), + "Ṗ": Overload( + 2, + { + (Iterable[0], Iterable[0]): cartesian_product, + (Number[0], Iterable[0]): range_product1, + (Iterable[0], Number[0]): range_product2, + (Number[0], Number[0]): range_product3, + }, + 0, + ("cartesian_product",), + ), + "Ṙ": Overload(1, {Number: str, str: string_repr, list: list_repr}, 0, ("repr",)), + "Ṡ": Overload(1, {Number: digits_sort, str: str_sort, list: sort}, 0, ("sort",)), + "Ṫ": Overload( + 1, {Number: num_tail_extract, Iterable: tail_extract}, 0, ("tail_extract",) + ), + "Ẇ": Overload( + 2, + { + (Iterable[0], Number[0]): split1, + (Number[0], Iterable[0]): split2, + (Number[0], Number[0]): chunk1, + (Iterable[0], Iterable[0]): chunk2, + }, + 0, + ("chunk", "chunk_split"), + ), + # Ẋ is defined in the run function + # Ẏ is defined in the run function + "Ż": Overload( + 1, + {Number: num_length_range_0, Iterable: length_range_0}, + 0, + ("zero_length_range",), + ), + ",": Overload(2, {(Any[0], Any[0]): pair}, 0, ("pair",)), + "⁺": Overload( + 1, {Number: increment, str: str_increment}, 1, ("increment", "incr", "plus_one") + ), + "⁻": Overload( + 1, + {Number: decrement, str: str_decrement}, + 1, + ("decrement", "decr", "minus_one"), + ), + "⁼": Overload( + 2, {(Any[0], Any[0]): equals}, 0, ("exactly_equal", "exactly_equals") + ), + "+": Overload( + 2, + { + (Number[0], Number[0]): add, + (str, Number[0]): string_add, + (Number[0], str): string_add, + (str, str): string_add, + }, + 2, + ("add", "plus"), + ), + "-": Overload( + 2, + { + (Number[0], Number[0]): subtract, + (str, Number[0]): slice_start, + (Number[0], str): slice_end, + (str, str): replace_with_nothing, + }, + 2, + ("subtract", "minus"), + ), + "×": Overload( + 2, + { + (Number[0], Number[0]): multiply, + (str, Number[0]): multiply, + (Number[0], str): multiply, + (str, str): string_cartesian_product, + }, + 2, + ("multiply", "times"), + ), + "/": Overload( + 2, + { + (Number[0], Number[0]): divide, + (str, Number[0]): split1, + (Number[0], str): split2, + (str, str): split3, + }, + 2, + ("divide", "split"), + ), + "*": Overload( + 2, + { + (Number[0], Number[0]): exponentiate, + (str, Number[0]): append_first1, + (Number[0], str): append_first2, + (str, str): regex_findall, + }, + 2, + ("exponentiate", "power", "pow", "regex", "findall"), + ), + "%": Overload( + 2, + { + (Number[0], Number[0]): modulo, + (str, Number[0]): swapped_format, + (Number[0], str): str_format, + (str, str): str_format, + }, + 2, + ("modulo", "mod", "format"), + ), + "÷": Overload( + 2, + { + (Number[0], Number[0]): integer_divide, + (str, Number[0]): first_split1, + (Number[0], str): first_split2, + (str, str): first_split3, + }, + 2, + ("floor_divide", "integer_divide"), + ), + "_": Overload( + 2, + { + (Number[0], Number[0]): swapped_subtract, + (str, Number[0]): slice_end2, + (Number[0], str): slice_start2, + (str, str): replace_with_nothing2, + }, + 2, + ("swapped_subtract", "swapped_minus"), + ), + "\\": Overload( + 2, + { + (Number[0], Number[0]): swapped_divide, + (str, Number[0]): split1, + (Number[0], str): split2, + (str, str): split4, + }, + 2, + ("swapped_divide", "swapped_split"), + ), + "@": Overload( + 2, + { + (Number[0], Number[0]): swapped_exponentiate, + (str, Number[0]): prepend_last1, + (Number[0], str): prepend_last2, + (str, str): swapped_regex_findall, + }, + 2, + ("swapped_exponentiate", "swapped_pow", "swapped_findall", "swapped_regex"), + ), + "Œ": Overload( + 2, + { + (Number[0], Number[0]): swapped_modulo, + (str, Number[0]): swapped_format, + (Number[0], str): str_format, + (str, str): str_format2, + }, + 2, + ("swapped_modulo", "swapped_mod", "swapped_format"), + ), + "¦": Overload( + 2, + { + (Number[0], Number[0]): swapped_integer_divide, + (str, Number[0]): last_split1, + (Number[0], str): last_split2, + (str, str): last_split3, + }, + 2, + ("swapped_floor_divide", "swapped_integer_divide"), + ), + "=": Overload(2, {(Any[0], Any[0]): equals}, 2, ("equal", "equals")), + "<": Overload( + 2, + { + (Number[0], Number[0]): less_than, + (str, Number[0]): ord_less_than2, + (Number[0], str): ord_less_than1, + (str, str): less_than, + }, + 2, + ("less_than",), + ), + ">": Overload( + 2, + { + (Number[0], Number[0]): greater_than, + (str, Number[0]): ord_greater_than2, + (Number[0], str): ord_greater_than1, + (str, str): greater_than, + }, + 2, + ("greater_than",), + ), + "©": Overload( + 2, + { + (Number[0], Number[0]): less_than_or_equal_to, + (str, Number[0]): ord_less_than_or_equal_to2, + (Number[0], str): ord_less_than_or_equal_to1, + (str, str): less_than_or_equal_to, + }, + 2, + ("less_than_or_equal_to",), + ), + "®": Overload( + 2, + { + (Number[0], Number[0]): greater_than_or_equal_to, + (str, Number[0]): ord_greater_than_or_equal_to2, + (Number[0], str): ord_greater_than_or_equal_to1, + (str, str): greater_than_or_equal_to, + }, + 2, + ("greater_than_or_equal_to",), + ), + "&": Overload(2, {(Any[0], Any[0]): logical_and}, 2, ("and", "logical_and")), + "|": Overload(2, {(Any[0], Any[0]): logical_or}, 2, ("or", "logical_or")), + "^": Overload( + 1, + {Number: num_uninterleave_dump, Iterable: uninterleave_dump}, + 0, + ("uninterleave_dump",), + ), + "~": Overload(1, {Any: logical_not}, 1, ("not", "logical_not")), + "ð": Overload(0, {Any: (lambda: " ")}, 0, ("space",)), + "Ð": Overload(1, {Any: triplicate}, 0, ("triplicate",)), + "ȧ": Overload( + 3, + { + (Any[0], Number[0], Iterable[0]): assign, + (Any[0], Iterable[0], Number[0]): swapped_assign, + (Any[0], list, Iterable[0]): vectorised_assign, + (Any[0], str, Iterable[0]): length_assign, + (Any[0], Number[0], Number[0]): num_assign, + }, + 0, + ("assign",), + ), + "ḃ": Overload( + 1, {Number: to_binary, str: ord_bin}, 1, ("bin", "binary", "to_binary") + ), + "ċ": Overload( + 2, + { + (Number[0], Iterable[0]): combinations1, + (Iterable[0], Number[0]): combinations2, + (Number[0], Number[0]): combinations3, + (Iterable[0], Iterable[0]): set_union, + }, + 0, + ("combinations", "union"), + ), + "ḋ": Overload( + 2, + { + (Number[0], Number[0]): divmod2, + (Number[0], list): from_list_of_digits, + (list, Number[0]): from_list_of_digits_2, + (Any[0], Any[0]): pass_, + }, + 0, + ("divmod", "from_digits"), + ), + "ė": Overload( + 1, + {Number: exclusive_one_range, Iterable: length_range}, + 0, + ("length_range", "exclusive_one_range"), + ), + "ḟ": Overload( + 1, + {Number: prime_factor_exponents, str: str.title}, + 1, + ("prime_factor_exponents", "title", "title_case"), + ), + "ġ": Overload( + 1, + {Number: consecutive_digits, Iterable: group_consecutive}, + 0, + ("group_consecutive",), + ), + "ḣ": Overload( + 1, {Number: num_head_remove, Iterable: head_remove}, 0, ("head_remove",) + ), + "ŀ": Overload( + 1, + {Number: digits_lcm, str: ords_lcm, list: lcm}, + 0, + ("lcm", "lowest_common_multiple"), + ), + "ṁ": Overload( + 1, {Number: num_median, str: ord_median, list: median}, 0, ("median",) + ), + # ṅ is defined in the run function + "ȯ": Overload( + 2, + { + (Number[0], Number[0]): round_decimal_places, + (Number[0], Iterable[0]): range_intersection1, + (Iterable[0], Number[0]): range_intersection2, + (Iterable[0], Iterable[0]): set_intersection, + }, + 0, + ("set_intersection", "round_dps"), + ), + "ṗ": Overload( + 2, + { + (Number[0], Iterable[0]): permutations1, + (Iterable[0], Number[0]): permutations2, + (Number[0], Number[0]): permutations3, + (Iterable[0], Iterable[0]): set_difference, + }, + 0, + ("permutations", "set_difference"), + ), + "ṙ": Overload( + 3, + { + (Any[0], Number[0], Any[0]): rjust1, + (Number[0], Any[0], Any[0]): rjust2, + (Any[0], Any[0], Any[0]): rjust3, + }, + 3, + ("rjust", "right_justify"), + ), + "ṡ": Overload( + 1, + {Number: numcumsum, str: prefixes, list: cumsum}, + 0, + ("cumsum", "cumulative_sums"), + ), + "ṫ": Overload( + 1, {Number: num_tail_remove, Iterable: tail_remove}, 0, ("tail_remove",) + ), + "ẇ": Overload( + 2, + { + (Number[0], Number[0]): chunk5, + (Number[0], Iterable[0]): chunk3, + (Iterable[0], Number[0]): chunk4, + (Iterable[0], Iterable[0]): chunk6, + }, + 0, + ("chunk_wrap", "split_chunk"), + ), + "ż": Overload( + 1, + {Number: num_length_range, Iterable: length_range_no_pop}, + 0, + ("length_range_no_pop",), + ), + "Ạ": Overload( + 0, + {Any: (lambda: string.ascii_lowercase)}, + 0, + ("alphabet", "lowercase_alphabet"), + ), + "Ḅ": Overload( + 2, + { + (int, int): ntbs, + (str, int): character_multiply1, + (int, str): character_multiply2, + (str, str): regex_split, + (float, Any): pass_, + }, + 2, + ("to_base_string", "character_multiply", "regex_split"), + ), + "Ḍ": Overload(1, {Any: double}, 1, ("double",)), + "Ẹ": Overload( + 1, + {Number: num_dump, Iterable: dump}, + 0, + ("dump",), + ), + "Ḥ": Overload( + 1, {Number: to_hex, str: ord_hex}, 1, ("hex", "hexadecimal", "to_hexadecimal") + ), + "Ị": Overload( + 1, + {Number: reciprocal, str: remove_non_alphabets}, + 1, + ("reciprocal", "inverse", "filter_isalpha", "only_alphabetic"), + ), + "Ḳ": Overload(1, {Number: num_bifurcate, Iterable: bifurcate}, 0, ("bifurcate",)), + "Ḷ": Overload( + 2, + { + (Number[0], Number[0]): dyadic_lcm, + (str, Number[0]): ordinal_lcm1, + (Number[0], str): ordinal_lcm2, + (str, str): ordinal_lcm3, + }, + 2, + ("dyadic_lcm",), + ), + "Ṃ": Overload(1, {Number: num_mirror, Iterable: mirror}, 0, ("mirror",)), + "Ṇ": Overload( + 3, + { + (list, list, (int, float, str)): str_transliterate, + (list, list, list): list_transliterate, + (list, (int, float, str), (int, float, str)): str_transliterate_overload_1, + (list, (int, float, str), list): list_transliterate_overload_1, + ((int, float, str), list, (int, float, str)): str_transliterate_overload_2, + ((int, float, str), list, list): list_transliterate_overload_2, + ( + (int, float, str), + (int, float, str), + (int, float, str), + ): str_transliterate_overload_3, + ((int, float, str), (int, float, str), list): list_transliterate_overload_3, + }, + 0, + ("transliterate",), + ), + "Ọ": Overload( + 2, + { + (Number[0], Number[0]): dyadic_minimum, + (Any[0], Any[0]): string_dyadic_minimum, + }, + 2, + ("dyadic_minimum",), + ), + "Ṛ": Overload( + 2, + { + (Number[0], Iterable[0]): combinations_with_replacement1, + (Iterable[0], Number[0]): combinations_with_replacement2, + (Number[0], Number[0]): combinations_with_replacement3, + (Iterable[0], Iterable[0]): combinations_with_replacement4, + }, + 0, + ("combinations_with_replacement",), + ), + "Ṣ": Overload( + 1, + {Number: digit_deltas, str: ord_deltas, list: deltas}, + 0, + ("deltas", "forward_differences"), + ), + "Ṭ": Overload( + 1, {Number: digits_wrap, str: list_wrap, list: transpose}, 0, ("transpose",) + ), + "Ụ": Overload( + 1, + {Number: num_rotate_left_once, Iterable: rotate_left_once}, + 0, + ("rotate_left_once",), + ), + "Ṿ": Overload( + 1, + {Number: num_rotate_right_once, Iterable: rotate_right_once}, + 0, + ("rotate_right_once",), + ), + "Ẉ": Overload( + 2, + { + (Number[0], Number[0]): num_uninterleave2, + (Number[0], Iterable[0]): uninterleave2, + (Iterable[0], Number[0]): swapped_uninterleave, + (Iterable[0], Iterable[0]): len_uninterleave, + }, + 0, + ("uninterleave_into_pieces",), + ), + "Ỵ": Overload( + 2, + { + (Number[0], Number[0]): left_bit_shift, + (Number[0], Iterable[0]): rotate_left, + (Iterable[0], Number[0]): swapped_rotate_left, + (Iterable[0], Iterable[0]): len_rotate_left, + }, + 0, + ("rotate_left", "left_bit_shift"), + ), + "Ẓ": Overload( + 2, + { + (Number[0], Number[0]): right_bit_shift, + (Number[0], Iterable[0]): rotate_right, + (Iterable[0], Number[0]): swapped_rotate_right, + (Iterable[0], Iterable[0]): len_rotate_right, + }, + 0, + ("rotate_right", "right_bit_shift"), + ), + "Ä": Overload( + 1, + {Number: num_to_alphabet, str: alphabet_to_num}, + 1, + ("num_to_alphabet", "alphabet_to_num"), + ), + "¶": Overload(0, {Any: (lambda: "\n")}, 0, ("newline",)), + "Ç": Overload(0, {Any: (lambda: "|")}, 0, ("pipe",)), + "¬": Overload( + 1, {Any: logical_not}, 0, ("non_vectorised_not", "non_vectorised_logical_not") + ), + "§": Overload( + 2, + { + (Number[0], Number[0]): dyadic_maximum, + (Any[0], Any[0]): string_dyadic_maximum, + }, + 2, + ("dyadic_maximum",), + ), + "½": Overload(1, {Number: halve, str: chunk_halve}, 1, ("halve",)), + "Ƈ": Overload( + 2, + { + (Number[0], Number[0]): nPr, + (Any, list): list_contains, + (Any, str): string_contains, + }, + 0, + ("npr", "contains"), + ), + "Ɗ": Overload( + 2, + { + (Number[0], (int, float, str)): str_remove_at_index, + (Number[0], list): list_remove_at_index, + (str, Number[0]): swapped_str_remove_at_index, + (list, Number[0]): swapped_list_remove_at_index, + (Any[0], list): list_rmv, + (list, Any[0]): swapped_list_rmv, + (Any[0], str): str_rmv, + }, + 0, + ("drop_at_index", "remove_at_index"), + ), + "Ƒ": Overload( + 1, + {Number: unique_prime_factors, Iterable: substrings}, + 0, + ("unique_prime_factors", "sublists"), + ), + "Ɠ": Overload(0, {Any: (lambda: 16)}, 0, ("sixteen",)), + "Ɱ": Overload( + 1, {Number: num_palindromise, Iterable: palindromise}, 0, ("palindromise",) + ), + "Ɲ": Overload( + 1, + {Number: integer_partitions, Iterable: newline_join}, + 0, + ("integer_partitions", "newline_join", "join_by_newlines"), + ), + "Ƥ": Overload( + 2, + { + (Any[0], list): prepend, + (list, Any[0]): swapped_prepend, + (Any[0], Any[0]): prepend2, + }, + 0, + ("prepend",), + ), + "Ƭ": Overload( + 2, + { + (Any[0], list): transpose_with_filler, + (list, Any[0]): swapped_transpose_with_filler, + (Number[0], Any[0]): digits_wrap_2, + (str, Any[0]): list_wrap_2, + }, + 0, + ("transpose_with_filler",), + ), + "ɓ": Overload(1, {Any: boolify}, 1, ("boolify",)), + "ƈ": Overload(1, {Number: num_counts, Iterable: counts}, 0, ("counts",)), + "ɗ": Overload(1, {Number: parity, str: second_half}, 1, ("parity", "second_half")), + "ƒ": Overload(1, {Number: num_prefixes, Iterable: prefixes}, 0, ("prefixes",)), + "ɠ": Overload( + 0, {Any: (lambda: 256)}, 0, ("two_fifty_six", "two_hundred_fifty_six") + ), + "ɦ": Overload(0, {Any: (lambda: 100)}, 0, ("hundred", "one_hundred")), + "ƙ": Overload( + 1, + {Number: increment_twice, Iterable: grade_up}, + 0, + ("grade_up", "increment_twice"), + ), + "ɱ": Overload( + 2, + { + (Number[0], Number[0]): num_head_slice, + (Number[0], Iterable[0]): head_slice, + (Iterable[0], Number[0]): swapped_head_slice, + (Iterable[0], Iterable[0]): len_head_slice, + }, + 0, + ("head_slice",), + ), + "ɲ": Overload( + 2, + { + (Number[0], Number[0]): num_tail_slice, + (Number[0], Iterable[0]): tail_slice, + (Iterable[0], Number[0]): swapped_tail_slice, + (Iterable[0], Iterable[0]): len_tail_slice, + }, + 0, + ("tail_slice",), + ), + "ƥ": Overload(1, {Any: pop_}, 0, ("pop",)), + "ʠ": Overload(1, {Number: num_powerset, Iterable: powerset}, 0, ("powerset",)), + "ɼ": Overload( + 1, + {Number: randint, Iterable: randchoice}, + 0, + ("random", "random_choice", "randint"), + ), + "ʂ": Overload( + 1, + {Number: sign, str: sentence_case, list: sum_each}, + 0, + ("sign", "sentence_case", "sum_each"), + ), + "ƭ": Overload( + 1, + {Number: square_root, str: every_second_item}, + 1, + ("square_root", "every_second_item"), + ), + "²": Overload(1, {Number: square, str: chunk_wrap_2}, 1, ("square",)), + "³": Overload(1, {Number: cube, str: chunk_wrap_3}, 1, ("cube",)), + "⁴": Overload( + 1, {Number: fourth, str: chunk_wrap_4}, 1, ("fourth", "fourth_power") + ), + "⁵": Overload(1, {Number: fifth, str: chunk_wrap_5}, 1, ("fifth", "fifth_power")), + "ạ": Overload(1, {Number: num_all_equal, Iterable: all_equal}, 0, ("all_equal",)), + "ḅ": Overload(1, {Any: equals_one}, 1, ("equals_one",)), + "ḍ": Overload( + 2, + { + (Number[0], Number[0]): range_ssd1, + (Number[0], Iterable[0]): range_ssd2, + (Iterable[0], Number[0]): range_ssd3, + (Iterable[0], Iterable[0]): symmetric_set_difference, + }, + 0, + ("symmetric_set_difference",), + ), + "ẹ": Overload(1, {Number: num_enclose, Iterable: enclose}, 0, ("enclose",)), + "ḥ": Overload( + 2, + { + (list, list): add, + (list, Any[0]): add_digits1, + (Any[0], list): add_digits2, + (Any[0], Any[0]): add_digits3, + }, + 0, + ("concatenate", "merge"), + ), + "ị": Overload( + 2, + { + (Number[0], Number[0]): corresponding_digit_filter_1, + (Number[0], Iterable[0]): corresponding_digit_filter_2, + (Iterable[0], Number[0]): corresponding_digit_filter_3, + (Iterable[0], Iterable[0]): corresponding_filter, + }, + 0, + ("corresponding_filter",), + ), + "ḳ": Overload( + 1, + {Number: num_sort_uniquify, str: str_sort_uniquify, list: list_sort_uniquify}, + 0, + ("sorted_uniquify",), + ), + "ḷ": Overload( + 1, + {Number: complement, str: islower, list: length_of_each}, + 0, + ("length_of_each", "complement", "is_lower"), + ), + "ṃ": Overload( + 1, + {Number: math.ceil, str: is_vowel, list: reverse_each}, + 0, + ("ceil", "is_vowel", "reverse_each"), + ), + "ọ": Overload( + 2, + { + (Number[0], list): multiply, + (list, Number[0]): multiply, + (Number[0], Any[0]): digits_repeat1, + (Any[0], Number[0]): digits_repeat2, + (list, (int, float, str)): length_repeat1, + (Any[0], Any[0]): length_repeat2, + }, + 0, + ("repeat",), + ), + "ṛ": Overload( + 2, + { + (Number[0], Number[0]): absolute_difference, + (Number[0], str): zfill1, + (str, Number[0]): zfill2, + (str, str): surround, + }, + 2, + ("absolute_difference", "zfill", "surround"), + ), + "ṣ": Overload(1, {Number: spaces, Iterable: suffixes}, 0, ("suffixes", "spaces")), + "ṭ": Overload(3, {(Any[0], Any[0], Any[0]): triple_swap}, 0, ("triple_swap",)), + "ẉ": Overload( + 2, + { + (Number[0], Number[0]): range_cartesian_power, + (Number[0], Iterable[0]): cartesian_power, + (Iterable[0], Number[0]): swapped_cartesian_power, + (Iterable[0], Iterable[0]): cartesian_product, + }, + 0, + ("cartesian_power",), + ), + "ỵ": Overload( + 2, + { + (Number[0], Number[0]): num_head_remove_2, + (Number[0], Iterable[0]): head_remove_2, + (Iterable[0], Number[0]): swapped_head_remove_2, + (Iterable[0], Iterable[0]): len_head_remove_2, + }, + 0, + ("head_remove_many",), + ), + "ẓ": Overload( + 2, + { + (Number[0], Number[0]): num_tail_remove_2, + (Number[0], Iterable[0]): tail_remove_2, + (Iterable[0], Number[0]): swapped_tail_remove_2, + (Iterable[0], Iterable[0]): len_tail_remove_2, + }, + 0, + ("tail_remove_many",), + ), +} + +string_digraphs = { + "B": Overload( + 1, + {Any: brackets_are_balanced}, + 1, + ("balanced_brackets", "brackets_are_balanced"), + ), + "D": Overload( + 1, {Any: optimal_dictionary_compression}, 1, ("optimal_dictionary_compression",) + ), + "v": Overload( + 2, + { + (list, Any[0]): canvas_draw, + (Number[0], str): digits_canvas_draw, + (str, list): swapped_canvas_draw, + (str, Number[0]): swapped_digits_canvas_draw, + (Any[0], Any[0]): pass_, + }, + 0, + ("canvas", "draw", "canvas_draw"), + ), + "V": Overload( + 2, + { + (list, Any[0]): blank_canvas_draw, + (Number[0], str): blank_digits_canvas_draw, + (str, list): blank_swapped_canvas_draw, + (str, Number[0]): blank_swapped_digits_canvas_draw, + (Any[0], Any[0]): pass_, + }, + 0, + ("blank_canvas", "blank_draw", "blank_canvas_draw"), + ), + "^": Overload(0, {Any: clear_canvas}, 0, ("clear_canvas",)), + "<": Overload(2, {(Any[0], Any[0]): str_starts_with}, 2, ("starts_with",)), + ">": Overload(2, {(Any[0], Any[0]): str_ends_with}, 2, ("starts_with",)), +} + +list_digraphs = { + "C": Overload( + 1, {((int, float, str),): pass_, list: centre_list}, 0, ("center", "centre") + ), + "D": Overload(1, {Any: depth}, 0, ("depth",)), + "E": Overload( + 2, + { + (Number[0], Iterable[0]): extend_truncate, + (Iterable[0], Number[0]): swapped_extend_truncate, + (Iterable[0], Iterable[0]): length_extend_truncate, + (Number[0], Number[0]): num_extend_truncate, + }, + 0, + ( + "extend", + "truncate", + "extend_truncate", + "extend_to_length", + "truncate_to_length", + ), + ), + "G": Overload(1, {((int, float, str),): pass_, list: longest}, 0, ("longest",)), + "I": Overload( + 2, + { + ((int, float, str), list): multidimensional_index, + (list, (int, float, str)): swapped_multidimensional_index, + (list, list): vectorised_multidimensional_index, + (Any[0], Any[0]): pass_, + }, + 0, + ("multidimensional_index",), + ), + "M": Overload(1, {((int, float, str),): pass_, list: shortest}, 0, ("shortest",)), + ".": Overload( + 2, {(list, list): dot_product, (Any[0], Any[0]): pass_}, 0, ("dot_product",) + ), + "\\": Overload( + 1, {((int, float, str),): pass_, list: main_diagonal}, 0, ("main_diagonal",) + ), + "/": Overload( + 1, {((int, float, str),): pass_, list: anti_diagonal}, 0, ("anti_diagonal",) + ), + "“": Overload( + 1, {((int, float, str),): pass_, list: all_diagonals}, 0, ("all_diagonals",) + ), + "”": Overload( + 1, + {((int, float, str),): pass_, list: all_anti_diagonals}, + 0, + ("all_anti_diagonals",), + ), +} + +random_digraphs_1 = { + "C": Overload(1, {Any: cosine}, 1, ("cosine", "cos")), + "D": Overload(1, {Any: degrees}, 1, ("degrees",)), + "E": Overload(1, {Any: exponent}, 1, ("exponent",)), + "F": Overload(1, {Any: nth_fibonacci_number}, 1, ("nth_fibonacci_number",)), + "H": Overload(2, {(Any[0], Any[0]): hypotenuse}, 2, ("hypot", "hypotenuse")), + "I": Overload(1, {Any: insignificant}, 1, ("insignificant",)), + "L": Overload(2, {(Any[0], Any[0]): logarithm}, 2, ("log", "logarithm")), + "N": Overload(1, {Any: ln}, 1, ("natural_log", "natural_logarithm")), + "P": Overload(1, {Any: nth_prime}, 1, ("nth_prime",)), + "R": Overload(1, {Any: radians}, 1, ("radians",)), + "S": Overload(1, {Any: sine}, 1, ("sine", "sin")), + "T": Overload(1, {Any: tangent}, 1, ("tangent", "tan")), + "c": Overload(1, {Any: arc_cosine}, 1, ("arc_cosine", "arccos")), + "l": Overload(1, {Any: log10}, 1, ("log10", "common_log", "common_logarithm")), + "s": Overload(1, {Any: arc_sine}, 1, ("arc_sine", "arcsin")), + "t": Overload(1, {Any: arc_tangent}, 1, ("arc_tangent", "arctan")), + "ḷ": Overload(1, {Any: log2}, 1, ("log2", "log_base_2")), + "&": Overload(2, {(Any[0], Any[0]): bitwise_and}, 2, ("bitwise_and",)), + "|": Overload(2, {(Any[0], Any[0]): bitwise_or}, 2, ("bitwise_or",)), + "^": Overload(2, {(Any[0], Any[0]): bitwise_xor}, 2, ("bitwise_xor",)), + "~": Overload(1, {Any: bitwise_not}, 1, ("bitwise_not",)), + "²": Overload(1, {Any: perfect_square}, 1, ("perfect_square",)), + "³": Overload(1, {Any: perfect_cube}, 1, ("perfect_cube",)), + "⁴": Overload(1, {Any: perfect_fourth}, 1, ("perfect_fourth",)), + "⁵": Overload(1, {Any: perfect_fifth}, 1, ("perfect_fifth",)), +} + +random_digraphs_2 = { + "R": Overload( + 1, {Number: to_roman_numerals, str: from_roman_numerals}, 1, ("roman_numerals",) + ), + "T": Overload(1, {Any: type_of}, 0, ("type",)), + "U": Overload( + 1, + { + Number: num_connected_uniquify, + str: str_connected_uniquify, + list: connected_uniquify, + }, + 0, + ("connected_uniquify",), + ), + "r": Overload( + 1, + {Number: range_shuffle, str: str_shuffle, list: shuffle}, + 0, + ("random_shuffle",), + ), + "v": Overload( + 2, + { + (list, list): vectorised_trim, + (Any[0], list): trim, + (list, Any[0]): swapped_trim, + (Any[0], (int, float, str)): str_trim, + }, + 0, + ("trim",), + ), + "<": Overload( + 2, + { + (list, list): vectorised_left_trim, + (Any[0], list): left_trim, + (list, Any[0]): swapped_left_trim, + (Any[0], (int, float, str)): str_left_trim, + }, + 0, + ("left_trim",), + ), + ">": Overload( + 2, + { + (list, list): vectorised_right_trim, + (Any[0], list): right_trim, + (list, Any[0]): swapped_right_trim, + (Any[0], (int, float, str)): str_right_trim, + }, + 0, + ("right_trim",), + ), + "&": Overload( + 2, + {(Any[0], Any[0]): logical_and}, + 0, + ("non_vectorised_and", "non_vectorised_logical_and"), + ), + "|": Overload( + 2, + {(Any[0], Any[0]): logical_or}, + 0, + ("non_vectorised_or", "non_vectorised_logical_or"), + ), + "^": Overload( + 2, + {(Any[0], Any[0]): logical_xor}, + 0, + ("non_vectorised_xor", "non_vectorised_logical_xor"), + ), + "/": Overload( + 2, + { + (list, Any[0]): swapped_split_on, + (Any[0], Iterable[0]): split_on, + (Any[0], Number[0]): num_split_on, + }, + 0, + ("split_on",), + ), +} + + +def get_a_function(command): + if not command: + return Void + if len(command) == 1: + return commands.get(command, Void) + if command[0] == "ø": + return string_digraphs.get(command[1], Void) + if command[0] == "Ø": + return list_digraphs.get(command[1], Void) + if command[0] == "Æ": + return random_digraphs_1.get(command[1], Void) + if command[0] == "µ": + return random_digraphs_2.get(command[1], Void) + return Void diff --git a/src/build/lib/thunno2/constants.py b/src/build/lib/thunno2/constants.py new file mode 100644 index 0000000..0e226ff --- /dev/null +++ b/src/build/lib/thunno2/constants.py @@ -0,0 +1,112 @@ +import datetime +import math +from string import * + +from thunno2.codepage import * +from thunno2.version import * + +""" +Constants in Thunno start with a `k` and then have one other character after that. +This is the dictionary where all the constants are defined +""" + +CONSTANTS = { + "A": ascii_uppercase, + "B": "Buzz", + "C": CODEPAGE, + "D": "0123456789", + "E": math.e, + "F": "Fizz", + "G": (1 + 5**0.5) / 2, + "H": "Hello, World!", + "I": (lambda: datetime.datetime.now().microsecond), + "J": (lambda: datetime.datetime.now().second), + "K": (lambda: datetime.datetime.now().minute), + "L": (lambda: datetime.datetime.now().hour), + "M": (lambda: datetime.datetime.now().day), + "N": (lambda: datetime.datetime.now().month), + "O": (lambda: datetime.datetime.now().year), + "P": math.pi, + "Q": (lambda: str(datetime.datetime.now()).split(".")[0]), + "R": "()[]{}", + "S": "([{", + "T": ")]}", + "U": "([{<", + "V": ")]}>", + "W": "AEIOU", + "X": "BCDFGHJKLMNPQRSTVWXYZ", + "Y": "AEIOUY", + "Z": "BCDFGHJKLMNPQRSTVWXZ", + "a": ascii_lowercase + ascii_uppercase, + "b": "buzz", + "c": "".join("%c" * 95 % (*range(32, 127),)), + "d": "01", + "e": "01234567", + "f": "0123456789ABCDEF", + "g": ["Fizz", "Buzz"], + "h": "Hello World", + "i": 16, + "j": 32, + "k": 64, + "l": 128, + "m": 256, + "n": 512, + "o": 1024, + "p": 2048, + "q": 4096, + "r": 8192, + "s": 16384, + "t": 32768, + "u": 65536, + "v": ["qwertyuiop", "asdfghjkl", "zxcvbnm"], + "w": "aeiou", + "x": "bcdfghjklmnpqrstvwxyz", + "y": "aeiouy", + "z": "bcdfghjklmnpqrstvwxz", + "1": 10**3, + "2": 10**4, + "3": 10**5, + "4": 10**6, + "5": 10**7, + "6": 10**8, + "7": 10**9, + "8": 10**10, + "9": 10**11, + "0": 10**12, + "!": THUNNO_VERSION, + '"': [0, 0], + "#": [0, 1], + "$": [0, -1], + "%": [1, 0], + "&": [1, 1], + "'": [1, -1], + "(": [-1, 0], + ")": [-1, 1], + "*": [-1, -1], + "+": [3, 5], + ",": "AEIOUaeiou", + "-": "aeiouAEIOU", + ".": "AEIOUYaeiouy", + "/": "aeiouyAEIOUY", + "Ȧ": ascii_lowercase + ascii_uppercase + "0123456789", + "Ḃ": "0123456789" + ascii_uppercase + ascii_lowercase, + "Ċ": ascii_lowercase + ascii_uppercase + "0123456789_", + "Ḋ": ascii_uppercase[::-1], + "Ė": ascii_lowercase[::-1] + ascii_uppercase[::-1], + "Ḟ": ascii_lowercase[::-1] + ascii_uppercase[::-1] + "9876543210_", + "Ġ": ascii_uppercase + ascii_lowercase, + "Ḣ": ascii_uppercase[::-1] + ascii_lowercase[::-1], + "İ": ascii_lowercase[::-1] + ascii_uppercase[::-1] + "9876543210", + "Ŀ": ascii_uppercase + ascii_lowercase + "0123456789", + "Ṁ": ascii_uppercase[::-1] + ascii_lowercase[::-1] + "9876543210", + "Ṅ": "9876543210", + "Ȯ": "\n" + "".join("%c" * 95 % (*range(32, 127),)), + "Ṗ": punctuation, + "Ṙ": "http://", + "Ṡ": "http://www.", + "Ṫ": "https://www.", + "Ẇ": whitespace, + "Ẋ": ["()", "[]", "{}", "<>"], + "Ẏ": "([{<>}])", + "Ż": "[]<>-+.,", +} diff --git a/src/build/lib/thunno2/dictionary.py b/src/build/lib/thunno2/dictionary.py new file mode 100644 index 0000000..7dfb46b --- /dev/null +++ b/src/build/lib/thunno2/dictionary.py @@ -0,0 +1,32151 @@ +words = """aardvark +aardwolf +aaron +aback +abacus +abaft +abalone +abandon +abandons +abase +abased +abash +abashed +abate +abated +abates +abattoir +abbe +abbess +abbey +abbeys +abbot +abbots +abdicate +abdomen +abdomens +abduct +abducted +abductor +abducts +abeam +abel +abele +aberdeen +aberrant +abet +abets +abetted +abetting +abeyance +abhor +abhorred +abhors +abide +abided +abides +abiding +abidjan +abies +ability +abject +abjectly +abjure +abjured +ablate +ablates +ablating +ablation +ablative +ablaze +able +abler +ablest +abloom +ablution +ably +abnormal +aboard +abode +abodes +abolish +abomb +abort +aborted +aborting +abortion +abortive +aborts +abound +abounded +abounds +about +above +abraded +abraham +abrasion +abrasive +abreast +abridge +abridged +abroad +abrogate +abrupt +abruptly +abscess +abscissa +abscond +absconds +abseil +abseiled +abseiler +abseils +absence +absences +absent +absented +absentee +absently +absolute +absolve +absolved +absolves +absorb +absorbed +absorber +absorbs +abstain +abstains +abstract +abstruse +absurd +absurder +absurdly +abundant +abuse +abused +abuser +abusers +abuses +abusing +abusive +abut +abutment +abutted +abutting +abuzz +abysmal +abyss +abyssal +abysses +acacia +academe +academia +academic +academy +acanthus +acapulco +accede +acceded +acceding +accent +accented +accents +accept +accepted +acceptor +accepts +access +accessed +accesses +accident +acclaim +acclaims +accolade +accord +accorded +accords +accost +accosted +accosts +account +accounts +accra +accredit +accreted +accrual +accruals +accrue +accrued +accrues +accruing +accuracy +accurate +accursed +accusal +accusals +accuse +accused +accuser +accusers +accuses +accusing +accustom +aced +acentric +acerbic +acerbity +acers +aces +acetal +acetate +acetates +acetic +acetone +ache +ached +aches +achieve +achieved +achiever +achieves +aching +achingly +achings +achy +acid +acidic +acidify +acidity +acidly +acidrain +acids +acme +acne +acolyte +acolytes +aconite +acorn +acorns +acoustic +acquaint +acquire +acquired +acquirer +acquires +acquit +acquited +acquites +acquits +acre +acreage +acres +acrid +acrimony +acrobat +acrobats +acronym +acronyms +across +acrostic +acrylic +acrylics +acted +acting +actings +action +actions +activate +active +actively +actives +activism +activist +activity +actor +actors +actress +acts +actual +actually +actuary +actuate +actuated +actuates +actuator +acuity +acumen +acute +acutely +acuter +acutest +acyclic +adage +adages +adagio +adam +adamant +adapt +adapted +adapter +adapters +adapting +adaptive +adaptor +adaptors +adapts +added +addenda +addendum +adder +adders +addict +addicted +addicts +adding +addition +additive +addle +addled +addles +addling +address +adds +adduce +adduced +adduces +adducing +adelaide +aden +adenine +adenoid +adenoids +adenoma +adenomas +adept +adepts +adequacy +adequate +adhere +adhered +adherent +adherer +adherers +adheres +adhering +adhesion +adhesive +adhoc +adieu +adieus +adieux +adios +adipose +adit +adjacent +adjoin +adjoined +adjoins +adjourn +adjourns +adjudge +adjudged +adjudges +adjunct +adjuncts +adjure +adjust +adjusted +adjuster +adjusts +adjutant +adlib +adlibs +adman +admen +admin +admiral +admirals +admire +admired +admirer +admirers +admires +admiring +admit +admits +admitted +admix +admonish +adobe +adonis +adopt +adopted +adopter +adopting +adoption +adoptive +adopts +adorable +adorably +adore +adored +adorer +adorers +adores +adoring +adorn +adorned +adorning +adorns +adrenal +adrift +adroit +adroitly +adsorb +adsorbed +adult +adultery +adults +advance +advanced +advancer +advances +advent +advents +adverb +adverbs +adverse +advert +adverted +adverts +advice +advices +advise +advised +adviser +advisers +advises +advising +advisory +advocacy +advocate +adze +aegean +aegina +aegis +aeolian +aeon +aeons +aerate +aerated +aerates +aerating +aeration +aerator +aerial +aerially +aerials +aerify +aerobe +aerobes +aerobic +aerobics +aerofoil +aeronaut +aerosol +aerosols +aesop +aesthete +afar +affable +affably +affair +affairs +affect +affected +affects +afferent +affine +affinity +affirm +affirmed +affirms +affix +affixed +affixes +affixing +afflict +afflicts +affluent +afflux +afford +afforded +affords +affray +affront +affronts +afghan +afghani +afghans +afield +afire +aflame +afloat +afoot +afraid +afresh +africa +african +africans +afro +afros +after +again +against +agakhan +agape +agar +agaragar +agave +agaves +aged +ageing +ageings +ageism +ageless +agencies +agency +agenda +agendas +agendums +agent +agents +ageold +ages +aghast +agile +agiler +agility +aging +agings +agio +agitate +agitated +agitates +agitator +agitprop +agleam +aglow +agnostic +agog +agonies +agonise +agonised +agonises +agonist +agonists +agony +agora +agouti +agrarian +agree +agreed +agreeing +agrees +agrimony +agronomy +aground +ague +ahead +ahem +ahoy +aide +aided +aider +aiders +aides +aiding +aids +aileron +ailerons +ailing +ailment +ailments +ails +aimed +aimer +aiming +aimless +aims +aint +airbase +airborne +airbrush +airbus +aircraft +aircrew +aircrews +aire +aired +airfield +airflow +airforce +airframe +airgun +airier +airiest +airily +airiness +airing +airings +airless +airlift +airlifts +airline +airliner +airlines +airlock +airlocks +airmail +airman +airmen +airplane +airplay +airport +airports +airraid +airs +airship +airships +airsick +airspace +airstrip +airtight +airtime +airwave +airwaves +airway +airways +airy +aisle +aisles +aitches +ajar +akimbo +akin +alabama +alacarte +alack +alacrity +aladdin +alanine +alarm +alarmed +alarming +alarmism +alarmist +alarms +alas +alaska +alaskan +albania +albany +albeit +albinism +albino +album +albumen +albumin +albums +alchemy +alcohol +alcohols +alcove +alcoves +aldehyde +alder +alderman +aldermen +aldrin +alehouse +alembic +alert +alerted +alerting +alertly +alerts +ales +alfalfa +alfatah +alga +algae +algal +algebra +algebras +algeria +algerian +algiers +alias +aliases +alibaba +alibi +alibis +alien +alienate +aliened +aliening +aliens +alight +alighted +alights +align +aligned +aligning +aligns +alike +alimony +aline +alined +alines +alining +aliquot +aliquots +alive +alkali +alkalic +alkaline +alkalis +alkalise +alkaloid +alkanes +alkyl +allay +allayed +allaying +allays +allege +alleged +alleges +alleging +allegory +allegri +allegro +allele +alleles +allelic +allergen +allergic +allergy +alley +alleys +alleyway +alliance +allied +allies +allocate +allot +allots +allotted +allow +allowed +allowing +allows +alloy +alloyed +alloying +alloys +allude +alluded +alludes +alluding +allure +allured +allures +alluring +allusion +allusive +alluvia +alluvial +alluvium +ally +allying +almanac +almanacs +almighty +almond +almonds +almost +alms +aloe +aloes +aloft +aloha +alone +along +aloof +aloud +alpaca +alpacas +alpha +alphabet +alphas +alpine +alps +already +alright +also +altar +altars +alter +altered +alterego +altering +alters +although +altitude +alto +altruism +altruist +alts +alum +aluminum +alumni +alumnus +alveolar +alveoli +always +amalgam +amalgams +amass +amassed +amasses +amassing +amateur +amateurs +amatory +amaze +amazed +amazes +amazing +amazon +amazons +amber +ambiance +ambience +ambient +ambit +ambition +amble +ambled +ambler +ambles +ambling +ambrosia +ambulant +ambulate +ambush +ambushed +ambushes +amen +amenable +amend +amended +amending +amends +amenity +amens +america +american +amethyst +amiable +amiably +amicable +amicably +amid +amide +amidst +amigo +amine +amines +amino +amir +amiss +amity +amman +ammeter +ammeters +ammo +ammonia +ammonium +amnesia +amnesiac +amnesic +amnesty +amniotic +amoeba +amoebae +amoebic +amok +among +amongst +amoral +amorist +amorous +amortise +amount +amounted +amounts +amour +amours +ampere +amperes +amphibia +amphora +ample +ampler +amplify +amply +ampoules +amps +ampule +ampules +ampuls +amputate +amputee +amputees +amuck +amulet +amulets +amuse +amused +amuses +amusing +anabolic +anaconda +anaemia +anaemic +anagram +anagrams +anal +anally +analogue +analogy +analyse +analysed +analyser +analyses +analysis +analyst +analysts +analytic +ananas +anaphora +anarchic +anarchy +anathema +anatomic +anatomy +ancestor +ancestry +anchor +anchored +anchors +anchovy +ancient +ancients +andante +andes +andrew +android +androids +anecdote +anechoic +anemia +anemic +anemone +anemones +anergy +aneroid +aneurysm +anew +angel +angelic +angelica +angels +angelus +anger +angered +angering +angers +angina +anginal +angle +angled +angler +anglers +angles +anglian +anglican +angling +angola +angolan +angolans +angora +angoras +angrier +angriest +angrily +angry +angst +anguish +angular +anil +aniline +animal +animals +animate +animated +animates +animator +animism +animist +animists +animus +anion +anionic +anions +anise +aniseed +aniseeds +ankara +ankle +ankles +anklet +anklets +anna +annal +annals +anneal +annealed +annealer +annex +annexe +annexed +annexes +annexing +annotate +announce +annoy +annoyed +annoyer +annoyers +annoying +annoys +annual +annually +annuals +annuity +annul +annular +annuli +annulled +annuls +annulus +anode +anodes +anodised +anodyne +anoint +anointed +anoints +anomaly +anomic +anon +anonym +anonyms +anorak +anoraks +anorexia +anorexic +another +answer +answered +answerer +answers +antacid +antacids +ante +anteater +antedate +antelope +antenna +antennae +antennas +anterior +anteroom +anthem +anthems +anther +anthrax +anti +antibody +antic +antics +antidote +antigen +antigens +antilope +antimony +antique +antiques +antler +antlers +antlion +antlions +antonym +antonyms +antral +antrum +ants +antwerp +anus +anvil +anvils +anxiety +anxious +anybody +anyhow +anymore +anyone +anyplace +anything +anyway +anyways +anywhere +aorist +aorta +aortas +aortic +apace +apache +apaches +apart +apathy +aped +apeman +aperies +aperitif +aperture +apery +apes +apex +aphasia +aphelion +aphid +aphids +aphorism +aphorist +apian +apiaries +apiarist +apiary +apiece +aping +apis +apish +aplenty +aplomb +apnea +apnoea +apogee +apollo +apologia +apology +apoplexy +apostasy +apostate +apostle +apostles +appal +appalled +appals +apparel +apparent +appeal +appealed +appeals +appear +appeared +appears +appease +appeased +appeaser +appeases +append +appended +appendix +appends +appetite +applaud +applauds +applause +apple +applepie +apples +applet +applied +applier +applies +applique +apply +applying +appoint +appoints +apposite +appraise +apprise +apprised +appro +approach +approval +approve +approved +approves +apricot +apricots +april +apriori +apron +aprons +apropos +apse +apses +apsis +aptest +aptitude +aptly +aptness +aqua +aqualung +aquanaut +aquaria +aquarium +aquatic +aquatics +aqueduct +aqueous +aquifer +aquifers +aquiline +arab +arabia +arabian +arabians +arabic +arable +arabs +arachnid +arak +araks +ararat +arbiter +arbiters +arbitral +arbor +arboreal +arbour +arcade +arcades +arcadia +arcading +arcana +arcane +arcanely +arced +arch +archaic +archaism +archduke +arched +archer +archers +archery +arches +arching +archival +archive +archived +archives +archly +archness +archway +archways +arcing +arcs +arctic +ardency +ardent +ardently +ardour +arduous +area +areal +areas +arena +arenas +arent +argent +argon +argot +arguable +arguably +argue +argued +arguer +arguers +argues +arguing +argument +argus +aria +arias +arid +aridity +aridness +aright +arise +arisen +arises +arising +arizona +arkansas +arks +armada +armadas +armament +armature +armband +armbands +armchair +armed +armenia +armful +armfuls +armhole +armholes +armies +arming +armless +armlet +armlets +armour +armoured +armourer +armoury +armpit +armpits +armrest +arms +army +aroma +aromas +aromatic +arose +around +arousal +arousals +arouse +aroused +arouses +arousing +arrange +arranged +arranger +arranges +arrant +arrases +array +arrayed +arraying +arrays +arrears +arrest +arrested +arrester +arrests +arrival +arrivals +arrive +arrived +arriver +arrives +arriving +arrogant +arrow +arrowed +arrowing +arrows +arsenal +arsenals +arsenic +arsenide +arson +arsonist +artefact +arterial +arteries +artery +artful +artfully +arthur +article +articled +articles +artier +artifice +artisan +artisans +artist +artiste +artistes +artistic +artistry +artists +artless +arts +artwork +artworks +arty +arum +asbestos +ascend +ascended +ascender +ascends +ascent +ascents +ascetic +ascetics +ascorbic +ascribe +ascribed +ascribes +aseptic +asexual +ashamed +ashbin +ashbins +ashcans +ashen +ashes +ashore +ashtray +ashtrays +ashy +asia +asian +asians +asiatic +aside +asides +asinine +askance +asked +askers +askew +asking +asks +aslant +asleep +asocial +aspect +aspects +asperity +asphalt +asphyxia +aspic +aspirant +aspirate +aspire +aspired +aspires +aspirin +aspiring +aspirins +asps +assail +assailed +assails +assassin +assault +assaults +assay +assayed +assayer +assays +assegai +assegais +assemble +assembly +assent +assented +assents +assert +asserted +asserts +asses +assess +assessed +assesses +assessor +asset +assets +assign +assigned +assigner +assigns +assist +assisted +assists +assizes +assort +assorted +assuage +assuaged +assuages +assume +assumed +assumes +assuming +assure +assured +assures +assuring +assyria +assyrian +aster +asterisk +astern +asteroid +asters +asthma +astir +astonish +astound +astounds +astral +astrally +astray +astride +astute +astutely +asunder +aswan +asylum +asylums +atavism +atelier +atheism +atheist +atheists +athena +athens +athlete +athletes +athletic +atlanta +atlantic +atlantis +atlas +atlases +atoll +atolls +atom +atombomb +atomic +atomised +atoms +atonal +atone +atoned +atones +atonic +atoning +atop +atrial +atrium +atrocity +atrophy +atropine +attach +attache +attached +attaches +attack +attacked +attacker +attacks +attain +attained +attains +attempt +attempts +attend +attended +attender +attends +attest +attested +attests +attic +attics +attila +attire +attired +attiring +attitude +attorney +attract +attracts +attune +attuned +atypical +auburn +auction +auctions +audacity +audible +audibly +audience +audio +audit +audited +auditing +audition +auditive +auditor +auditors +auditory +audits +auger +augers +augite +augment +augments +augur +augured +augurs +augury +august +augustus +auks +aunt +auntie +aunties +aunts +aupair +aupairs +aura +aural +aurally +auras +aurevoir +auric +aurora +aurorae +auroral +auroras +auspice +auspices +aussie +aussies +austere +austral +austria +autarchy +auteur +author +authored +authors +autism +autistic +auto +autobahn +autocrat +autocue +automat +automata +automate +automats +autonomy +autopsy +autumn +autumnal +autumns +avail +availed +availing +avails +avarice +avenge +avenged +avenger +avengers +avenges +avenging +avens +avenue +avenues +aver +average +averaged +averages +averred +averring +avers +averse +aversion +aversive +avert +averted +averting +averts +avian +aviaries +aviary +aviate +aviation +aviator +aviators +avid +avidity +avidly +avionics +avocado +avoid +avoided +avoiding +avoids +avow +avowal +avowals +avowed +avowedly +avowing +avulsion +await +awaited +awaiting +awaits +awake +awaken +awakened +awakens +awakes +awaking +award +awarded +awarding +awards +aware +awash +away +awed +aweless +awesome +awful +awfully +awhile +awkward +awls +awning +awnings +awoke +awoken +awol +awry +axed +axehead +axeheads +axeman +axes +axial +axially +axillary +axing +axiom +axioms +axis +axle +axles +axolotl +axon +axons +azalea +azaleas +azimuth +azores +aztec +aztecs +azure +baaing +baal +babas +babble +babbled +babbler +babblers +babbles +babbling +babe +babel +babes +babies +baboon +baboons +baby +babyface +babyhood +babying +babyish +babylon +babysit +baccarat +bacchus +bach +bachelor +bacilli +bacillus +back +backache +backbone +backchat +backdate +backdrop +backed +backer +backers +backfire +backhand +backing +backlash +backless +backlit +backlog +backlogs +backpack +backrest +backs +backseat +backside +backup +backups +backward +backwash +backyard +bacon +bacteria +baddy +bade +bader +badge +badged +badger +badgered +badgers +badges +badinage +badlands +badly +badness +baffle +baffled +baffler +baffles +baffling +bagdad +bagels +bagful +bagfuls +baggage +baggages +bagged +bagger +baggier +baggiest +bagging +baggy +baghdad +bagman +bagmen +bagpipe +bagpiper +bagpipes +bags +baguette +bahamas +bail +bailed +bailiff +bailiffs +bailing +bailout +bails +bait +baited +baiters +baiting +baitings +baits +bake +baked +baker +bakeries +bakers +bakery +bakes +baking +bakings +baklavas +balance +balanced +balancer +balances +balcony +bald +balder +baldest +balding +baldly +baldness +baldy +bale +baled +baleen +baleful +bales +bali +baling +ball +ballad +ballade +ballades +ballads +ballast +ballasts +ballet +balletic +ballets +balloon +balloons +ballot +balloted +ballots +ballpen +ballpens +ballroom +balls +ballyhoo +balm +balmier +balmiest +balmoral +balms +balmy +baloney +balsa +balsam +baltic +baluster +bambino +bamboo +bamboos +banal +banality +banana +bananas +band +bandage +bandaged +bandages +bandanna +banded +bandied +bandier +bandiest +banding +bandit +banditry +bandits +bandpass +bands +bane +bang +banged +banger +bangers +banging +bangkok +bangle +bangles +bangs +banish +banished +banishes +banister +banjo +bank +bankable +banked +banker +bankers +banking +banknote +bankrupt +banks +banned +banner +banners +banning +banns +banquet +banquets +bans +banshee +banshees +bantam +bantams +banter +bantered +baobab +baobabs +baptise +baptised +baptises +baptism +baptisms +baptist +baptists +barb +barbaric +barbecue +barbed +barbell +barbels +barber +barbers +barbie +barbs +barcode +bard +bards +bare +bareback +bared +barefoot +barely +bareness +barer +bares +barest +bargain +bargains +barge +barged +barges +barging +baring +baritone +barium +bark +barked +barker +barkers +barking +barks +barky +barley +barmaid +barmaids +barman +barmen +barn +barnacle +barns +barnyard +baron +baronage +baroness +baronet +baronets +baronial +baronies +barons +barony +baroque +barrack +barracks +barrage +barrages +barre +barred +barrel +barrels +barren +barrier +barriers +barring +barrow +barrows +bars +bart +barter +bartered +barterer +basal +basalt +basaltic +basalts +base +baseball +based +baseless +baseline +basely +basement +baseness +baser +bases +basest +bash +bashed +bashes +bashful +bashing +basic +basics +basify +basil +basilica +basilisk +basin +basinful +basing +basins +basis +bask +basked +basket +basketry +baskets +basking +basks +basque +bass +basses +bassist +bassoon +bassoons +bastard +bastards +bastardy +baste +basted +basting +bastion +bastions +batch +batched +batches +batching +bate +bated +bates +bath +bathe +bathed +bather +bathers +bathes +bathetic +bathing +bathos +bathrobe +bathroom +baths +bathtub +bathtubs +bathurst +batik +batiks +bating +batman +batmen +baton +batons +bats +batsman +batsmen +batted +batten +battened +battens +batter +battered +batters +battery +batting +battle +battled +battler +battlers +battles +battling +batty +bauble +baubles +baud +baulk +baulked +baulking +baulks +baulky +bauxite +bavaria +bavarian +bawdier +bawdiest +bawdy +bawl +bawled +bawling +bawls +bayed +baying +bayonet +bayonets +bays +bazaar +bazaars +bazooka +bazookas +beach +beached +beaches +beaching +beachy +beacon +beaconed +beacons +bead +beaded +beadier +beadiest +beading +beadings +beadle +beadles +beads +beadwork +beady +beagle +beagles +beak +beaked +beaker +beakers +beaks +beam +beamed +beaming +beams +beamy +bean +beanbag +beanery +beanie +beanpole +beans +beany +bear +bearable +bearably +beard +bearded +beards +bearer +bearers +bearing +bearings +bearish +bears +bearskin +beast +beastly +beasts +beat +beaten +beater +beaters +beatific +beatify +beating +beatings +beatnik +beatniks +beats +beatup +beau +beaus +beauties +beautify +beauts +beauty +beaux +beaver +beavers +bebop +becalm +becalmed +became +because +beck +beckon +beckoned +beckons +becks +become +becomes +becoming +bedazzle +bedbug +bedbugs +bedcover +bedded +bedder +bedding +beddings +bedecked +bedecks +bedevil +bedevils +bedlam +bedlinen +bedmaker +bedouin +bedouins +bedpan +bedpans +bedpost +bedrock +bedroom +bedrooms +beds +bedside +bedsit +bedsore +bedsores +bedstead +bedtime +bedtimes +beech +beeches +beechnut +beef +beefcake +beefier +beefiest +beefs +beefy +beehive +beehives +beeline +beelines +been +beep +beeper +beeping +beeps +beer +beermat +beermats +beers +beery +bees +beeswax +beet +beetle +beetles +beetroot +beets +befall +befallen +befalls +befell +befit +befits +befitted +befog +before +befoul +befriend +befuddle +began +begat +beget +begets +beggar +beggared +beggarly +beggars +beggary +begged +begging +beggings +begin +beginner +begins +begone +begonias +begot +begotten +begrudge +begs +beguile +beguiled +begun +behalf +behave +behaved +behaves +behaving +behead +beheaded +beheld +behemoth +behest +behind +behinds +behold +beholden +beholder +beholds +behoved +behoves +beige +beijing +being +beings +beirut +bejewel +belabour +belated +belay +belayed +belays +belch +belched +belches +belching +belfast +belfries +belfry +belgian +belgians +belgium +belgrade +belie +belied +belief +beliefs +belies +believe +believed +believer +believes +belike +belittle +bell +belle +belled +belles +bellies +bellow +bellowed +bellows +bells +belly +bellyful +belong +belonged +belongs +beloved +below +belt +belted +belting +beltings +belts +belying +bemoan +bemoaned +bemoans +bemuse +bemused +bench +benches +bend +bendable +bended +bender +benders +bending +bendings +bends +beneath +benefice +benefit +benefits +benelux +bengal +benign +benignly +benjamin +bent +benzene +bequeath +bequest +bequests +berate +berated +berating +berber +bereave +bereaved +bereft +beret +berets +bergs +berk +berlin +berliner +bermuda +bern +berries +berry +berserk +berth +berthed +berths +beryl +beseech +beset +besets +beside +besides +besiege +besieged +besmirch +besot +besotted +bespeak +bespeaks +bespoke +best +bestial +bestiary +bestir +bestow +bestowal +bestowed +bestows +bestride +bestrode +bests +beta +betel +betide +betimes +betoken +betokens +betray +betrayal +betrayed +betrayer +betrays +betroth +betroths +bets +betted +better +bettered +betters +betting +between +betwixt +bevel +bevelled +bevels +beverage +bevvy +bevy +bewail +bewailed +bewails +beware +bewilder +bewitch +beyond +biannual +bias +biased +biases +biasing +biassed +biasses +biassing +bible +bibles +biblical +bibs +bicarb +biceps +bicker +bicycle +bicycled +bicycles +bidden +bidder +bidders +bidding +biddings +bide +bided +bides +bidet +biding +bids +biennial +bier +bifocal +bifocals +bigamist +bigamous +bigamy +bigapple +bigben +bigger +biggest +biggish +bigheads +bigness +bigot +bigoted +bigotry +bigots +bijou +bijoux +bike +biker +bikes +biking +bikini +bikinis +bilabial +bile +biles +bilge +bilges +biliary +bilious +bill +billable +billed +billet +billeted +billets +billiard +billing +billings +billion +billions +billow +billowed +billows +billowy +bills +billy +biltong +bimbo +bimodal +binaries +binary +bind +binder +binders +bindery +binding +bindings +binds +bindweed +bing +binge +bingo +binnacle +binodal +binomial +bins +biology +biomass +biometry +biomorph +bionic +bionics +biopsies +biopsy +bioscope +biota +biotic +biped +bipedal +bipeds +biplane +biplanes +bipolar +birch +birched +birches +bird +birdbath +birdcage +birdie +birdies +birds +birdsong +birth +birthday +births +biscuit +biscuits +biscuity +bisect +bisected +bisects +bisexual +bishop +bishops +bismarck +bismuth +bison +bisons +bissau +bistable +bistro +bitch +bitches +bitching +bitchy +bite +biter +biters +bites +biting +bitingly +bitmap +bits +bitten +bitter +bitterly +bittern +bitters +bitts +bitty +bitumen +bivalve +bivalves +bivouac +bivouacs +biweekly +bizarre +blab +blabbed +blabber +blabs +black +blacked +blacken +blackens +blacker +blackest +blackfly +blacking +blackish +blackleg +blackly +blackout +blacks +blacksea +bladder +bladders +blade +bladed +blades +blah +blame +blamed +blameful +blames +blaming +blanch +blanched +bland +blandest +blandly +blank +blanked +blanker +blanket +blankets +blanking +blankly +blanks +blare +blared +blares +blaring +blase +blast +blasted +blaster +blasters +blasting +blasts +blat +blatancy +blatant +blaze +blazed +blazer +blazers +blazes +blazing +bleach +bleached +bleacher +bleaches +bleak +bleaker +bleakest +bleakly +blearily +bleary +bleat +bleated +bleating +bleats +bled +bleed +bleeder +bleeders +bleeding +bleeds +bleep +bleeped +bleeper +bleeping +bleeps +blemish +blench +blenched +blend +blended +blender +blenders +blending +blends +blesbok +bless +blessed +blesses +blessing +blew +blight +blighted +blights +blimp +blimps +blind +blinded +blinder +blindest +blinding +blindly +blinds +blink +blinked +blinker +blinkers +blinking +blinks +blip +blips +bliss +blissful +blister +blisters +blithe +blithely +blitz +blizzard +bloat +bloated +bloating +blob +blobs +bloc +block +blockade +blockage +blocked +blockers +blocking +blockish +blocks +blocky +blocs +bloke +blokes +blond +blonde +blonder +blondes +blondest +blonds +blood +blooded +bloodied +bloodier +bloodies +bloodily +bloodred +bloods +bloody +bloom +bloomed +bloomer +bloomers +blooming +blooms +bloomy +blossom +blossoms +blot +blotch +blotched +blotches +blotchy +blots +blotted +blotter +blotting +blouse +blouses +blow +blowed +blower +blowers +blowfly +blowing +blowlamp +blown +blowpipe +blows +blowup +blubber +bludgeon +blue +bluebell +bluebird +blueish +bluemoon +blueness +bluenile +bluer +blues +bluest +bluesy +bluff +bluffed +bluffer +bluffers +bluffing +bluffs +bluish +blunder +blunders +blunt +blunted +blunter +bluntest +blunting +bluntly +blunts +blur +blurb +blurbs +blurred +blurring +blurry +blurs +blurt +blurted +blurting +blurts +blush +blushed +blusher +blushers +blushes +blushing +bluster +blusters +blustery +bmus +boar +board +boarded +boarder +boarders +boarding +boards +boars +boas +boast +boasted +boaster +boasters +boastful +boasting +boasts +boat +boated +boater +boaters +boating +boatload +boatman +boatmen +boats +bobbed +bobbies +bobbin +bobbing +bobbins +bobble +bobbles +bobby +bobcat +bobs +bobsled +bobtail +bobtails +bode +boded +bodes +bodice +bodices +bodied +bodies +bodiless +bodily +boding +bodkin +body +bodywork +boer +boers +boerwar +boffin +boffins +bogey +bogeyman +bogeymen +bogeys +bogged +boggiest +bogging +boggle +boggled +boggles +boggling +boggy +bogies +bogs +bogus +bogy +bohemian +boil +boiled +boiler +boilers +boiling +boils +bola +bold +bolder +boldest +boldface +boldly +boldness +bole +bolero +boleyn +bolivia +bollard +bollards +bologna +bolster +bolsters +bolt +bolted +bolting +bolts +bomb +bombard +bombards +bombast +bombasts +bombay +bombed +bomber +bombers +bombing +bombings +bombs +bonanza +bonanzas +bonbon +bonbons +bond +bondage +bonded +bonding +bondings +bonds +bone +boned +boneless +bonemeal +bones +boney +bonfire +bonfires +bong +bongs +bonier +boniest +bonn +bonnet +bonneted +bonnets +bonnie +bonniest +bonny +bonobo +bonsai +bonus +bonuses +bony +boobies +booboo +booby +booed +boohoo +booing +book +bookable +bookcase +booked +bookends +bookers +bookie +bookies +booking +bookings +bookish +booklet +booklets +bookmark +books +bookshop +bookwork +bookworm +boom +boomed +boomer +booming +booms +boon +boons +boor +boorish +boors +boos +boost +boosted +booster +boosters +boosting +boosts +boot +booted +bootees +booth +booths +booting +bootlace +bootleg +bootless +boots +booty +booze +boozed +boozer +boozers +boozes +bops +boracic +borate +borates +borax +bordeaux +border +bordered +borderer +borders +bore +boreal +bored +boredom +borehole +borer +borers +bores +boring +boringly +born +borne +borneo +boron +borough +boroughs +borrow +borrowed +borrower +borrows +borstal +borstals +bosnia +bosom +bosoms +boson +bosons +boss +bossed +bosses +bossier +bossiest +bossing +bossy +boston +bosun +botanic +botanist +botany +botch +botched +both +bother +bothered +bothers +bothy +botswana +bottle +bottled +bottler +bottles +bottling +bottom +bottomed +bottoms +botulism +boudoir +boudoirs +bouffant +bough +boughs +bought +boulder +boulders +bounce +bounced +bouncer +bouncers +bounces +bouncier +bouncing +bouncy +bound +boundary +bounded +bounder +bounders +bounding +bounds +bounties +bounty +bouquet +bouquets +bourbon +bourbons +bout +boutique +bouts +bovine +bowed +bowel +bowels +bower +bowers +bowie +bowing +bowl +bowlder +bowled +bowler +bowlers +bowlines +bowling +bowls +bowman +bowmen +bows +bowsprit +boxed +boxer +boxers +boxes +boxful +boxing +boxtops +boxwood +boxy +boycott +boycotts +boyhood +boyish +boyishly +boys +boyscout +brabble +brabbled +brabbles +brace +braced +bracelet +bracer +braces +bracing +bracken +bracket +brackets +brackish +bradawl +brag +braggart +bragged +bragging +brags +brahman +brahms +braid +braided +braiding +braids +brail +braille +brain +brainier +brains +brainy +braise +braised +brake +braked +brakes +braking +bramble +brambles +bran +branch +branched +branches +branchy +brand +branded +brandies +branding +brandish +brands +brandy +brans +bras +brash +brasher +brashly +brasiers +brasil +brasilia +brass +brasses +brassy +brat +brats +bratty +bravado +brave +braved +bravely +braver +bravery +braves +bravest +braving +bravo +braw +brawl +brawled +brawler +brawling +brawls +brawn +brawnier +brawny +bray +brayed +braying +brays +braze +brazen +brazened +brazenly +brazier +braziers +brazil +brazing +breach +breached +breaches +bread +breaded +breads +breadth +breadths +break +breakage +breaker +breakers +breakin +breaking +breakins +breakout +breaks +breakup +breakups +bream +breast +breasted +breasts +breath +breathe +breathed +breather +breathes +breaths +breathy +breccias +bred +breech +breeches +breed +breeder +breeders +breeding +breeds +breeze +breezed +breezes +breezier +breezily +breezing +breezy +brethren +breton +breviary +brevity +brew +brewage +brewed +brewer +brewers +brewery +brewing +brews +briar +bribe +bribed +briber +bribers +bribery +bribes +bribing +brick +brickbat +bricked +bricking +brickred +bricks +bridal +bridals +bride +brides +bridge +bridged +bridges +bridging +bridle +bridled +bridles +bridling +brief +briefed +briefer +briefest +briefing +briefly +briefs +briers +brig +brigade +brigades +brigand +brigands +bright +brighten +brighter +brightly +brighton +brim +brimmed +brimming +brims +brindled +brine +brines +bring +bringer +bringing +brings +brink +brinks +briny +brio +brioche +brisbane +brisk +brisker +briskest +briskly +bristle +bristled +bristles +bristly +brit +britain +british +britons +brittle +broach +broached +broaches +broad +broaden +broadens +broader +broadest +broadly +broadway +brocade +brocaded +broccoli +brochure +brogue +brogues +broil +broiled +broiler +broiling +broils +broke +broken +brokenly +broker +brokered +brokers +broking +bromide +bromides +bromine +bronchi +bronco +bronze +bronzed +bronzes +brooch +brooches +brood +brooded +brooding +broods +broody +brook +brooklyn +brooks +broom +brooms +broth +brothel +brothels +brother +brothers +broths +brought +brouhaha +brow +browbeat +brown +browned +browner +brownest +brownie +brownies +browning +brownish +browns +brows +browse +browsed +browser +browsers +browses +browsing +bruise +bruised +bruiser +bruisers +bruises +bruising +brunch +brunches +brunei +brunet +brunets +brunette +brunt +brunts +brush +brushed +brushes +brushing +brushoff +brushup +brushy +brusque +brussels +brutal +brutally +brute +brutes +brutish +brutus +bubble +bubbled +bubbles +bubblier +bubbling +bubbly +bubonic +buck +bucked +bucket +buckets +bucking +buckle +buckled +buckler +bucklers +buckles +buckling +bucks +buckshot +buckskin +bucolic +budapest +budded +buddhism +buddhist +buddies +budding +buddings +buddy +budge +budged +budget +budgeted +budgets +budgie +budgies +budging +buds +buff +buffalo +buffer +buffered +buffers +buffet +buffeted +buffets +buffing +buffoon +buffoons +buffs +bugbear +bugbears +bugeyed +bugged +bugger +buggered +buggers +buggery +buggies +bugging +buggy +bugle +bugler +buglers +bugles +bugs +build +builder +builders +building +builds +buildup +buildups +built +builtin +builtup +bulb +bulbous +bulbs +bulgaria +bulge +bulged +bulges +bulging +bulgy +bulimia +bulimic +bulk +bulkhead +bulkier +bulkiest +bulks +bulky +bull +bulldog +bulldogs +bulldoze +bullet +bulletin +bullets +bullfrog +bullied +bullies +bullion +bullish +bullock +bullocks +bulls +bully +bullying +bulwark +bulwarks +bumble +bumbled +bumbler +bumblers +bumbles +bumbling +bump +bumped +bumper +bumpers +bumpier +bumpiest +bumping +bumpkin +bumpkins +bumps +bumpy +bums +bunch +bunched +bunches +bunching +bundle +bundled +bundles +bundling +bung +bungalow +bungee +bungle +bungled +bungler +bunglers +bungles +bungling +bunion +bunions +bunk +bunked +bunker +bunkered +bunkers +bunks +bunkum +bunnies +bunny +buns +bunting +bunyan +buoy +buoyancy +buoyant +buoyed +buoys +burble +burbled +burbles +burbling +burden +burdened +burdens +burdock +bureau +bureaus +bureaux +burette +burg +burgeon +burgeons +burger +burgers +burghers +burglar +burglars +burglary +burgle +burgled +burgles +burgling +burgundy +burial +burials +buried +buries +burlier +burliest +burly +burma +burmese +burn +burned +burner +burners +burning +burnings +burns +burnt +burp +burped +burping +burps +burr +burrow +burrowed +burrows +burs +bursar +bursars +bursary +burst +bursted +bursting +bursts +burundi +bury +burying +buses +bush +bushel +bushels +bushes +bushfire +bushier +bushiest +bushing +bushland +bushman +bushmen +bushy +busied +busier +busies +busiest +busily +business +busk +busker +buskers +busking +busman +busmen +bussed +bussing +bust +bustard +bustards +busted +busters +bustier +busting +bustle +bustled +bustles +bustling +busts +busty +busy +busybody +busying +butane +butcher +butchers +butchery +butler +butlers +buts +butt +butted +butter +buttered +butters +buttery +butting +buttock +buttocks +button +buttoned +buttons +buttress +butts +buxom +buyer +buyers +buying +buyout +buys +buzz +buzzard +buzzards +buzzed +buzzer +buzzers +buzzes +buzzing +byebye +byelaw +byelaws +byes +bygone +bygones +bylaw +bylaws +byline +bypass +bypassed +bypasses +bypath +bypaths +byte +bytes +byway +byways +byword +cabal +cabals +cabaret +cabarets +cabbage +cabbages +cabby +cabin +cabinet +cabinets +cabins +cable +cabled +cables +cableway +cabling +cabman +cabmen +caboodle +caboose +cabs +cacao +cache +cached +caches +cachet +caching +cackle +cackled +cackles +cackling +cacti +cactus +cactuses +cadaver +cadavers +caddie +caddied +caddies +caddy +caddying +cade +cadence +cadences +cadenza +cadenzas +cadet +cadets +cadge +cadged +cadger +cadges +cadmium +cads +caesar +cafe +cafes +caftan +caftans +cage +caged +cages +cagey +cagiest +caging +cagoule +cagoules +cagy +cahoots +caiman +caimans +cain +cairn +cairns +cairo +cajole +cajoled +cajoling +cake +caked +cakes +caking +calamity +calcify +calcite +calcium +calculus +calcutta +caldera +caldron +caldrons +calendar +calf +calibre +calico +calif +caliper +calipers +caliph +call +callable +called +caller +callers +callgirl +calling +callings +calliper +callous +callow +calls +callup +callus +calm +calmed +calmer +calmest +calming +calmly +calmness +calms +calorie +calories +calory +calumny +calvary +calve +calves +calvin +calving +calypso +camber +cambodia +came +camel +camelot +camels +cameo +camera +cameras +camisole +camomile +camp +campaign +camped +camper +campers +campfire +camphor +camping +camps +campsite +campus +campuses +cams +camshaft +canaan +canada +canadian +canal +canals +canape +canapes +canard +canaries +canary +canberra +cancan +cancel +cancels +cancer +cancers +candelas +candid +candidly +candies +candle +candles +candour +candy +cane +caned +canes +canine +canines +caning +canings +canister +cannabis +canned +cannel +cannery +cannes +cannibal +cannily +canning +cannon +cannoned +cannons +cannot +cannula +canny +canoe +canoed +canoeing +canoeist +canoes +canon +canonic +canonise +canonry +canons +canopied +canopies +canopy +cans +cant +cantata +cantatas +canted +canteen +canteens +canter +cantered +canters +canticle +canton +cantons +cantor +canvas +canvased +canvases +canvass +canyon +canyons +capable +capably +capacity +cape +caped +caper +capered +capering +capers +capes +capetown +capita +capital +capitals +capitate +capitol +capped +capping +capri +caprice +caprices +capriole +capris +caps +capsize +capsized +capsizes +capstan +capstans +capsule +capsules +captain +captains +caption +captions +captious +captive +captives +captor +captors +capture +captured +captures +capybara +caracal +caracals +carafe +caramel +caramels +carapace +carat +carats +caravan +caravans +caravel +caraway +carbide +carbine +carbines +carbolic +carbon +carbonic +carbons +carbonyl +carboxyl +carcase +carcases +carcass +card +carded +cardiac +cardiff +cardigan +cardinal +carding +cardioid +cards +care +cared +career +careered +careers +carefree +careful +careless +carer +carers +cares +caress +caressed +caresses +carets +careworn +cargo +caribou +caries +caring +carmine +carnage +carnages +carnal +carnally +carnival +carol +carols +carotene +carotid +carotin +carouse +carousel +carp +carpal +carpet +carpeted +carpets +carping +carport +carports +carps +carrel +carriage +carried +carrier +carriers +carries +carrion +carrot +carrots +carroty +carry +carrycot +carrying +cars +carsick +cart +carted +cartel +cartels +carter +carting +cartload +carton +cartons +cartoon +cartoons +carts +carve +carved +carver +carvers +carvery +carves +carving +carvings +casanova +cascade +cascaded +cascades +cascara +case +casebook +cased +caseload +casement +cases +casework +cash +cashbox +cashed +cashes +cashew +cashier +cashiers +cashing +cashless +cashmere +casing +casings +casino +cask +casket +caskets +casks +cassava +cassette +cassock +cassocks +cast +castanet +castaway +caste +caster +casters +castes +casting +castings +castiron +castle +castled +castles +castling +castoff +castoffs +castor +castors +castrate +castrato +casts +casual +casually +casuals +casualty +catacomb +catalyse +catalyst +catapult +cataract +catarrh +catcalls +catch +catched +catcher +catchers +catches +catchier +catching +catchy +category +cater +catered +caterer +caterers +catering +caters +catfish +catgut +catguts +catheter +cathode +cathodes +catholic +cation +cationic +cations +catlike +catnap +catnip +cats +catsuit +cattery +cattle +catwalk +catwalks +caucus +caucuses +caudal +caught +cauldron +caulking +causal +causally +cause +caused +causes +causeway +causing +caustic +caustics +caution +cautions +cautious +cavalier +cavalry +cave +caveat +caveats +caved +cavein +caveman +cavemen +caver +cavern +caverns +cavers +caves +caviar +caviare +caviars +caving +cavities +cavity +cavort +cavorted +cavorts +cawing +cayman +caymans +cease +ceased +ceases +ceasing +cedar +cedars +cede +ceded +cedilla +ceding +ceilidh +ceilidhs +ceiling +ceilings +celeb +celeriac +celery +celibacy +celibate +cell +cellar +cellars +cellist +cellists +cello +cells +cellular +celsius +celtic +cement +cemented +cements +cemetery +cenotaph +censer +censor +censored +censors +censure +censured +censures +census +censuses +cent +centaur +centaurs +centime +centimes +central +centre +centred +centres +centric +centring +centrist +centroid +cents +century +ceramic +ceramics +ceramist +cereal +cereals +cerebral +cerebrum +ceremony +ceres +cerise +certain +certify +cervical +cervix +cess +cession +cesspit +cesspool +cetacean +ceylon +chacha +chad +chafe +chafed +chafes +chaff +chaffed +chaffing +chafing +chagrin +chain +chained +chaining +chains +chainsaw +chair +chaired +chairing +chairman +chairmen +chairs +chaldron +chalet +chalets +chalice +chalices +chalk +chalked +chalking +chalks +chalky +chamber +chambers +chamfer +chamois +champ +champing +champion +champs +chance +chanced +chancel +chancer +chancery +chances +chancier +chancing +chancy +chandler +change +changed +changer +changers +changes +changing +channel +channels +chant +chanted +chanter +chanting +chantry +chants +chaos +chaotic +chap +chapel +chapels +chaperon +chaplain +chaplain +chapman +chapped +chapping +chaps +chapter +chapters +char +charade +charades +charcoal +chared +charge +charged +charger +chargers +charges +charging +chariot +chariots +charisma +charity +charlady +charles +charlie +charm +charmed +charmer +charmers +charming +charms +charon +charred +charring +chars +chart +charted +charter +charters +charting +charts +chary +chase +chased +chaser +chasers +chases +chasing +chasm +chasms +chassis +chaste +chastely +chastise +chastity +chat +chateau +chats +chatted +chattel +chattels +chatter +chatters +chattily +chatting +chatty +cheap +cheapen +cheapens +cheaper +cheapest +cheapish +cheaply +cheat +cheated +cheater +cheaters +cheating +cheats +check +checked +checker +checkers +checkin +checking +checkout +checks +checkup +checkups +cheddar +cheek +cheeked +cheekier +cheekily +cheeking +cheeks +cheeky +cheep +cheeping +cheer +cheered +cheerful +cheerier +cheerily +cheering +cheerio +cheers +cheery +cheese +cheeses +cheesy +cheetah +cheetahs +chef +chefs +chekov +chemic +chemical +chemise +chemist +chemists +cheque +chequer +chequers +cheques +cherish +cheroot +cheroots +cherries +cherry +cherub +cherubic +cherubim +cherubs +chess +chessmen +chest +chested +chester +chestnut +chests +chesty +chevron +chevrons +chew +chewable +chewed +chewer +chewier +chewiest +chewing +chews +chewy +chic +chicago +chicane +chick +chicken +chickens +chicks +chicory +chide +chided +chides +chiding +chief +chiefly +chiefs +chiffon +child +childish +childly +children +chilean +chili +chill +chilled +chiller +chillers +chilli +chillier +chillies +chilling +chills +chilly +chimaera +chime +chimed +chimera +chimeras +chimes +chiming +chimney +chimneys +chimp +chimps +chin +china +chinese +chink +chinked +chinking +chinks +chinless +chins +chintz +chintzy +chip +chipmunk +chipped +chipping +chips +chiral +chirp +chirped +chirping +chirps +chirpy +chisel +chiseled +chisels +chit +chits +chivalry +chives +chivvied +chivvy +chlorate +chloride +chlorine +chock +chocks +choice +choices +choicest +choir +choirboy +choirs +choke +choked +choker +chokes +choking +cholera +choline +chomp +chomped +chomping +chomps +choose +chooser +choosers +chooses +choosey +choosier +choosing +choosy +chop +chopin +chopped +chopper +choppers +choppier +chopping +choppy +chops +choral +chorale +chorales +chorals +chord +chordal +chords +chore +chorea +chores +chortle +chortled +chortles +chorus +chorused +choruses +chose +chosen +choughs +chow +christ +christen +chroma +chrome +chromed +chromite +chromium +chronic +chubby +chuck +chucked +chucking +chuckle +chuckled +chuckles +chucks +chuff +chuffed +chug +chugged +chugging +chugs +chum +chump +chums +chunk +chunkier +chunks +chunky +chunnel +church +churches +churlish +churn +churned +churning +churns +chute +chutes +chutney +chutzpah +cicada +cicadas +cicero +cider +ciders +cigar +cigaret +cigars +cilia +cilium +cinch +cinder +cinders +cine +cinema +cinemas +cinnamon +cipher +ciphered +ciphers +circa +circle +circled +circles +circlet +circlets +circling +circuit +circuits +circular +circus +circuses +cirrus +cist +cistern +cisterns +citadel +citadels +citation +cite +cited +cites +cithers +cities +citing +citizen +citizens +citrate +citrates +citric +citron +citrons +citrus +citruses +cittern +city +civic +civics +civies +civil +civilian +civilise +civility +civilly +clacking +clad +cladding +claim +claimant +claimed +claiming +claims +clam +clamber +clambers +clammed +clamming +clammy +clamour +clamours +clamp +clamped +clamping +clamps +clams +clan +clang +clanged +clangers +clanging +clank +clanked +clanking +clannish +clans +clansmen +clap +clapped +clapper +clappers +clapping +claps +claptrap +claret +clarets +clarify +clarinet +clarion +clarity +clash +clashed +clashes +clashing +clasp +clasped +clasper +clasping +clasps +class +classed +classes +classic +classics +classier +classify +classing +classy +clatter +clatters +clausal +clause +clauses +clavicle +claw +clawed +clawing +claws +clay +clayey +claymore +clays +clean +cleancut +cleaned +cleaner +cleaners +cleanest +cleaning +cleanly +cleans +cleanse +cleansed +cleanser +cleanses +cleanup +clear +clearcut +cleared +clearer +clearest +clearing +clearly +clears +clearup +clearups +clearway +cleat +cleavage +cleave +cleaved +cleaver +cleavers +cleaves +cleaving +clef +cleft +clefts +cleg +clematis +clemency +clement +clench +clenched +clenches +clergies +clergy +cleric +clerical +clerics +clerk +clerks +clever +cleverer +cleverly +cliche +cliches +click +clicked +clicking +clicks +client +clients +cliff +cliffs +climate +climates +climatic +climax +climaxed +climaxes +climb +climbed +climber +climbers +climbing +climbs +climes +clinch +clinched +clinches +cling +clingers +clinging +clings +clinic +clinical +clinics +clink +clinked +clinker +clinking +clip +clipped +clipper +clippers +clipping +clips +clique +cliques +cliquey +clitoral +clitoris +cloaca +cloak +cloaked +cloaking +cloaks +clobber +clock +clocked +clocking +clocks +clod +clods +clog +clogged +clogging +clogs +cloister +clonal +clone +cloned +clones +cloning +closable +close +closed +closely +closer +closers +closes +closest +closet +closeted +closets +closeup +closeups +closing +closings +closure +closures +clot +cloth +clothe +clothed +clothes +clothier +clothing +cloths +clots +clotted +clotting +cloud +clouded +cloudier +clouding +clouds +cloudy +clout +clouted +clouts +clove +cloven +clover +cloves +clown +clowned +clowning +clownish +clowns +cloying +club +clubbed +clubbing +clubman +clubroom +clubs +cluck +clucked +clucking +clucks +clue +clued +cluedup +clueless +clues +clumber +clump +clumped +clumping +clumps +clumpy +clumsier +clumsily +clumsy +clung +cluster +clusters +clutch +clutched +clutches +clutter +clutters +coach +coached +coaches +coaching +coachman +coachmen +coacted +coaction +coacts +coal +coalesce +coalface +coals +coapts +coarse +coarsely +coarsens +coarser +coarsest +coast +coastal +coasted +coaster +coasters +coasting +coasts +coat +coated +coating +coatings +coats +coauthor +coax +coaxed +coaxes +coaxial +coaxing +cobalt +cobble +cobbled +cobbler +cobblers +cobbles +cobbling +coble +cobra +cobras +cobs +cobweb +cobwebby +cobwebs +coca +cocain +cocaine +cochlea +cochlear +cock +cockatoo +cockcrow +cocked +cockerel +cockeyed +cockier +cockiest +cocking +cockle +cockles +cockney +cockneys +cockpit +cockpits +cocks +cocksure +cocktail +cocky +cocoa +coconut +coconuts +cocoon +cocooned +cocoons +coda +coddle +coddling +code +coded +codeine +codename +coder +coders +codes +codeword +codex +codfish +codices +codicil +codicils +codified +codifies +codify +coding +codling +codpiece +cods +coerce +coerced +coercer +coerces +coercing +coercion +coercive +coeval +coexist +coexists +coffee +coffees +coffer +coffers +coffin +coffins +cogency +cogent +cogently +cogitate +cognac +cognacs +cognate +cognates +cogs +cohabit +cohere +cohered +coherent +coheres +cohesion +cohesive +cohort +cohorts +coiffure +coil +coiled +coiling +coils +coin +coinage +coinages +coincide +coined +coiner +coiners +coining +coins +coital +coitus +coke +cola +colander +colas +cold +colder +coldest +coldish +coldly +coldness +colds +coldwar +cole +coleslaw +colitis +collage +collagen +collages +collapse +collar +collared +collars +collate +collated +collates +collect +collects +college +colleges +collide +collided +collides +collie +collier +colliers +colliery +collies +collins +colloid +colloids +collude +colluded +colobus +cologne +colon +colonel +colonels +colonial +colonic +colonies +colonise +colonist +colons +colony +colossal +colossus +colour +coloure +colours +coloury +cols +colt +colts +columbus +column +columnar +columned +columns +coma +comas +comatose +comb +combat +combated +combats +combed +comber +combine +combined +combines +combing +combs +combusts +come +comeback +comedian +comedies +comedown +comedy +comely +comer +comers +comes +comet +cometary +comets +comfort +comforts +comfy +comic +comical +comics +coming +comings +comity +comma +command +commando +commands +commas +commence +commend +commends +comment +comments +commerce +commit +commits +commode +commodes +common +commoner +commonly +commons +communal +commune +communed +communes +commute +commuted +commuter +commutes +compact +compacts +company +compare +compared +compares +compass +compel +compels +compere +compete +competed +competes +compile +compiled +compiler +compiles +complain +complete +complex +complied +complies +complot +comply +comport +compose +composed +composer +composes +compost +composts +compound +compress +comprise +compute +computed +computer +computes +comrade +comrades +conakry +concave +conceal +conceals +concede +conceded +concedes +conceit +conceits +conceive +concept +concepts +concern +concerns +concert +concerti +concerto +concerts +concise +conclave +conclude +concoct +concocts +concord +concords +concrete +concur +concurs +concuss +condemn +condemns +condense +condole +condoled +condoles +condone +condoned +condones +condor +condors +conduct +conducts +conduit +conduits +cone +coned +cones +confer +confers +confess +confetti +confide +confided +confides +confine +confined +confines +confirm +confirms +conflict +confocal +conform +conforms +confound +confront +confuse +confused +confuser +confuses +conga +congeal +congeals +conger +congest +congo +congress +conic +conical +conics +conifer +conifers +conjoin +conjoint +conjugal +conjunct +conjure +conjured +conjurer +conjures +conjuror +conjury +conk +conker +conkers +conman +conmen +connect +connects +conned +connive +connived +connote +connoted +connotes +conquer +conquers +conquest +cons +consent +consents +conserve +consider +consign +consigns +consist +consists +console +consoled +consoles +consort +consorts +conspire +constant +construe +consul +consular +consuls +consult +consults +consume +consumed +consumer +consumes +contact +contacts +contain +contains +contempt +contend +contends +content +contents +contest +contests +context +contexts +continua +continue +contort +contorts +contour +contours +contra +contract +contrary +contras +contrast +contrite +contrive +control +controls +contuse +convect +convects +convene +convened +convener +convenes +convenor +convent +convents +converge +converse +convert +converts +convex +convey +conveyed +conveyor +conveys +convict +convicts +convince +convolve +convoy +convoys +convulse +cony +cooed +cooing +cook +cookbook +cooked +cooker +cookers +cookery +cookies +cooking +cooks +cookware +cool +coolant +coolants +cooled +cooler +coolers +coolest +cooling +coolness +cools +coon +coons +coop +cooped +cooper +coopers +coops +coos +cope +coped +copes +copied +copier +copiers +copies +copilot +coping +copious +coplanar +copout +copouts +copper +coppers +coppery +coppice +coppiced +coppices +copra +cops +copse +copses +copulate +copy +copyable +copycat +copycats +copying +copyist +copyists +coquette +coracle +coral +corals +cord +cordage +cordate +corded +cordial +cordials +cordite +cordless +cordon +cordoned +cordons +cords +corduroy +core +cores +corgi +corgis +corinth +cork +corkage +corked +corks +corky +corn +cornea +corneal +corneas +corned +corner +cornered +corners +cornet +cornets +cornice +cornices +cornish +cornmeal +corns +corny +corona +coronal +coronary +coronas +coroner +coroners +coronet +coronets +corpora +corporal +corps +corpse +corpses +corpus +corral +corrals +correct +corrects +corridor +corrode +corroded +corrodes +corrupt +corrupts +corsage +corse +corset +corsets +corsica +corslet +cortege +cortex +cortical +cortisol +corvette +cosier +cosiest +cosily +cosine +cosines +cosiness +cosmetic +cosmic +cosmical +cosmos +cossacks +cosset +cosseted +cossets +cost +costar +costars +costed +costing +costings +costive +costless +costlier +costly +costs +costume +costumed +costumes +cosy +coterie +cots +cottage +cottages +cotton +cottoned +cottons +couch +couched +couches +couching +cougar +cougars +cough +coughed +coughing +coughs +could +couloir +coulomb +coulombs +council +councils +counsel +counsels +count +counted +counter +counters +countess +counties +counting +country +counts +county +coup +coupe +coupes +couple +coupled +coupler +couplers +couples +couplet +couplets +coupling +coupon +coupons +coups +courage +courier +couriers +course +coursed +courses +coursing +court +courted +courtesy +courtier +courting +courtly +courts +couscous +cousin +cousinly +cousins +couther +couture +covalent +cove +coven +covenant +covens +cover +coverage +covered +covering +coverlet +covers +covert +covertly +coverts +coverup +coverups +coves +covet +coveted +coveting +covetous +covets +coward +cowardly +cowards +cowboy +cowboys +cowed +cower +cowered +cowering +cowers +cowgirl +cowgirls +cowhand +cowherd +cowing +cowl +cowled +cowling +coworker +cowriter +cows +cowshed +cowsheds +cowslip +cowslips +coxcomb +coxcombs +coxed +coxes +coxing +coxswain +coyly +coyness +coyote +coyotes +cozier +crab +crabby +crabs +crack +cracked +cracker +crackers +cracking +crackle +crackled +crackles +crackly +crackpot +cracks +cradle +cradled +cradles +cradling +craft +crafted +crafter +craftier +craftily +crafting +crafts +crafty +crag +craggy +crags +cram +crammed +crammer +cramming +cramp +cramped +cramping +crampon +crampons +cramps +crams +cran +crane +craned +cranes +cranial +craning +cranium +crank +cranked +cranking +cranks +cranky +crannies +cranny +crap +crash +crashed +crasher +crashers +crashes +crashing +crass +crasser +crassly +crate +crateful +crater +cratered +craters +crates +cravat +cravats +crave +craved +craven +cravenly +craves +craving +cravings +crawl +crawled +crawler +crawlers +crawling +crawls +craws +crayfish +crayon +crayoned +crayons +craze +crazed +crazes +crazier +craziest +crazily +crazy +creak +creaked +creakier +creaking +creaks +creaky +cream +creamed +creamer +creamery +creamier +creaming +creams +creamy +crease +creased +creases +creasing +create +created +creates +creating +creation +creative +creator +creators +creature +creche +creches +credence +credible +credibly +credit +credited +creditor +credits +credo +creed +creeds +creek +creeks +creel +creep +creeper +creepers +creeping +creeps +creepy +cremate +cremated +cremates +creme +creole +creoles +creosote +crepe +crept +crescent +cress +crest +crested +cresting +crests +cretan +cretans +crete +cretin +cretins +crevasse +crevice +crevices +crew +crewed +crewing +crewman +crewmen +crews +crib +cribbage +cribbed +cribbing +cribs +crick +cricket +crickets +cried +crier +cries +crim +crime +crimea +crimes +criminal +crimp +crimped +crimping +crimson +cringe +cringed +cringes +cringing +crinkle +crinkled +crinkly +cripple +crippled +cripples +crises +crisis +crisp +crisped +crisper +crispier +crisply +crisps +crispy +criteria +critic +critical +critics +critique +critter +croak +croaked +croakier +croaking +croaks +croatia +croatian +crochet +crochets +crock +crockery +crocks +crocus +crocuses +croft +crofter +crofters +crofting +crofts +crone +crones +cronies +crony +crook +crooked +crooking +crooks +croon +crooned +crooner +crooners +crooning +croons +crop +cropped +cropper +croppers +cropping +crops +croquet +crores +crosier +crosiers +cross +crossbar +crossbow +crossed +crosser +crosses +crossing +crossly +crotch +crotchet +crouch +crouched +crouches +croup +croupier +croutons +crow +crowbar +crowbars +crowd +crowded +crowding +crowds +crowed +crowing +crown +crowned +crowning +crowns +crows +crozier +croziers +crucial +cruciate +crucible +crucifix +crucify +crude +crudely +cruder +crudest +crudity +cruel +crueler +cruelest +crueller +cruelly +cruelty +cruise +cruised +cruiser +cruisers +cruises +cruising +cruller +crumb +crumbing +crumble +crumbled +crumbles +crumbly +crumbs +crumby +crummy +crumpet +crumpets +crumple +crumpled +crumples +crunch +crunched +cruncher +crunches +crunchy +crusade +crusaded +crusader +crusades +crush +crushed +crusher +crushers +crushes +crushing +crust +crustal +crusted +crustier +crusts +crusty +crutch +crutches +crux +cruxes +crying +cryings +cryostat +crypt +cryptic +crypts +crystal +crystals +cuba +cuban +cubans +cube +cubed +cubes +cubic +cubical +cubicle +cubicles +cubing +cubism +cubist +cubistic +cubists +cubit +cubits +cuboid +cubs +cuckold +cuckoo +cuckoos +cucumber +cuddle +cuddled +cuddles +cuddlier +cuddling +cuddly +cudgel +cudgels +cuds +cued +cueing +cues +cuff +cuffed +cuffing +cuffs +cuing +cuirass +cuisine +culdesac +culinary +cull +culled +culling +culls +culpable +culpably +culprit +culprits +cult +cultivar +cults +cultural +culture +cultured +cultures +cultus +culvert +cumlaude +cumulus +cunning +cupboard +cupful +cupid +cupidity +cupola +cupolas +cupped +cupping +cuprous +cups +curable +curare +curate +curated +curates +curative +curator +curators +curb +curbed +curbing +curbs +curd +curdle +curdled +curdles +curdling +curds +cure +cured +curer +cures +curfew +curfews +curia +curial +curie +curies +curing +curio +curious +curl +curled +curlers +curlew +curlews +curlier +curliest +curling +curls +curly +currant +currants +currency +current +currents +curricle +curried +curries +curry +currying +curs +curse +cursed +curses +cursing +cursive +cursor +cursors +cursory +curt +curtail +curtails +curtain +curtains +curtly +curtness +curtsey +curtseys +curtsied +curtsies +curtsy +curve +curved +curves +curving +curvy +cushion +cushions +cusp +cusps +cuss +custard +custards +custody +custom +customer +customs +cutback +cutbacks +cute +cutely +cuteness +cutest +cuticle +cuticles +cutlass +cutler +cutlery +cutlet +cutlets +cutout +cutouts +cutprice +cutrate +cuts +cutter +cutters +cutting +cuttings +cuttle +cyan +cyanide +cyanogen +cyborg +cycad +cycads +cycle +cycled +cycles +cycleway +cyclic +cyclical +cycling +cyclist +cyclists +cycloid +cyclone +cyclones +cyclops +cygnet +cygnets +cylinder +cymbal +cymbals +cynic +cynical +cynicism +cynics +cypher +cyphers +cypress +cyprian +cyprians +cypriot +cypriots +cyprus +cyst +cysteine +cystic +cystine +cystitis +cysts +cytology +cytosine +czar +czars +czech +czechs +dabbed +dabbing +dabble +dabbled +dabbler +dabbles +dabbling +dabs +dace +dacha +dachau +dactyl +dactylic +dactyls +daddies +daddy +dado +dads +daemon +daemonic +daemons +daffodil +daffy +daft +dafter +daftest +daftness +dagama +dagga +dagger +daggers +dahlia +dahlias +dahomey +dailies +daily +daintier +daintily +dainty +dairies +dairy +dairying +dairyman +dairymen +dais +daisies +daisy +dakar +dakoits +dale +dales +dallas +dallied +dally +dallying +damage +damaged +damages +damaging +damascus +damask +dame +dames +dammed +damming +damn +damnable +damnably +damned +damnify +damning +damns +damp +damped +dampen +dampened +dampens +damper +dampers +dampest +damping +dampish +damply +dampness +damps +dams +damsel +damsels +damson +damsons +dance +danced +dancer +dancers +dances +dancing +dandies +dandruff +dandy +dane +danes +danger +dangers +dangle +dangled +dangles +dangling +daniel +danish +dank +dankest +dante +danube +danzig +dapper +dapple +dappled +dapples +dare +dared +dares +daring +daringly +dark +darken +darkened +darkens +darker +darkest +darkish +darkly +darkness +darkroom +darling +darlings +darn +darned +darning +darns +dart +darted +darter +darters +darting +darts +darwin +dash +dashed +dashes +dashing +dassie +dassies +data +database +datable +date +dated +dateline +dates +dating +dative +datum +daub +daubed +dauber +daubing +daughter +daunt +daunted +daunting +daunts +dauphin +dauphins +david +davinci +dawdle +dawdled +dawdling +dawn +dawned +dawning +dawns +daybreak +daycare +daydream +daylight +daylong +dayold +days +daytime +daze +dazed +dazedly +dazing +dazzle +dazzled +dazzler +dazzles +dazzling +dday +deacon +deacons +dead +deadbeat +deaden +deadend +deadened +deadens +deader +deadlier +deadline +deadlock +deadly +deadness +deadon +deadpan +deadsea +deaf +deafen +deafened +deafens +deafer +deafest +deafness +deal +dealer +dealers +dealing +dealings +deals +dealt +dean +deanery +deans +dear +dearer +dearest +dearie +dearies +dearly +dearness +dears +dearth +deary +death +deathbed +deathly +deaths +debacle +debacles +debar +debark +debarred +debars +debase +debased +debaser +debasing +debate +debated +debater +debaters +debates +debating +debauch +debility +debit +debited +debiting +debits +debonair +debone +deboned +debones +debrief +debris +debt +debtor +debtors +debts +debug +debugged +debugger +debugs +debunk +debunks +debut +debutant +debuts +decade +decadent +decades +decaf +decagon +decagons +decamp +decamped +decant +decanted +decanter +decants +decapod +decay +decayed +decaying +decays +decease +deceased +deceases +deceit +deceits +deceive +deceived +deceiver +deceives +december +decency +decent +decently +decibel +decibels +decide +decided +decider +decides +deciding +decile +deciles +decimal +decimals +decimate +decipher +decision +decisive +deck +decked +decker +decking +decks +declaim +declaims +declare +declared +declarer +declares +decline +declined +declines +deco +decode +decoded +decoder +decoders +decodes +decoding +decoke +decor +decorate +decorous +decors +decorum +decouple +decoy +decoyed +decoying +decoys +decrease +decree +decreed +decrees +decrepit +decried +decries +decry +decrying +decrypt +decrypts +dedicate +deduce +deduced +deduces +deducing +deduct +deducted +deducts +deed +deeds +deejay +deem +deemed +deeming +deems +deep +deepen +deepened +deepens +deeper +deepest +deepish +deeply +deepness +deeps +deepsea +deer +deface +defaced +defaces +defacing +defacto +defame +defamed +defamer +defames +defaming +default +defaults +defeat +defeated +defeater +defeats +defecate +defect +defected +defector +defects +defence +defences +defend +defended +defender +defends +defenses +defer +deferral +deferred +defers +defiance +defiant +deficit +deficits +defied +defier +defies +defile +defiled +defiles +defiling +define +defined +definer +defines +defining +definite +deflate +deflated +deflates +deflect +deflects +deflower +deform +deformed +deforms +defraud +defrauds +defray +defrayed +defrost +defrosts +deft +defter +deftly +deftness +defunct +defuse +defused +defuses +defusing +defy +defying +degas +degauss +degrade +degraded +degrades +degrease +degree +degrees +dehorn +deified +deifies +deify +deifying +deism +deist +deists +deities +deity +deject +dejected +dejects +deklerk +delate +delay +delayed +delaying +delays +delegate +delete +deleted +deleter +deletes +deleting +deletion +delhi +deli +delible +delicacy +delicate +delict +delight +delights +delilah +delimit +delimits +delirium +deliver +delivers +delivery +dell +dells +delphi +delta +deltas +deltoid +deltoids +delude +deluded +deludes +deluding +deluge +deluged +deluges +deluging +delusion +delusive +deluxe +delve +delved +delves +delving +demagog +demagogy +demand +demanded +demander +demands +demean +demeaned +demeans +dement +demented +dementia +demerge +demerit +demigod +demigods +demise +demised +demises +demist +demists +demo +demobs +democrat +demolish +demon +demonic +demonise +demons +demote +demoted +demotes +demotic +demotion +demount +demur +demure +demurely +demurred +demurs +deniable +denial +denials +denied +denier +deniers +denies +denim +denims +denizen +denizens +denmark +denote +denoted +denotes +denoting +denounce +dens +dense +densely +denser +densest +density +dent +dental +dented +dentin +dentine +denting +dentist +dentists +dents +denture +dentures +denude +denuded +denudes +denver +deny +denying +depart +departed +departer +departs +depend +depended +depends +depict +depicted +depicts +deplete +depleted +deplore +deplored +deplores +deploy +deployed +deploys +deponent +deport +deported +deportee +deports +depose +deposed +deposing +deposit +deposits +depot +depots +deprave +depraved +depraves +depress +deprive +deprived +deprives +depth +depths +depute +deputed +deputes +deputies +deputise +deputy +derail +derailed +derails +derange +deranged +derate +derated +derates +derbies +derby +derelict +deride +derided +deriders +derides +deriding +derision +derisive +derisory +derive +derived +derives +deriving +dermal +dermic +dermis +derogate +derrick +desalt +descant +descend +descends +descent +descents +describe +desert +deserted +deserter +deserts +deserve +deserved +deserves +design +designed +designer +designs +desire +desired +desires +desiring +desirous +desist +desisted +desk +desks +desktop +desktops +desolate +despair +despairs +despatch +despisal +despise +despised +despises +despite +despoil +despond +despot +despotic +despots +dessert +desserts +destine +destined +destiny +destroy +destroys +destruct +detach +detached +detaches +detail +detailed +details +detain +detained +detainee +detainer +detains +detect +detected +detector +detects +detent +detente +deter +deterred +deters +detest +detested +detester +detests +dethrone +detonate +detour +detoured +detours +detox +detoxify +detract +detracts +detrital +detritus +detroit +deuce +deuced +deuces +deuteron +devalue +devalued +devalues +develop +develops +deviance +deviancy +deviant +deviants +deviate +deviated +deviates +device +devices +devil +devilish +devilled +devilry +devils +devious +devisal +devise +devised +deviser +devises +devising +devoice +devoid +devoir +devolve +devolved +devote +devoted +devotee +devotees +devotes +devoting +devotion +devour +devoured +devourer +devours +devout +devoutly +dewdrop +dewdrops +dews +dewy +dextral +dextrose +dextrous +dhow +diabetes +diabetic +diabolic +diaconal +diadem +diadems +diagnose +diagonal +diagram +diagrams +dial +dialect +dialects +dialing +dialled +dialler +dialling +dialog +dialogue +dials +dialysis +diamante +diameter +diamond +diamonds +diana +diapason +diaper +diapers +diaries +diarist +diarrhea +diary +diaspora +diatom +diatomic +diatoms +diatonic +diatribe +dice +diced +dices +dicey +diciest +dicing +dickens +dictate +dictated +dictates +dictator +diction +dictions +dictum +didactic +didnt +died +diehard +diehards +dies +diesel +diesels +diet +dietary +dieted +dieter +dietetic +dieting +diets +differ +differed +differs +diffract +diffuse +diffused +diffuser +diffuses +digest +digested +digester +digests +digger +diggers +digging +diggings +digit +digital +digitise +digits +dignify +dignity +digraphs +digress +digs +dihedral +dikes +diktat +diktats +dilate +dilated +dilates +dilating +dilation +dilator +dilatory +dildo +dilemma +dilemmas +diligent +dill +dilly +diluent +dilute +diluted +diluter +dilutes +diluting +dilution +dime +dimer +dimers +dimes +diminish +dimly +dimmed +dimmer +dimmers +dimmest +dimming +dimness +dimple +dimpled +dimples +dims +dimwit +dinar +dinars +dine +dined +diner +diners +dines +ding +dingdong +dinged +dinghies +dinghy +dingier +dingiest +dingle +dingo +dingy +dining +dinky +dinner +dinners +dinosaur +dint +dints +diocesan +diocese +diode +diodes +dioptre +dioptres +dioxide +dioxides +dioxin +dioxins +diploid +diploma +diplomas +diplomat +dipolar +dipole +dipoles +dipped +dipper +dipping +dips +dipstick +dire +direct +directed +directly +director +directs +direly +direness +direst +dirge +dirges +dirt +dirtied +dirtier +dirties +dirtiest +dirtily +dirts +dirty +dirtying +disable +disabled +disables +disabuse +disagree +disallow +disarm +disarmed +disarmer +disarms +disarray +disaster +disavow +disband +disbands +disbars +disburse +disc +discant +discard +discards +discern +discerns +disciple +disclaim +disclose +disco +discord +discords +discount +discover +discreet +discrete +discs +discus +discuss +disdain +disease +diseased +diseases +disgorge +disgrace +disguise +disgust +disgusts +dish +dished +dishes +dishier +dishing +dishpan +dishy +disinter +disjoin +disjoint +disjunct +diskette +dislike +disliked +dislikes +dislodge +disloyal +dismal +dismally +dismay +dismayed +dismays +dismiss +dismount +disobey +disobeys +disorder +disown +disowned +disowns +dispatch +dispel +dispels +dispense +disperse +displace +display +displays +disposal +dispose +disposed +disposer +disposes +disproof +disprove +dispute +disputed +disputes +disquiet +disrobe +disrupt +disrupts +dissect +dissects +dissent +dissolve +dissuade +distaff +distal +distally +distance +distant +distaste +distil +distils +distinct +distort +distorts +distract +distress +district +distrust +disturb +disturbs +disunion +disunite +disunity +disuse +disused +ditch +ditched +ditches +ditching +dither +dithered +dithers +ditties +ditto +ditty +diuresis +diuretic +diurnal +diva +divan +divans +divas +dive +dived +diver +diverge +diverged +diverges +divers +diverse +divert +diverted +diverts +dives +divest +divested +divide +divided +dividend +divider +dividers +divides +dividing +divine +divined +divinely +diviner +divines +divinest +diving +divining +divinity +division +divisive +divisor +divisors +divorce +divorced +divorcee +divorces +divot +divots +divulge +divulged +divulges +dizzier +dizziest +dizzily +dizzy +dizzying +doberman +docile +docilely +docility +dock +dockage +docked +docker +dockers +docket +dockets +docking +dockland +docks +dockside +dockyard +docs +doctor +doctoral +doctored +doctors +doctrine +document +dodge +dodged +dodgem +dodgems +dodger +dodgers +dodges +dodgier +dodging +dodgy +dodo +doer +doers +does +doesnt +doffed +doffing +dogdays +doge +dogeared +doges +dogfight +dogfish +dogged +doggedly +doggerel +dogging +doggy +doglike +dogma +dogmas +dogmatic +dogood +dogooder +dogs +dogsbody +dogtag +dogy +dohs +doily +doing +doings +doldrums +dole +doled +doleful +dolerite +doles +doling +doll +dollar +dollars +dolled +dollies +dollop +dolls +dolly +dolman +dolmen +dolomite +dolorous +dolphin +dolphins +dolt +domain +domains +dome +domed +domes +domestic +domicile +dominant +dominate +domineer +dominion +domino +donate +donated +donates +donating +donation +done +dong +donga +donjuan +donkey +donkeys +donned +donning +donor +donors +dons +dont +donut +doodle +doodled +doodles +doodling +doom +doomed +dooming +dooms +doomsday +door +doorbell +doorknob +doorman +doormat +doormats +doormen +doornail +doorpost +doors +doorstep +doorstop +doorway +doorways +dopamine +dope +doped +dopes +dopey +dopier +doping +dopy +dorado +dormancy +dormant +dormer +dormers +dormice +dormouse +dorsal +dorsally +dosage +dosages +dose +dosed +doses +dosing +dossier +dossiers +dotage +dote +doted +dotes +doting +dots +dotted +dotting +dotty +double +doubled +doubles +doublet +doublets +doubling +doubly +doubt +doubted +doubter +doubters +doubtful +doubting +doubts +douche +douching +dough +doughnut +doughs +doughty +dour +dourly +dourness +douse +doused +dousing +dove +dovecot +dovecote +dover +doves +dovetail +dowager +dowagers +dowdier +dowdiest +dowdy +dowel +dowels +down +downbeat +downcast +downed +downfall +downhill +downing +downland +download +downpipe +downplay +downpour +downs +downside +downsize +downturn +downward +downwind +downy +dowries +dowry +dowse +dowser +dowsers +dowsing +doyen +doyenne +doyens +doze +dozed +dozen +dozens +dozes +dozier +dozing +dozy +drab +drabness +drachm +drachma +drachmas +dracone +dracula +draft +drafted +draftee +draftees +drafter +drafters +draftier +drafting +drafts +drafty +drag +dragged +dragging +dragnet +dragon +dragons +dragoon +dragoons +drags +drain +drainage +drained +drainer +draining +drains +drake +drakes +dram +drama +dramas +dramatic +drank +drape +draped +draper +drapers +drapery +drapes +draping +drastic +drat +draught +draughts +draughty +draw +drawable +drawback +drawcord +drawees +drawer +drawers +drawing +drawings +drawl +drawled +drawling +drawls +drawn +draws +dray +drays +dread +dreaded +dreadful +dreading +dreads +dream +dreamed +dreamer +dreamers +dreamier +dreamily +dreaming +dreams +dreamt +dreamy +drear +drearier +drearily +dreary +dredge +dredged +dredger +dredges +dredging +dregs +drench +drenched +drenches +dress +dressage +dressed +dresser +dressers +dresses +dressing +dressy +drew +dribble +dribbled +dribbler +dribbles +dried +drier +driers +dries +driest +drift +drifted +drifter +drifters +drifting +drifts +drill +drilled +driller +drilling +drills +drily +drink +drinker +drinkers +drinking +drinks +drip +dripdry +dripped +dripping +drippy +drips +drivable +drive +drivein +driveins +drivel +drivels +driven +driver +drivers +drives +driveway +driving +drizzle +drizzled +drizzles +drizzly +droll +droller +drollery +drollest +drone +droned +drones +droning +drool +drooled +drooling +drools +droop +drooped +droopier +drooping +droops +droopy +drop +droplet +droplets +dropout +dropouts +dropped +dropper +dropping +drops +dropsy +dross +drought +droughts +drove +drover +drovers +droves +droving +drown +drowned +drowning +drowns +drowse +drowsed +drowses +drowsier +drowsily +drowsy +drub +drubbed +drubbing +drudge +drudgery +drudges +drug +drugged +drugging +druggist +drugs +druid +druids +drum +drumbeat +drummed +drummer +drummers +drumming +drums +drunk +drunkard +drunken +drunker +drunks +dryer +dryers +dryeyed +drying +dryish +dryly +dryness +drystone +dual +dualism +dualisms +dualist +duality +dually +duals +dubbed +dubbing +dubious +dublin +dubs +duce +duchess +duchies +duchy +duck +duckbill +ducked +ducking +duckings +duckling +duckpond +ducks +duct +ducted +ductile +ducting +ducts +dude +dudes +dudgeon +duds +duel +duelled +dueller +duellers +duelling +duellist +duels +dues +duet +duets +duff +duffel +dugout +dugouts +duiker +duke +dukedom +dukedoms +dukes +dulcet +dulcimer +dull +dullard +dullards +dulled +duller +dullest +dulling +dullness +dulls +dully +dulness +duly +dumb +dumbbell +dumber +dumbest +dumbly +dumbness +dumfound +dummied +dummies +dummy +dump +dumped +dumper +dumping +dumpling +dumps +dumpy +dunce +dunces +dune +dunes +dung +dungeon +dungeons +dunghill +dunked +dunking +dunkirk +duodenal +duodenum +duologue +duomo +duopoly +dupe +duped +dupes +duplex +durable +durables +durance +duration +durban +duress +during +dusk +duskier +dusky +dust +dustbin +dustbins +dustcart +dusted +duster +dusters +dustier +dustily +dusting +dustman +dustmen +dustpan +dusts +dusty +dutch +dutchman +dutchmen +duties +dutiful +duty +dutyfree +duvet +duvets +dwarf +dwarfed +dwarfing +dwarfish +dwarfs +dwarves +dwell +dwelled +dweller +dwellers +dwelling +dwells +dwelt +dwindle +dwindled +dwindles +dyad +dyadic +dyed +dyeing +dyeings +dyer +dyers +dyes +dyestuff +dying +dyke +dykes +dynamic +dynamics +dynamism +dynamite +dynamo +dynast +dynastic +dynasts +dynasty +dyne +dyslexia +dyslexic +each +eager +eagerly +eagle +eagles +eaglet +eaglets +earache +earaches +eardrop +eardrops +eardrum +eardrums +eared +earful +earholes +earl +earldom +earldoms +earlier +earliest +earlobe +earlobes +earls +early +earmark +earn +earned +earner +earners +earnest +earning +earnings +earns +earphone +earpiece +earplug +earplugs +earring +earrings +ears +earshot +earth +earthed +earthen +earthing +earthly +earths +earthy +earwax +earwig +earwigs +ease +eased +easel +easels +easement +eases +easier +easiest +easily +easiness +easing +east +easter +easterly +eastern +easting +eastward +easy +eatable +eatage +eaten +eater +eaters +eatery +eating +eatings +eats +eaves +ebbed +ebbing +ebbs +ebbtide +ebony +echelon +echelons +echidna +echidnas +echo +echoed +echoic +echoing +eclair +eclairs +eclectic +eclipse +eclipsed +eclipses +ecliptic +ecology +economic +economy +ecstasy +ecstatic +ectopic +ecuador +eczema +eddied +eddies +eddy +eddying +edema +eden +edge +edged +edgeless +edges +edgeways +edgewise +edgier +edgily +edginess +edging +edgings +edgy +edible +edibles +edict +edicts +edifice +edifices +edified +edifies +edify +edifying +edison +edit +editable +edited +editing +edition +editions +editor +editors +edits +educate +educated +educates +educator +eduction +eels +eelworm +eelworms +eerie +eerier +eeriest +eerily +eeriness +eery +efface +effaced +effacing +effect +effected +effector +effects +efferent +effete +efficacy +effigies +effigy +effluent +effluvia +effort +efforts +effusion +effusive +egged +eggheads +egging +eggs +eggshell +egoism +egoist +egoistic +egoists +egomania +egotism +egotist +egotists +egress +egret +egrets +egypt +egyptian +eider +eidetic +eight +eighteen +eighth +eighties +eights +eighty +einstein +eire +either +eject +ejected +ejecting +ejection +ejector +ejectors +ejects +eked +eking +elal +elan +eland +elands +elapse +elapsed +elapses +elapsing +elastic +elastics +elastin +elate +elated +elates +elation +elbe +elbow +elbowed +elbowing +elbows +elder +elderly +elders +eldest +eldorado +elect +elected +electing +election +elective +elector +electors +electric +electro +electron +elects +elegance +elegant +elegiac +elegies +elegy +element +elements +elephant +elevate +elevated +elevates +elevator +eleven +eleventh +elfin +elflike +elgreco +elicit +elicited +elicits +elide +elided +elides +eliding +eligible +eligibly +elijah +elision +elisions +elite +elites +elitism +elitist +elitists +elixir +elixirs +elks +ellipse +ellipses +ellipsis +elliptic +ells +elms +elnino +elongate +elope +eloped +elopes +eloping +eloquent +else +elude +eluded +eludes +eluding +elusion +elusions +elusive +eluted +elution +elven +elves +elvish +elysee +emaciate +email +emailed +emanate +emanated +emanates +embalm +embalmed +embalmer +embalms +embank +embargo +embark +embarked +embarks +embassy +embattle +embed +embedded +embeds +ember +embers +embezzle +embitter +emblem +emblems +embodied +embodies +embody +embolden +embolism +embosom +emboss +embossed +embrace +embraced +embraces +embroil +embryo +emended +emerald +emeralds +emerge +emerged +emergent +emerges +emerging +emeritus +emersion +emery +emetic +emigrant +emigrate +emigre +emigres +eminence +eminent +emir +emirate +emirates +emirs +emissary +emission +emit +emits +emitted +emitter +emitters +emitting +emotion +emotions +emotive +empathic +empathy +emperor +emperors +emphases +emphasis +emphatic +empire +empires +empiric +employ +employed +employee +employer +employs +emporia +emporium +empower +empowers +empress +emptied +emptier +empties +emptiest +emptily +empty +emptying +emulate +emulated +emulates +emulator +emulsion +emus +enable +enabled +enables +enabling +enact +enacted +enacting +enacts +enamel +enamels +encage +encamp +encamped +encase +encased +encases +encasing +enchain +enchant +enchants +encircle +enclasp +enclave +enclaves +enclose +enclosed +encloses +encode +encoded +encoder +encoders +encodes +encoding +encomium +encore +encored +encores +encroach +encrust +encrypt +encrypts +encumber +endanger +endear +endeared +endears +ended +endemic +endgame +ending +endings +endive +endless +endorse +endorsed +endorser +endorses +endow +endowed +endowing +endows +ends +endued +endues +endure +endured +endures +enduring +enema +enemas +enemies +enemy +energies +energise +energy +enervate +enfeeble +enfold +enfolded +enfolds +enforce +enforced +enforcer +enforces +engage +engaged +engages +engaging +engarde +engels +engender +engine +engined +engineer +engines +england +english +engorge +engorged +engrave +engraved +engraver +engraves +engross +engulf +engulfed +engulfs +enhance +enhanced +enhancer +enhances +enigma +enigmas +enjoin +enjoined +enjoins +enjoy +enjoyed +enjoyer +enjoying +enjoys +enlace +enlarge +enlarged +enlarger +enlarges +enlist +enlisted +enlists +enliven +enlivens +enmasse +enmeshed +enmities +enmity +enneads +ennoble +ennobled +ennobles +ennui +enormity +enormous +enough +enounced +enounces +enquire +enquired +enquirer +enquires +enquiry +enrage +enraged +enrages +enraging +enrich +enriched +enriches +enrobe +enrobed +enrol +enroll +enrolled +enrolls +enrols +enroute +ensconce +ensemble +enshrine +enshroud +ensign +ensigns +enslave +enslaved +enslaves +ensnare +ensnared +ensnarl +ensue +ensued +ensues +ensuing +ensure +ensured +ensures +ensuring +entail +entailed +entails +entangle +entente +enter +entered +entering +enters +enthalpy +enthrone +enthuse +enthused +enthuses +entice +enticed +entices +enticing +entire +entirely +entires +entirety +entities +entitle +entitled +entitles +entity +entomb +entombed +entombs +entrails +entrain +entrance +entrant +entrants +entrap +entreat +entreats +entreaty +entree +entrench +entries +entropic +entropy +entrust +entrusts +entry +entwine +entwined +entwines +envelop +envelope +envelops +enviable +enviably +envied +envies +envious +environ +environs +envisage +envision +envoy +envoys +envy +envying +enwrap +enzyme +enzymes +eons +eosin +ephemera +ephor +epic +epically +epicarp +epics +epicure +epidemic +epidural +epigon +epigones +epigram +epigrams +epigraph +epilepsy +epilogue +episode +episodes +episodic +epistle +epistles +epitap +epitaph +epitaphs +epitaxy +epithet +epithets +epitome +epoch +epochal +epochs +epoxies +epoxy +epsilon +equable +equably +equal +equalise +equality +equalled +equally +equals +equate +equated +equates +equating +equation +equator +equerry +equine +equinox +equip +equipped +equips +equities +equity +eras +erasable +erase +erased +eraser +erasers +erases +erasing +erasure +erasures +erbium +erect +erected +erecter +erectile +erecting +erection +erectly +erects +ergo +ergodic +ergot +ergs +erica +ericas +eritrea +ermine +erode +eroded +erodes +eroding +eros +erose +erosion +erosions +erosive +erotic +erotica +errand +errands +errant +errata +erratic +erratum +erred +erring +error +errors +errs +ersatz +erst +erudite +erupt +erupted +erupting +eruption +eruptive +erupts +esau +escalade +escalate +escapade +escape +escaped +escapee +escapees +escapes +escaping +escapism +escapist +escarp +escarps +eschew +eschewed +eschews +escort +escorted +escorts +escudo +eskimo +esoteric +especial +espied +espousal +espouse +espoused +espouses +espresso +esprit +espy +espying +esquire +esquires +essay +essayed +essayist +essays +essen +essence +essences +estate +estates +esteem +esteemed +esteems +ester +esters +esthete +esthetic +estimate +estonia +estuary +etal +etcetera +etch +etched +etcher +etchers +etches +etching +etchings +eternal +eternity +ethane +ethanol +ether +ethereal +ethic +ethical +ethicist +ethics +ethiopia +ethnic +ethnical +ethology +ethos +ethyl +ethylene +etna +etudes +etui +eugenic +eugenics +eulogies +eulogise +eulogy +eunuch +eunuchs +euphony +euphoria +euphoric +eurasia +eurasian +eureka +eurekas +euro +europe +european +eurydice +eutectic +evacuate +evacuee +evacuees +evadable +evade +evaded +evader +evaders +evades +evading +evaluate +evasion +evasions +evasive +even +evened +evener +evening +evenings +evenly +evenness +evens +evensong +event +eventful +eventide +eventing +events +eventual +ever +everest +evermore +eversion +everting +every +everyday +everyone +eves +evict +evicted +evicting +eviction +evicts +evidence +evident +evil +evildoer +evilly +evilness +evils +evince +evinced +evinces +evincing +evoke +evoked +evokes +evoking +evolute +evolve +evolved +evolves +evolving +ewes +exact +exacted +exacting +exaction +exactly +exacts +exalt +exalted +exalting +exalts +exam +examine +examined +examiner +examines +example +examples +exams +excavate +exceed +exceeded +exceeds +excel +excelled +excels +except +excepted +excepts +excerpt +excerpts +excess +excesses +exchange +excise +excised +excising +excision +excite +excited +excites +exciting +exciton +exclaim +exclaims +exclude +excluded +excludes +excrete +excursus +excuse +excused +excuses +excusing +execute +executed +executes +executor +exegesis +exemplar +exempt +exempted +exempts +exercise +exert +exerted +exerting +exertion +exerts +exes +exeunt +exhale +exhaled +exhales +exhaling +exhaust +exhausts +exhibit +exhibits +exhort +exhorted +exhorts +exhume +exhumed +exhumes +exhuming +exigency +exigent +exiguous +exile +exiled +exiles +exiling +exist +existed +existent +existing +exists +exit +exited +exiting +exits +exmember +exocrine +exoderm +exodus +exorcise +exorcism +exorcist +exotic +exotica +expand +expanded +expander +expands +expanse +expanses +expect +expected +expects +expedite +expel +expelled +expels +expend +expended +expends +expense +expenses +expert +expertly +experts +expiate +expire +expired +expires +expiring +expiry +explain +explains +explicit +explode +exploded +exploder +explodes +exploit +exploits +explore +explored +explorer +explores +expo +exponent +export +exported +exporter +exports +expose +exposed +exposes +exposing +exposure +expound +expounds +express +expunge +expunged +expunges +extend +extended +extender +extends +extent +extents +exterior +extern +external +externs +extinct +extol +extolled +extols +extort +extorted +extorts +extra +extract +extracts +extras +extrema +extremal +extreme +extremes +extrude +extruded +exudate +exude +exuded +exudes +exuding +exult +exultant +exulted +exulting +exults +exwife +exwives +eyeball +eyeballs +eyebrow +eyebrows +eyed +eyeful +eyeglass +eyeing +eyelash +eyeless +eyelet +eyelets +eyelevel +eyelid +eyelids +eyelike +eyeliner +eyepatch +eyepiece +eyes +eyesight +eyesore +eyesores +eyeteeth +eyetooth +eyewash +fable +fabled +fables +fabric +fabrics +fabulous +facade +facades +face +faced +faceless +facelift +facer +facers +faces +facet +faceted +faceting +facets +facia +facial +facials +facile +facility +facing +facings +fact +faction +factions +factious +factor +factored +factors +factory +factotum +facts +factual +faculty +fade +faded +fadeout +fades +fading +fads +faecal +faeces +faggot +faggots +fagot +fags +fail +failed +failing +failings +fails +failure +failures +faint +fainted +fainter +faintest +fainting +faintly +faints +fair +fairer +fairest +fairies +fairing +fairish +fairly +fairness +fairs +fairsex +fairway +fairways +fairy +faith +faithful +faiths +fake +faked +fakers +fakery +fakes +faking +falcon +falconer +falconry +falcons +fall +fallacy +fallen +faller +fallers +fallguy +fallible +falling +fallout +fallow +falls +false +falsebay +falsely +falser +falsetto +falsify +falsity +falter +faltered +falters +fame +famed +familial +familiar +families +family +famine +famines +famish +famished +famous +famously +fanatic +fanatics +fanbelt +fancied +fancier +fanciers +fancies +fanciest +fanciful +fancy +fancying +fandango +fanfare +fanfares +fang +fangs +fanlight +fanned +fanning +fanny +fans +fantail +fantails +fantasia +farad +faraday +faraway +farce +farces +farcical +fare +fared +fares +farewell +farflung +faring +farm +farmed +farmer +farmers +farming +farmings +farmland +farms +farmyard +faroff +farout +farrago +farrier +farriers +farrow +farther +farthest +farthing +fascia +fascias +fascism +fascist +fascists +fashion +fashions +fast +fasted +fasten +fastened +fastener +fastens +faster +fastest +fasting +fastings +fastness +fasts +fatal +fatalism +fatalist +fatality +fatally +fatcat +fate +fated +fateful +fates +father +fathered +fatherly +fathers +fathom +fathomed +fathoms +fatigue +fatigued +fatigues +fatless +fatness +fats +fatted +fatten +fattened +fattens +fatter +fattest +fattier +fattiest +fatty +fatuity +fatuous +fatwa +faucet +faucets +fault +faulted +faulting +faults +faulty +faun +fauna +faunal +faunas +fauns +faust +faustus +favour +favoured +favours +fawn +fawned +fawning +fawns +faxed +faxes +faxing +fealty +fear +feared +fearful +fearing +fearless +fears +fearsome +feasible +feasibly +feast +feasted +feasting +feasts +feat +feather +feathers +feathery +feats +feature +featured +features +febrile +february +feckless +fecund +federal +federate +fedora +feds +fedup +feeble +feebler +feeblest +feebly +feed +feedback +feeder +feeders +feeding +feedings +feeds +feel +feeler +feelers +feeling +feelings +feels +fees +feet +feign +feigned +feigning +feigns +feint +feinted +feinting +feints +feldspar +felicia +felicity +feline +felines +fell +fellatio +felled +feller +felling +fellow +fellows +fells +felon +felons +felony +felt +feltpen +female +females +feminine +feminism +feminist +femur +femurs +fence +fenced +fencer +fencers +fences +fencing +fencings +fend +fended +fender +fenders +fending +fends +fenland +fennel +fens +feral +ferment +ferments +fermion +fermions +fern +ferns +ferny +ferocity +ferret +ferreted +ferrets +ferric +ferried +ferries +ferrite +ferrous +ferrule +ferry +ferrying +ferryman +fertile +fervent +fervid +fervidly +fervour +fescue +fest +festal +fester +festered +festers +festival +festive +festoon +festoons +fetal +fetch +fetched +fetches +fetching +fete +feted +fetes +fetid +fetish +fetishes +fetlock +fetlocks +fetter +fettered +fetters +fettle +fetus +feud +feudal +feuded +feuding +feudist +feuds +fever +fevered +feverish +fevers +fewer +fewest +fewness +fiance +fiancee +fiasco +fiat +fibbed +fibber +fibbers +fibbing +fibers +fibre +fibred +fibres +fibrosis +fibrous +fibs +fibula +fiche +fiches +fickle +fiction +fictions +fictive +ficus +fiddle +fiddled +fiddler +fiddlers +fiddles +fiddling +fiddly +fidelity +fidget +fidgeted +fidgets +fidgety +fief +fiefdom +fiefdoms +fiefs +field +fielded +fielder +fielders +fielding +fields +fiend +fiendish +fiends +fierce +fiercely +fiercer +fiercest +fierier +fieriest +fierily +fiery +fiesta +fiestas +fife +fifes +fifteen +fifth +fifthly +fifths +fifties +fiftieth +fifty +fight +fighter +fighters +fighting +fights +figleaf +figment +figments +figs +figtree +figural +figure +figured +figurer +figures +figurine +figuring +fiji +fijians +filament +filch +filched +file +filed +filer +filers +files +filet +filial +filigree +filing +filings +fill +filled +filler +fillers +fillet +fillets +fillies +filling +fillings +fillip +fills +filly +film +filmed +filmic +filming +films +filmset +filmy +filter +filtered +filters +filth +filthier +filthily +filthy +filtrate +final +finale +finales +finalise +finalist +finality +finally +finals +finance +financed +finances +finch +finches +find +findable +finder +finders +finding +findings +finds +fine +fined +finely +fineness +finer +finery +fines +finesse +finest +finetune +finger +fingered +fingers +finial +finicky +fining +finis +finish +finished +finisher +finishes +finite +finitely +finland +finn +finned +finnish +fins +fiord +fiords +fire +firearm +firearms +fireball +firebomb +firebox +fired +firefly +fireman +firemen +firer +fires +fireside +firewood +firework +firing +firings +firkin +firm +firmed +firmer +firmest +firming +firmly +firmness +firms +firmware +firs +first +firstaid +firstly +firsts +firth +fiscal +fiscally +fish +fished +fisher +fishers +fishery +fishes +fishhook +fishier +fishiest +fishing +fishings +fishlike +fishnet +fishwife +fishy +fissile +fission +fissions +fissure +fissured +fissures +fist +fisted +fistful +fists +fistula +fitful +fitfully +fitly +fitment +fitments +fitness +fits +fitted +fitter +fitters +fittest +fitting +fittings +five +fivefold +fiver +fivers +fives +fixable +fixate +fixated +fixates +fixation +fixative +fixed +fixedly +fixer +fixers +fixes +fixing +fixings +fixture +fixtures +fizz +fizzed +fizzes +fizzier +fizziest +fizzing +fizzle +fizzled +fizzles +fizzy +fjord +fjords +flab +flabbier +flabby +flabs +flaccid +flack +flag +flagella +flagged +flagging +flagon +flagons +flagpole +flagrant +flags +flagship +flair +flak +flake +flaked +flakes +flakiest +flaking +flaky +flame +flamed +flamenco +flames +flaming +flamingo +flan +flange +flanged +flanges +flank +flanked +flanker +flanking +flanks +flannel +flannels +flans +flap +flapjack +flapped +flapper +flappers +flapping +flaps +flare +flared +flares +flareup +flareups +flaring +flash +flashed +flasher +flashes +flashier +flashily +flashing +flashy +flask +flasks +flat +flatfish +flatly +flatmate +flatness +flats +flatten +flattens +flatter +flatters +flattery +flattest +flattish +flatus +flaunt +flaunted +flaunts +flautist +flavour +flavours +flaw +flawed +flawless +flaws +flax +flaxen +flay +flayed +flayer +flayers +flaying +flea +fleas +fleck +flecked +flecks +fled +fledge +fledged +fledges +flee +fleece +fleeced +fleeces +fleecing +fleecy +fleeing +flees +fleet +fleeted +fleeter +fleeting +fleetly +fleets +flemish +flesh +fleshed +flesher +fleshes +fleshier +fleshing +fleshly +fleshy +flew +flex +flexed +flexes +flexible +flexibly +flexile +flexing +flexion +flexor +flick +flicked +flicker +flickers +flickery +flicking +flicks +flier +fliers +flies +flight +flighted +flights +flighty +flimsier +flimsily +flimsy +flinch +flinched +fling +flinging +flings +flint +flints +flinty +flip +flipflop +flippant +flipped +flipper +flippers +flipping +flips +flirt +flirted +flirting +flirts +flit +fliting +flits +flitted +flitting +float +floated +floater +floaters +floating +floats +floaty +flock +flocked +flocking +flocks +floe +flog +flogged +flogger +floggers +flogging +flogs +flood +flooded +flooding +floodlit +floods +floor +floored +flooring +floors +floozie +floozies +floozy +flop +flopped +flopper +floppier +floppies +flopping +floppy +flops +flora +floral +floras +floreat +florence +floret +florid +florida +floridly +florin +florins +florist +florists +floss +flosses +flossing +flossy +flotilla +flotsam +flounce +flounced +flounces +flounder +flour +floured +flourish +flours +floury +flout +flouted +flouting +flouts +flow +flowed +flower +flowered +flowers +flowery +flowing +flown +flows +flub +flubbed +flue +fluency +fluent +fluently +flues +fluff +fluffed +fluffier +fluffing +fluffs +fluffy +fluid +fluidity +fluidly +fluids +fluke +flukes +flukey +flukier +flukiest +flumes +flumped +flung +flunked +fluor +fluoride +fluorine +flurried +flurries +flurry +flush +flushed +flusher +flushes +flushing +fluster +flute +fluted +flutes +fluting +flutist +flutter +flutters +fluttery +fluvial +flux +fluxes +flyaway +flyer +flyers +flyhalf +flying +flyover +flyovers +flypaper +flypast +flyway +flyways +flywheel +foal +foaled +foaling +foals +foam +foamed +foamier +foamiest +foaming +foams +foamy +fobbed +fobbing +fobs +focal +focally +foci +focus +focused +focuses +focusing +focussed +focusses +fodder +fodders +foehns +foes +foetal +foetid +foetus +foetuses +fogbank +fogey +fogged +foggier +foggiest +fogging +foggy +foghorn +foghorns +fogs +fogy +foible +foibles +foil +foiled +foiling +foils +foist +foisted +foisting +fold +folded +folder +folders +folding +folds +foliage +foliate +foliated +folio +folk +folkart +folkish +folklore +folks +folktale +follicle +follies +follow +followed +follower +follows +folly +foment +fomented +fond +fondant +fonder +fondest +fondle +fondled +fondles +fondling +fondly +fondness +fondue +fondues +font +fontanel +fonts +food +foodless +foods +fool +fooled +foolery +fooling +foolish +fools +foolscap +foot +footage +footages +football +footbath +footed +footfall +footgear +foothill +foothold +footing +footings +footless +footman +footmen +footnote +footpads +footpath +footrest +foots +footsie +footsore +footstep +footway +footwear +footwork +fops +forage +foraged +foragers +forages +foraging +foramen +foray +forays +forbad +forbade +forbear +forbears +forbid +forbids +forbore +force +forced +forceful +forceps +forces +forcible +forcibly +forcing +ford +forded +fording +fords +fore +forearm +forearms +forebear +forecast +foredeck +forego +foregone +forehand +forehead +foreign +foreland +foreleg +forelegs +forelock +foreman +foremen +foremost +forename +forensic +forepaw +forepaws +foreplay +foresail +foresaw +foresee +foreseen +foresees +foreskin +forest +forested +forester +forestry +forests +foretell +foretold +forever +forewarn +foreword +forfeit +forfeits +forgave +forge +forged +forger +forgers +forgery +forges +forget +forgets +forging +forgings +forgive +forgiven +forgives +forgo +forgoing +forgone +forgot +fork +forked +forking +forks +forlorn +form +formal +formalin +formally +formant +format +formated +formats +formed +former +formerly +formers +formic +forming +formless +formosa +forms +formula +formulae +formulas +forsake +forsaken +forsakes +forsook +forswear +forswore +forsworn +fort +forte +forth +forties +fortieth +fortify +fortknox +fortress +forts +fortune +fortunes +forty +forum +forums +forward +forwards +fossa +fossil +fossils +foster +fostered +fosters +fought +foul +fouled +fouler +foulest +fouling +foully +foulness +fouls +foulup +foulups +found +founded +founder +founders +founding +foundry +founds +fount +fountain +founts +four +fourfold +fours +foursome +fourteen +fourth +fourthly +fourths +fowl +fowls +foxed +foxes +foxhole +foxholes +foxhunt +foxhunts +foxier +foxiest +foxily +foxiness +foxing +foxtrot +foxtrots +foxy +foyer +foyers +fracas +fractal +fractals +fraction +fracture +fragile +fragment +fragrant +frail +frailer +frailest +frailly +frailty +frame +framed +framer +framers +frames +frameup +framing +franc +france +francs +frank +franked +franker +frankest +franking +frankly +franks +frantic +fraud +frauds +fraught +fray +frayed +fraying +frays +frazzle +frazzled +freak +freaked +freakish +freaks +freaky +freckle +freckled +freckles +free +freebie +freed +freedom +freedoms +freefall +freehand +freehold +freeing +freely +freeman +freemen +freer +frees +freesia +freesias +freeway +freeze +freezer +freezers +freezes +freezing +freight +freights +french +frenetic +frenzied +frenzies +frenzy +freon +freons +frequent +fresco +fresh +freshen +freshens +fresher +freshers +freshest +freshly +freshman +freshmen +fret +fretful +fretless +frets +fretsaw +fretsaws +fretted +fretting +fretwork +freud +freya +friable +friar +friars +friary +friction +friday +fridays +fridge +fridges +fried +friend +friendly +friends +friers +fries +frieze +friezes +frigate +frigates +fright +frighted +frighten +frights +frigid +frigidly +frijole +frill +frilled +frillier +frills +frilly +fringe +fringed +fringes +fringing +fringy +frippery +frisk +frisked +friskier +friskily +frisking +frisks +frisky +frisson +fritter +fritters +frivol +frivols +frizzle +frizzles +frizzy +frock +frocks +frog +froggy +frogman +frogmen +frogs +frolic +frolics +from +frond +fronds +front +frontage +frontal +frontals +fronted +frontier +fronting +fronts +frost +frosted +frostier +frostily +frosting +frosts +frosty +froth +frothed +frothier +frothing +froths +frothy +froward +frown +frowned +frowning +frowns +froze +frozen +fructose +frugal +frugally +fruit +fruited +fruiter +fruitful +fruitier +fruiting +fruition +fruits +fruity +frumps +frumpy +frustum +fryer +fryers +frying +fryings +fuchsia +fuchsias +fuddle +fuddled +fuddles +fudge +fudged +fudges +fudging +fuel +fuelled +fuelling +fuels +fugal +fugitive +fugue +fugues +fuhrer +fulcrum +fulfil +fulfils +full +fullback +fuller +fullest +fulling +fullish +fullmoon +fullness +fullpage +fullstop +fulltime +fully +fulsome +fumarole +fumble +fumbled +fumbles +fumbling +fume +fumed +fumes +fumigate +fuming +fumingly +function +fund +funded +funding +fundings +funds +funeral +funerals +funerary +funereal +funfair +fungal +fungi +fungoid +fungous +fungus +funguses +funk +funked +funkier +funky +funnel +funnels +funnier +funnies +funniest +funnily +funny +furies +furious +furled +furling +furlong +furlongs +furlough +furls +furnace +furnaces +furnish +furore +furores +furred +furrier +furriers +furriest +furring +furrow +furrowed +furrows +furry +furs +further +furthers +furthest +furtive +fury +furze +fuse +fused +fuselage +fuses +fusible +fusilier +fusing +fusion +fusions +fuss +fussed +fusses +fussier +fussiest +fussily +fussing +fussy +fustian +fusty +futile +futilely +futility +futon +future +futures +futurism +futurist +futurity +fuzz +fuzzed +fuzzes +fuzzier +fuzziest +fuzzily +fuzzy +gabble +gabbled +gabbles +gabbling +gable +gabled +gables +gabon +gadded +gadding +gadfly +gadget +gadgetry +gadgets +gaff +gaffe +gaffes +gaga +gage +gagged +gagging +gaggle +gaggled +gaging +gags +gagster +gaiety +gaijin +gaily +gain +gained +gainer +gainers +gainful +gaining +gainly +gains +gainsay +gait +gaiter +gaiters +gaits +gala +galactic +galas +galaxies +galaxy +gale +galena +gales +galilean +galileo +gall +gallant +gallants +galled +galleon +galleons +gallery +galley +galleys +gallic +galling +gallium +gallon +gallons +gallop +galloped +gallops +gallows +galls +galop +galore +galoshes +gals +galvanic +gambia +gambian +gambit +gambits +gamble +gambled +gambler +gamblers +gambles +gambling +gambol +gambols +game +gamed +gamely +gamers +games +gamesmen +gamete +gametes +gaming +gamma +gammon +gamut +gamy +gander +ganders +gandhi +gang +ganged +ganger +gangers +ganges +ganging +gangland +ganglia +gangling +ganglion +gangly +gangrene +gangs +gangster +gangway +gangways +gannet +gannets +gantries +gantry +gaol +gaoled +gaoler +gaolers +gaols +gape +gaped +gapes +gaping +gapingly +gaps +garage +garaged +garages +garb +garbage +garbed +garble +garbled +garbles +garbling +garbs +garden +gardener +gardens +gargle +gargled +gargles +gargling +gargoyle +garish +garishly +garland +garlands +garlic +garment +garments +garner +garnered +garnet +garnets +garnish +garotte +garotted +garottes +garret +garrets +garrison +garrotte +garter +garters +gaseous +gases +gash +gashed +gashes +gashing +gasify +gasket +gaskets +gaslight +gasp +gasped +gasper +gasping +gasps +gassed +gasses +gassier +gassiest +gassing +gassy +gastric +gasworks +gate +gateau +gateaus +gateaux +gated +gatepost +gates +gateway +gateways +gather +gathered +gatherer +gathers +gating +gauche +gaud +gaudiest +gaudily +gaudy +gauge +gauged +gauges +gauging +gaul +gauls +gaunt +gaunter +gauntlet +gauntly +gauze +gave +gavel +gavial +gavials +gavotte +gawk +gawking +gawky +gawpin +gayest +gays +gaze +gazebo +gazed +gazelle +gazelles +gazes +gazette +gazettes +gazing +gdansk +gear +gearbox +geared +gearing +gears +gecko +geek +geeks +geese +geezer +geiger +geisha +geishas +gelatin +gelatine +gelding +geldings +gelled +gels +gemini +gemmed +gems +gemsbok +gemstone +gender +gendered +genders +gene +genera +general +generals +generate +generic +generous +genes +genesis +genetic +genetics +genets +geneva +genial +genially +genie +genii +genital +genitals +genitive +genius +geniuses +genoa +genocide +genome +genomes +genomic +genotype +genre +genres +gent +genteel +gentians +gentile +gentiles +gentle +gentler +gentlest +gentling +gently +gentry +gents +genuine +genus +geodesic +geologic +geology +geometer +geometry +george +georgia +geranium +gerbil +gerbils +germ +german +germane +germanic +germans +germany +germinal +germs +gerund +gestalt +gestapo +gestate +gestural +gesture +gestured +gestures +getable +getaway +gets +gettable +getter +getting +geyser +geysers +ghana +ghanian +ghastly +gherkin +gherkins +ghetto +ghost +ghosted +ghosting +ghostly +ghosts +ghoul +ghoulish +ghouls +giant +giantess +giantism +giants +gibber +gibbered +gibbet +gibbets +gibbon +gibbons +gibbous +gibed +gibes +giblets +giddier +giddiest +giddily +giddy +gift +gifted +gifting +gifts +giftware +gigantic +gigavolt +giggle +giggled +giggles +giggling +giggly +gigolo +gilded +gilders +gilding +gilds +gill +gillie +gills +gilt +gilts +gimcrack +gimlet +gimlets +gimmick +gimmicks +gimmicky +ginger +gingerly +gingers +gingery +gingham +gins +ginseng +gipsies +gipsy +giraffe +giraffes +gird +girded +girder +girders +girding +girdle +girdled +girdles +girdling +girl +girlhood +girlie +girlish +girls +giro +girt +girth +girths +gist +give +giveaway +given +giver +givers +gives +giving +givings +gizzard +glace +glacial +glacier +glaciers +glad +gladden +gladdens +gladder +gladdest +glade +glades +gladioli +gladly +gladness +glamour +glance +glanced +glances +glancing +gland +glands +glans +glare +glared +glares +glaring +glasgow +glasnost +glass +glassed +glasses +glassful +glassier +glassy +glaucoma +glaucous +glaze +glazed +glazer +glazes +glazier +glaziers +glazing +gleam +gleamed +gleaming +gleams +glean +gleaned +gleaning +gleans +glebe +glee +gleeful +glen +glenn +glens +glia +glib +glibly +glibness +glide +glided +glider +gliders +glides +gliding +glim +glimmer +glimmers +glimpse +glimpsed +glimpses +glint +glinted +glinting +glints +glisten +glistens +glitter +glitters +glittery +glitzy +gloaming +gloat +gloated +gloating +glob +global +globally +globe +globed +globes +globose +globular +globule +globules +gloom +gloomful +gloomier +gloomily +glooms +gloomy +gloried +glories +glorify +glorious +glory +glorying +gloss +glossary +glossed +glosses +glossier +glossily +glossing +glossy +glottal +glove +gloved +gloves +glow +glowed +glower +glowered +glowers +glowing +glows +glowworm +glucose +glue +glued +glueing +glues +gluey +gluing +glum +glumly +gluon +glut +gluten +glutted +glutton +gluttons +gluttony +glycerol +glycine +glycol +glyph +glyphs +gnarl +gnarled +gnarling +gnarls +gnash +gnashed +gnashes +gnashing +gnat +gnats +gnaw +gnawed +gnawer +gnawers +gnawing +gnaws +gneiss +gnome +gnomes +gnomic +gnostic +gnus +goad +goaded +goading +goads +goahead +goal +goalies +goalless +goalpost +goals +goat +goatee +goatees +goats +goatskin +gobbet +gobbets +gobble +gobbled +gobbler +gobbles +gobbling +gobi +gobies +goblet +goblets +goblin +goblins +godchild +goddess +godhead +godless +godlier +godlike +godly +gods +godsend +godson +godsons +goer +goers +goes +goethe +gofer +goggled +goggles +goggling +going +goings +goitre +goitres +gold +golden +goldfish +golds +golf +golfer +golfers +golfing +golgotha +goliath +golliwog +golly +gonad +gonads +gondola +gondolas +gone +gong +gongs +good +goodbye +goodbyes +goodhope +goodies +goodish +goodly +goodness +goods +goodwill +goody +gooey +goof +goofed +goofing +goofs +goofy +googlies +googly +goon +goons +goose +gopher +gophers +gordian +gore +gored +gores +gorge +gorged +gorgeous +gorges +gorging +gorgon +gorgons +gorier +goriest +gorilla +gorillas +goring +gormless +gorse +gory +gosh +gosling +goslings +goslow +goslows +gospel +gospels +gossamer +gossip +gossiped +gossips +gossipy +goth +gothic +goths +gotten +gouda +gouge +gouged +gouges +gouging +goulash +gourd +gourds +gourmand +gourmet +gourmets +gout +govern +governed +governor +governs +gown +gowned +gowns +grab +grabbed +grabber +grabbers +grabbing +grabs +grace +graced +graceful +graces +gracing +gracious +grade +graded +grader +graders +grades +gradient +grading +gradings +gradual +graduand +graduate +graffiti +graffito +graft +grafted +grafting +grafts +graham +grail +grails +grain +grained +grainier +grains +grainy +gram +grammar +grammars +gramme +grammes +grams +granary +grand +grandads +granddad +grandee +grandees +grander +grandest +grandeur +grandly +grandma +grandmas +grandpa +grandpas +grands +grandson +grange +granite +granites +granitic +grannie +grannies +granny +grant +granted +grantee +granting +grants +granular +granule +granules +grape +grapes +graph +graphed +graphic +graphics +graphite +graphs +grapnel +grapple +grappled +grapples +grasp +grasped +grasper +grasping +grasps +grass +grassed +grasses +grassier +grassy +grate +grated +grateful +grater +graters +grates +gratify +grating +gratings +gratis +gratuity +grave +gravel +gravelly +gravels +gravely +graven +graver +graves +gravest +gravies +gravitas +graviton +gravity +gravures +gravy +graze +grazed +grazer +grazes +grazing +grease +greased +greasers +greases +greasier +greasing +greasy +great +greater +greatest +greatly +grecian +greece +greed +greedier +greedily +greeds +greedy +greek +greeks +green +greened +greener +greenery +greenest +greenfly +greenie +greening +greenish +greenly +greens +greet +greeted +greeting +greets +gremlin +gremlins +grenade +grenades +grew +grey +greyed +greyer +greyest +greying +greyish +greyness +greys +grid +gridded +gridiron +gridlock +grids +grief +griefs +grieve +grieved +griever +grievers +grieves +grieving +grievous +griffin +griffins +griffon +grill +grille +grilled +grilles +grilling +grills +grim +grimace +grimaced +grimaces +grime +grimiest +grimly +grimm +grimmer +grimmest +grimness +grimy +grin +grind +grinded +grinder +grinders +grinding +grinds +grinned +grinner +grinning +grins +grip +gripe +griped +gripes +griping +gripped +gripper +grippers +gripping +grips +grislier +grisly +grist +gristle +grit +grits +gritted +grittier +gritting +gritty +grizzled +grizzly +groan +groaned +groaner +groaners +groaning +groans +groat +groats +grocer +grocers +grocery +grog +groggily +groggy +groin +groins +grommet +grommets +groom +groomed +groomer +groomers +grooming +grooms +groove +grooved +grooves +groovier +grooving +groovy +grope +groped +groper +gropers +gropes +groping +gropings +gross +grossed +grosser +grossest +grossly +grotto +grouch +grouchy +ground +grounded +grounds +group +grouped +grouper +groupie +groupies +grouping +groups +grouse +grouses +grout +grouting +grove +grovel +grovels +groves +grow +grower +growers +growing +growl +growled +growler +growling +growls +grown +grownup +grownups +grows +growth +growths +grub +grubbed +grubbier +grubbing +grubby +grubs +grudge +grudges +grudging +gruel +grueling +gruesome +gruff +gruffly +grumble +grumbled +grumbler +grumbles +grumpier +grumpily +grumps +grumpy +grunge +grunt +grunted +grunter +grunting +grunts +guanaco +guanine +guano +guard +guarded +guardian +guarding +guards +guava +guavas +gudgeon +guerilla +guess +guessed +guesses +guessing +guest +guesting +guests +guffaw +guffawed +guffaws +guidance +guide +guided +guider +guiders +guides +guiding +guidings +guild +guilder +guilders +guilds +guile +guilt +guiltier +guiltily +guilts +guilty +guinea +guineas +guise +guises +guitar +guitars +gulf +gulfs +gulfwar +gull +gullet +gullets +gulley +gulleys +gullible +gullies +gulls +gully +gulp +gulped +gulping +gulps +gumboil +gumboils +gumboots +gumdrop +gumdrops +gummed +gumming +gums +gumshoe +gumtree +gumtrees +gunboat +gunboats +gunfight +gunfire +gunfires +gunite +gunk +gunman +gunmen +gunmetal +gunned +gunner +gunners +gunnery +gunning +gunpoint +guns +gunship +gunships +gunshot +gunshots +gunsight +gunsmith +gunwale +gunwales +guppies +guppy +gurgle +gurgled +gurgles +gurgling +guru +gurus +gush +gushed +gusher +gushes +gushing +gusset +gust +gusted +gustier +gustiest +gusting +gusto +gusts +gusty +gutless +guts +gutsier +gutsy +gutted +gutter +guttered +gutters +gutting +guttural +guys +guzzle +guzzled +guzzler +guzzlers +guzzling +gymkhana +gymnasia +gymnast +gymnasts +gyms +gypsies +gypsum +gypsy +gyrate +gyrated +gyrates +gyrating +gyration +gyro +habit +habitat +habitats +habits +habitual +hacienda +hack +hackable +hacked +hacker +hackers +hacking +hackle +hackles +hackling +hackney +hacks +hacksaw +haddock +haddocks +hades +hadnt +hadron +hadrons +haft +hafts +haggard +haggis +haggle +haggled +haggler +haggling +hags +haha +haiku +hail +hailed +hailing +hails +hair +haircare +haircut +haircuts +hairdo +haired +hairier +hairiest +hairless +hairline +hairnet +hairpin +hairpins +hairs +hairy +haiti +haitian +hake +hakea +hale +half +halfhour +halfway +halibut +halifax +halite +hall +hallmark +hallo +hallow +hallowed +hallows +halls +hallway +hallways +halo +haloed +halogen +halogens +halon +halons +halt +halted +halter +haltered +halters +halting +halts +halve +halved +halves +halving +hamburg +hamitic +hamlet +hamlets +hammer +hammered +hammers +hammock +hammocks +hamper +hampered +hampers +hams +hamster +hamsters +hand +handbag +handbags +handball +handbell +handbill +handbook +handcar +handcart +handcuff +handed +handel +handful +handfuls +handgun +handguns +handhold +handicap +handier +handiest +handily +handing +handle +handled +handler +handlers +handles +handling +handmade +handout +handouts +handover +handrail +hands +handset +handsets +handsome +handy +handyman +handymen +hang +hangar +hangars +hangdog +hanged +hanger +hangers +hanging +hangings +hangman +hangmen +hangouts +hangover +hangs +hangup +hanker +hankered +hankers +hankie +hankies +hanoi +hanover +hansard +hansom +hapless +happen +happened +happens +happier +happiest +happily +happy +harangue +harare +harass +harassed +harasses +harbour +harbours +hard +hardback +hardcore +harden +hardened +hardener +hardens +harder +hardest +hardhit +hardier +hardiest +hardily +hardline +hardly +hardness +hardship +hardup +hardware +hardwood +hardy +hare +harebell +hared +harem +harems +hares +hark +harked +harken +harkened +harkens +harking +harks +harlot +harlots +harm +harmed +harmer +harmful +harming +harmless +harmonic +harmony +harms +harness +harp +harped +harping +harpist +harpists +harpoon +harpoons +harps +harridan +harried +harrier +harriers +harrow +harrowed +harrows +harry +harrying +harsh +harshen +harshens +harsher +harshest +harshly +hart +harts +harvard +harvest +harvests +hasbeen +hasbeens +hash +hashed +hashes +hashing +hashish +hasnt +hasp +hassle +haste +hasted +hasten +hastened +hastens +hastes +hastier +hastiest +hastily +hasty +hatch +hatched +hatchery +hatches +hatchet +hatchets +hatching +hatchway +hate +hated +hateful +hater +haters +hates +hatful +hating +hatless +hatrack +hatracks +hatred +hatreds +hats +hatted +hatter +hatters +hattrick +haughty +haul +haulage +haulages +hauled +hauler +haulers +haulier +hauliers +hauling +haulms +hauls +haunch +haunches +haunt +haunted +haunting +haunts +hauteur +havana +have +haven +havenots +havens +havent +havering +haves +having +havoc +hawaii +hawaiian +hawk +hawked +hawker +hawkers +hawking +hawkish +hawks +hawser +hawsers +hawthorn +haydn +hayfever +hayfield +hayloft +haystack +haywain +haywire +hazard +hazarded +hazards +haze +hazel +hazelnut +hazier +haziest +hazily +haziness +hazy +head +headache +headband +headed +header +headers +headfast +headgear +headier +headiest +heading +headings +headlamp +headland +headless +headline +headlock +headlong +headman +headmen +headnote +headon +headrest +headroom +heads +headset +headsets +headship +headway +headwind +headword +headwork +heady +heal +healed +healer +healers +healing +heals +health +healths +healthy +heap +heaped +heaping +heaps +hear +hearable +heard +hearer +hearers +hearing +hearings +hearken +hearkens +hears +hearsay +hearse +hearses +heart +hearten +hearth +hearths +hearties +heartily +hearts +hearty +heat +heated +heatedly +heater +heaters +heath +heathen +heathens +heather +heathers +heathery +heaths +heating +heats +heatwave +heave +heaved +heaveho +heaven +heavenly +heavens +heaves +heavier +heavies +heaviest +heavily +heaving +heavings +heavy +hebrew +hebrews +heck +heckle +heckled +heckler +hecklers +heckles +heckling +hectare +hectares +hectic +hector +hedge +hedged +hedgehog +hedgerow +hedges +hedging +hedonism +hedonist +heed +heeded +heedful +heeding +heedless +heeds +heel +heeled +heels +heft +hefted +heftier +hefting +hefty +hegemony +heifer +heifers +height +heighten +heights +heinous +heir +heiress +heirloom +heirs +heist +heists +held +helen +helical +helices +helipad +helium +helix +helixes +hell +hellenic +hellfire +hellish +hello +hells +helm +helmet +helmeted +helmets +helms +helmsman +helots +help +helped +helper +helpers +helpful +helping +helpings +helpless +helpline +helpmate +helps +helsinki +heman +hemen +hemline +hemlines +hemlock +hemmed +hemming +hemp +hems +hence +henchman +henchmen +henge +henna +henpeck +henry +hens +hepatic +heptagon +heptane +herald +heralded +heraldic +heraldry +heralds +herb +herbage +herbal +herbs +herd +herded +herding +herds +herdsman +herdsmen +here +hereby +heredity +herein +hereof +heresies +heresy +heretic +heretics +hereto +hereupon +herewith +heritage +heritors +herm +hermetic +hermit +hermits +hernia +hernias +hero +herod +heroic +heroical +heroics +heroin +heroine +heroines +heroism +heron +heronry +herons +herpes +herring +herrings +hers +herself +hertz +hesitant +hesitate +hewed +hewer +hewing +hewn +hexagon +hexagons +hexagram +hexane +hexed +heyday +heydays +hiatus +hiatuses +hibernal +hibiscus +hiccough +hiccup +hiccups +hickory +hidden +hide +hideaway +hideous +hideout +hideouts +hider +hides +hiding +hidings +hierarch +hieratic +high +highbrow +higher +highest +highish +highjack +highland +highly +highness +highs +hight +highway +highways +hijack +hijacked +hijacker +hijacks +hike +hiked +hiker +hikers +hikes +hiking +hilarity +hill +hilled +hillier +hilliest +hillman +hillock +hillocks +hillocky +hills +hillside +hilltop +hilltops +hilly +hilt +hilts +himself +hind +hinder +hindered +hinderer +hinders +hindmost +hindu +hinduism +hinge +hinged +hinges +hinnies +hinny +hint +hinted +hinting +hints +hipbone +hippie +hippies +hippo +hippy +hips +hipster +hipsters +hire +hired +hireling +hirer +hires +hiring +hirings +hirsute +hispanic +hiss +hissed +hisses +hissing +hissings +historic +history +hitch +hitched +hitcher +hitches +hitching +hither +hitherto +hitler +hits +hittable +hitters +hitting +hive +hived +hives +hiving +hoar +hoard +hoarded +hoarder +hoarders +hoarding +hoards +hoarse +hoarsely +hoarser +hoary +hoax +hoaxed +hoaxer +hoaxers +hoaxes +hoaxing +hobbies +hobbit +hobble +hobbled +hobbles +hobbling +hobby +hobbyist +hobnails +hobo +hobs +hock +hockey +hocks +hocus +hoed +hoeing +hoes +hogg +hogged +hogger +hogging +hoggs +hogs +hogwash +hoist +hoisted +hoisting +hoists +hold +holdable +holdall +holdalls +holder +holders +holding +holdings +holdout +holds +holdup +holdups +hole +holed +holes +holiday +holidays +holier +holies +holiest +holily +holiness +holing +holism +holistic +holland +holler +hollered +hollies +hollow +hollowed +hollowly +hollows +holly +holmes +hologram +holster +holsters +holy +homage +homages +hombre +home +homed +homeland +homeless +homelier +homely +homemade +homes +homesick +homespun +homeward +homework +homicide +homiest +homilies +homily +homing +hominid +hominids +homology +homonym +homonyms +homotopy +homy +hone +honed +hones +honest +honestly +honesty +honey +honeybee +honeydew +honeyed +honing +honk +honking +honks +honorary +honors +honour +honoured +honours +honshu +hood +hooded +hoodlum +hoodlums +hoods +hoodwink +hoof +hoofs +hook +hookah +hooked +hooker +hookers +hooking +hooks +hooky +hooligan +hoop +hooped +hoops +hooray +hoot +hooted +hooter +hooters +hooting +hoots +hoover +hoovered +hooves +hope +hoped +hopeful +hopefuls +hopeless +hopes +hoping +hopped +hopper +hoppers +hopping +hops +horde +hordes +horizon +horizons +hormonal +hormone +hormones +horn +hornbeam +horned +hornet +hornets +hornpipe +horns +horny +horrible +horribly +horrid +horridly +horrific +horrify +horror +horrors +horse +horsebox +horsefly +horseman +horsemen +horses +horsey +horsing +hosanna +hosannas +hose +hosed +hosepipe +hoses +hosier +hosiery +hosing +hospice +hospices +hospital +host +hosta +hostage +hostages +hosted +hostel +hostelry +hostels +hostess +hostile +hosting +hostler +hosts +hotair +hotbed +hotbeds +hotdog +hotdogs +hotel +hotelier +hotels +hotheads +hothouse +hotline +hotly +hotness +hotplate +hotpot +hotrod +hotspot +hotspots +hotter +hottest +hotting +hound +hounded +hounding +hounds +hour +hourly +hours +house +housed +houseful +houses +housing +housings +houston +hove +hovel +hovels +hover +hovered +hoverer +hovering +hovers +howdy +however +howitzer +howl +howled +howler +howlers +howling +howlings +howls +hubbies +hubbub +hubby +hubcap +hubcaps +hubris +hubs +huddle +huddled +huddles +huddling +hues +huff +huffed +huffily +huffing +huffy +huge +hugely +hugeness +hugged +hugging +hugs +huguenot +hulk +hulking +hulks +hull +hulled +hullo +hulls +human +humane +humanely +humaner +humanise +humanism +humanist +humanity +humanly +humanoid +humans +humble +humbled +humbler +humbles +humblest +humbling +humbly +humbug +humbugs +humdrum +humerus +humid +humidity +humify +humility +hummable +hummed +hummer +humming +hummock +hummocks +hummocky +humorist +humorous +humour +humoured +humours +hump +humpback +humped +humping +humps +hums +humus +hunch +hunched +hunches +hunching +hundred +hundreds +hung +hungary +hunger +hungered +hungers +hungrier +hungrily +hungry +hunk +hunkers +hunks +hunt +hunted +hunter +hunters +hunting +hunts +huntsman +huntsmen +hurdle +hurdled +hurdler +hurdlers +hurdles +hurl +hurled +hurling +hurls +hurrah +hurrahs +hurray +hurried +hurries +hurry +hurrying +hurt +hurtful +hurting +hurtle +hurtled +hurtles +hurtling +hurts +husband +husbands +hush +hushed +hushes +hushhush +hushing +husk +husked +huskier +huskies +huskiest +huskily +husks +husky +hussies +hussy +hustings +hustle +hustled +hustler +hustlers +hustles +hustling +hutch +hutches +huts +hyacinth +hyaena +hyaenas +hybrid +hybrids +hydra +hydrant +hydrants +hydrate +hydrated +hydride +hydro +hydrogen +hydrous +hyena +hyenas +hygiene +hygienic +hymen +hymens +hymn +hymnal +hymnbook +hymns +hype +hyphen +hyphened +hyphens +hypnosis +hypnotic +hypoxia +hyssop +hysteria +hysteric +iambic +iambus +iberia +iberian +ibex +ibexes +ibis +ibises +ibsen +icarus +iceage +iceberg +icebergs +icebox +icecap +icecold +icecream +iced +iceland +iceman +icepack +icepick +icepicks +ices +iceskate +icicle +icicles +icier +iciest +icily +iciness +icing +icings +icon +iconic +icons +idaho +idea +ideal +idealise +idealism +idealist +ideality +ideally +ideals +ideas +idem +identify +identity +ideology +ides +idiocies +idiocy +idiolect +idiom +idioms +idiot +idiotic +idiots +idle +idled +idleness +idler +idlers +idles +idlest +idling +idly +idol +idolatry +idolise +idolised +idols +idyll +idyllic +igloo +igloos +iglu +igneous +ignite +ignited +igniter +ignites +igniting +ignition +ignoble +ignobly +ignominy +ignorant +ignore +ignored +ignores +ignoring +iguana +iguanas +ileum +iliad +illegal +illfated +illicit +illinois +illiquid +illness +illogic +ills +illumine +illusion +illusive +illusory +ilmenite +image +imaged +imagery +images +imagine +imagined +imagines +imaging +imago +imam +imams +imbecile +imbedded +imbeds +imbibe +imbibed +imbiber +imbibers +imbibing +imbue +imbued +imitate +imitated +imitates +imitator +immanent +immature +immense +immerse +immersed +immerses +imminent +immobile +immodest +immolate +immoral +immortal +immune +immunise +immunity +immured +impact +impacted +impacts +impair +impaired +impairs +impala +impalas +impale +impaled +impaler +impales +impaling +impart +imparted +imparts +impasse +impeach +impede +impeded +impedes +impeding +impel +impelled +impels +impend +imperial +imperil +imperium +impetus +impi +impiety +impinge +impinged +impinges +impious +impish +impishly +implant +implants +implicit +implied +implies +implode +imploded +implodes +implore +implored +implores +imply +implying +impolite +import +imported +importer +imports +impose +imposed +imposes +imposing +imposter +impostor +impotent +impound +impress +imprint +imprints +imprison +improper +improve +improved +improver +improves +imps +impudent +impugn +impugned +impulse +impulses +impunity +impure +impurity +impute +imputed +imputing +inaction +inactive +inane +inanely +inanity +inaptly +inasmuch +inboard +inborn +inbound +inbred +inbuilt +inca +incant +incas +incased +incense +incensed +incenses +incest +incests +inch +inched +inches +inching +inchoate +incident +incised +incision +incisive +incisor +incisors +incite +incited +inciter +inciters +incites +inciting +incline +inclined +inclines +include +included +includes +income +incomer +incomers +incomes +incoming +increase +incubate +incur +incurred +incurs +indaba +indebted +indecent +indeed +indent +indented +indents +indepth +index +indexed +indexer +indexers +indexes +indexing +india +indian +indiana +indians +indicant +indicate +indices +indict +indicted +indicts +indigo +indirect +indite +indole +indolent +indoor +indoors +indorsed +indorses +indrawn +induce +induced +induces +inducing +induct +inducted +inductor +inducts +indulge +indulged +indulger +indulges +induna +industry +inedible +inept +ineptly +inequity +inert +inertia +inertial +inexact +inexpert +infamous +infamy +infancy +infant +infanta +infante +infantry +infants +infarct +infect +infected +infects +infer +inferior +infernal +inferno +inferred +infers +infest +infested +infests +infidel +infidels +infield +infill +infinite +infinity +infirm +infix +inflame +inflamed +inflames +inflate +inflated +inflates +inflect +inflects +inflict +inflicts +inflow +inflows +influx +influxes +info +inform +informal +informed +informer +informs +infra +infrared +infringe +infuse +infused +infuses +infusing +infusion +ingest +ingested +ingoing +ingot +ingots +ingrate +ingress +ingrown +inhabit +inhabits +inhalant +inhale +inhaled +inhaler +inhalers +inhales +inhaling +inherent +inherit +inherits +inhibit +inhibits +inhouse +inhuman +inhumane +inimical +iniquity +initial +initials +initiate +inject +injected +injector +injects +injoke +injokes +injure +injured +injures +injuries +injuring +injury +inked +inkier +inkiest +inking +inkling +inklings +inkpad +inkpot +inkpots +inks +inkstand +inkwell +inkwells +inky +inlaid +inland +inlaw +inlaws +inlay +inlays +inlet +inlets +inmate +inmates +inmost +innards +innate +innately +inner +innings +innocent +innovate +inns +innuendo +input +inputs +inquest +inquests +inquire +inquired +inquirer +inquires +inquiry +inroad +inroads +inrush +insane +insanely +insanity +inscribe +insect +insects +insecure +insert +inserted +inserts +inset +insets +inshore +inside +insider +insiders +insides +insight +insights +insignia +insipid +insist +insisted +insists +insofar +insole +insolent +insomnia +inspect +inspects +inspire +inspired +inspires +install +installs +instance +instancy +instant +instants +instated +instead +instep +insteps +instil +instills +instils +instinct +instruct +insulant +insular +insulate +insulin +insult +insulted +insulter +insults +insure +insured +insurer +insurers +insures +insuring +intact +intaglio +intake +intakes +integer +integers +integral +intend +intended +intends +intense +intent +intently +intents +inter +interact +intercom +intercut +interest +interim +interims +interior +interlap +intermix +intern +internal +interned +internet +interns +interred +interval +intifada +intimacy +intimate +into +intone +intoned +intones +intoning +intrepid +intrigue +intro +intrude +intruded +intruder +intrudes +intuited +inuit +inuits +inundate +inure +inured +invade +invaded +invader +invaders +invades +invading +invalid +invalids +invasion +invasive +inveigh +inveigle +invent +invented +inventor +invents +inverse +inverses +invert +inverted +inverter +inverts +invest +invested +investor +invests +inviscid +invite +invited +invites +inviting +invoice +invoiced +invoices +invoke +invoked +invoker +invokers +invokes +invoking +involute +involve +involved +involves +inward +inwardly +inwards +iodide +iodine +ionian +ionic +ionise +ionised +ionising +ions +iota +iotas +iran +iranian +iranians +iraq +iraqi +iraqis +irate +ireland +iridium +iris +irises +irish +irishman +irishmen +irked +irking +irks +irksome +iron +ironage +ironed +ironic +ironical +ironies +ironing +ironlady +irons +ironwork +irony +irrigate +irritant +irritate +irrupted +isis +islam +islamic +island +islander +islands +isle +isles +islet +islets +isms +isnt +isobar +isobars +isogram +isolate +isolated +isolates +isolator +isomer +isomeric +isomers +isometry +isomorph +isotonic +isotope +isotopes +isotopic +isotropy +israel +israeli +israelis +issuable +issuance +issue +issued +issuer +issuers +issues +issuing +istanbul +isthmus +italian +italians +italic +italics +italy +itch +itched +itches +itchier +itchiest +itching +itchy +item +itemise +itemised +itemises +items +iterate +iterated +iterates +itll +itself +ivies +ivories +ivory +jabbed +jabber +jabbered +jabbers +jabbing +jabs +jack +jackal +jackals +jackass +jackboot +jackdaw +jackdaws +jacked +jacket +jackets +jacking +jackpot +jackpots +jacks +jacob +jacuzzi +jade +jaded +jadedly +jades +jagged +jaggedly +jaguar +jaguars +jahweh +jail +jailbird +jailed +jailer +jailers +jailing +jails +jakarta +jalopy +jamaica +jamaican +jamb +jamboree +jambs +james +jammed +jamming +jams +jangle +jangled +jangling +jangly +janitor +janitors +january +janus +japan +jape +japes +japonica +jargon +jargons +jarl +jarred +jarring +jars +jasmine +jaundice +jaunt +jaunted +jauntier +jauntily +jaunting +jaunts +jaunty +java +javelin +javelins +jawbone +jawbones +jawed +jawing +jawline +jaws +jays +jaywalk +jazz +jazzed +jazzier +jazziest +jazzy +jealous +jealousy +jeans +jeep +jeeps +jeer +jeered +jeering +jeerings +jeers +jehad +jejune +jejunum +jell +jellied +jellies +jellify +jelly +jemmy +jennets +jeopardy +jerboas +jeremiah +jericho +jerk +jerked +jerkier +jerkiest +jerkily +jerkin +jerking +jerkings +jerkins +jerks +jerky +jersey +jerseys +jest +jested +jester +jesters +jesting +jests +jesuit +jesus +jetplane +jets +jetsam +jetted +jetties +jetting +jettison +jetty +jewel +jewelled +jeweller +jewelry +jewels +jewess +jewish +jews +jewsharp +jezebel +jiffy +jiggle +jiggling +jigs +jigsaw +jigsaws +jihad +jilt +jilted +jilting +jilts +jimmy +jingle +jingled +jingles +jingling +jingo +jingoism +jinked +jinks +jinx +jinxed +jinxes +jitter +jitters +jittery +jiujitsu +jive +jived +jives +jobbing +jobless +jobs +jock +jockey +jockeys +jocular +joey +jogged +jogger +joggers +jogging +jogs +john +join +joined +joiner +joiners +joinery +joining +joins +joint +jointed +jointing +jointly +joints +joist +joists +joke +joked +joker +jokers +jokes +jokey +jokier +jokily +joking +jokingly +jollier +jolliest +jollify +jollily +jollity +jolly +jolt +jolted +jolting +jolts +jonah +jonathan +joseph +joshua +jostle +jostled +jostles +jostling +jots +jotted +jotter +jotting +jottings +joule +joules +journal +journals +journey +journeys +joust +jouster +jousting +jousts +jovial +jovially +jovian +jowl +jowls +joyed +joyful +joyfully +joyless +joyous +joyously +joyride +joyrider +joys +joystick +jubilant +jubilate +jubilee +jubilees +judaic +judaism +judas +judder +juddered +judders +judge +judged +judges +judging +judgment +judicial +judo +jugged +juggle +juggled +juggler +jugglers +juggles +juggling +jugs +jugular +juice +juices +juicier +juiciest +juicy +jukebox +julep +juleps +july +jumble +jumbled +jumbles +jumbo +jump +jumped +jumper +jumpers +jumpier +jumpiest +jumping +jumps +jumpsuit +jumpy +junction +juncture +june +jungle +jungles +junior +juniors +juniper +junk +junker +junket +junkie +junkies +junkmail +junks +junkyard +juno +junta +juntas +jupiter +jurassic +juridic +juries +jurist +juristic +jurists +juror +jurors +jury +juryman +jurymen +jussive +just +justice +justices +justify +justly +justness +jute +juts +jutted +jutting +juvenile +kaftan +kaftans +kaiser +kalahari +kale +kalif +kamikaze +kampala +kampong +kangaroo +kaolin +karakul +karaoke +karate +karma +karst +katydid +kayak +kayaks +kebab +kebabs +kedgeree +keel +keeled +keelhaul +keeling +keels +keen +keener +keenest +keening +keenly +keenness +keep +keeper +keepers +keeping +keeps +keepsake +kegs +kelp +kelpers +kelt +kelts +kelvin +kennedy +kennel +kennels +kent +kentucky +kenya +kenyan +kept +keratin +kerb +kerbs +kerbside +kerchief +kerned +kernel +kernels +kerning +kerosene +kestrel +kestrels +ketch +ketchup +kettle +kettles +keyboard +keyed +keyhole +keyholes +keying +keynote +keynotes +keypad +keypads +keyring +keys +keystone +keyword +keywords +khaki +khalif +khan +khans +khoikhoi +khoisan +kibbutz +kick +kickback +kicked +kicker +kicking +kicks +kidded +kiddie +kidding +kidnap +kidnaps +kidney +kidneys +kids +kiev +kill +killed +killer +killers +killing +killings +killjoy +killjoys +kills +kiln +kilns +kilo +kilobits +kilobyte +kiloton +kilotons +kilovolt +kilowatt +kilt +kilted +kilter +kilts +kimono +kina +kinase +kind +kinder +kindest +kindle +kindled +kindles +kindlier +kindling +kindly +kindness +kindred +kinds +kinetic +kinetics +kinfolk +king +kingdom +kingdoms +kingly +kingpin +kings +kingship +kingsize +kink +kinked +kinks +kinky +kinsfolk +kinshasa +kinship +kinsman +kinsmen +kiosk +kiosks +kipper +kippers +kirk +kismet +kiss +kissed +kisser +kisses +kissing +kitbag +kitbags +kitchen +kitchens +kite +kites +kith +kits +kitsch +kitted +kitten +kittens +kitting +kitty +kiwi +kiwis +klaxon +klaxons +klick +kloof +knack +knacker +knackers +knacks +knapsack +knave +knavery +knaves +knavish +knead +kneaded +kneading +kneads +knee +kneecap +kneecaps +kneed +kneedeep +kneel +kneeled +kneeler +kneeling +kneels +knees +knell +knelt +knesset +knew +knickers +knife +knifed +knifes +knifing +knight +knighted +knightly +knights +knit +knits +knitted +knitter +knitters +knitting +knitwear +knives +knob +knobbly +knobs +knock +knocked +knocker +knockers +knocking +knockout +knocks +knoll +knolls +knot +knots +knotted +knottier +knotting +knotty +know +knowable +knowhow +knowing +known +knows +knuckle +knuckled +knuckles +koala +koalas +kongo +koran +korea +korean +koreans +kosher +kraal +kraals +kraft +kremlin +krill +krypton +kudu +kudus +kungfu +kuwait +kwacha +kwachas +laager +label +labelled +labels +labia +labial +labials +labile +labium +labour +laboured +labourer +labours +labs +laburnum +lace +laced +lacerate +laces +lacework +laches +lacier +lacing +lacings +lack +lacked +lackey +lackeys +lacking +lacks +laconic +lacquer +lacquers +lacrosse +lacs +lactate +lacteal +lactic +lactose +lacuna +lacunae +lacunas +lacy +ladder +laddered +ladders +laddie +laddies +lade +laden +ladies +lading +ladle +ladled +ladles +ladling +lads +lady +ladybird +ladybug +ladylike +ladyship +lager +lagers +laggard +laggards +lagged +lagging +lagoon +lagoons +lagos +lags +lagune +laid +lain +lair +laird +lairds +lairs +laity +lake +lakes +lakeside +lama +lamas +lamb +lambda +lambent +lambing +lambs +lambskin +lame +lamed +lamely +lameness +lament +lamented +lamenter +laments +lamest +lamina +laminar +laminate +lamp +lamplit +lampoon +lampoons +lamppost +lamprey +lampreys +lamps +lance +lanced +lancelot +lancer +lancers +lances +lancet +lancets +lancing +land +landed +lander +landfall +landfill +landform +landing +landings +landlady +landless +landlord +landman +landmark +landmass +landmine +lands +landside +landslip +landward +lane +lanes +language +languid +languish +languor +lank +lankier +lankiest +lanky +lanolin +lantern +lanterns +lanyard +laos +lapdog +lapdogs +lapel +lapels +lapful +lapidary +lapland +lapp +lapped +lapping +laps +lapse +lapsed +lapses +lapsing +laptop +laptops +lapwing +lapwings +larceny +larch +larches +lard +larder +larders +lards +large +largely +larger +largest +largish +largo +lark +larking +larks +larva +larvae +larval +larynx +larynxes +lasagne +lase +laser +lasers +lash +lashed +lashers +lashes +lashing +lashings +lasing +lass +lasses +lassie +lassies +lasso +lassoed +lassoing +last +lasted +lasting +lastly +lasts +latch +latched +latches +latching +late +lately +latency +lateness +latent +later +lateral +laterals +latest +latex +lath +lathe +lather +lathered +lathers +lathes +laths +latices +latin +latino +latitude +latrine +latrines +latter +lattice +latticed +lattices +latvia +latvian +laud +laudable +lauded +lauders +lauding +lauds +laugh +laughed +laugher +laughing +laughs +laughter +launch +launched +launcher +launches +launder +laundry +laureate +laurel +laurels +lava +lavas +lavatory +lavender +lavish +lavished +lavishes +lavishly +lawful +lawfully +lawless +lawmaker +lawman +lawmen +lawn +lawns +laws +lawsuit +lawsuits +lawyer +lawyers +laxative +laxer +laxity +laxness +layabout +layby +laybys +layer +layered +layering +layers +laying +layman +laymen +layoff +layoffs +layout +layouts +lays +lazaret +lazarus +laze +lazed +lazier +laziest +lazily +laziness +lazing +lazuli +lazy +leach +leached +leaches +leaching +lead +leaded +leaden +leader +leaders +leadfree +leading +leads +leaf +leafed +leafier +leafiest +leafing +leafless +leaflet +leaflets +leafy +league +leagues +leak +leakage +leakages +leaked +leakier +leakiest +leaking +leaks +leaky +lean +leaned +leaner +leanest +leaning +leanings +leanness +leans +leant +leap +leaped +leaper +leapfrog +leaping +leaps +leapt +leapyear +learn +learned +learner +learners +learning +learns +learnt +lease +leased +leases +leash +leashed +leashes +leashing +leasing +least +leat +leather +leathers +leathery +leave +leaved +leaven +leavened +leaver +leavers +leaves +leaving +leavings +lebanon +lecher +lechery +lectern +lector +lectors +lecture +lectured +lecturer +lectures +ledge +ledger +ledgers +ledges +leech +leeches +leeching +leeds +leek +leeks +leer +leered +leering +leers +lees +leeward +leeway +left +lefties +leftish +leftist +leftists +leftmost +leftover +lefts +leftward +lefty +legacies +legacy +legal +legalese +legalise +legalism +legality +legally +legate +legatee +legatees +legates +legation +legato +legator +legend +legends +legged +legging +leggings +leggy +leghorn +leghorns +legible +legibly +legion +legions +legless +legman +legroom +legs +legume +legumes +legwork +leipzig +leisure +leisured +lemma +lemmas +lemming +lemmings +lemon +lemonade +lemons +lemur +lemurs +lend +lender +lenders +lending +lends +length +lengthen +lengths +lengthy +leniency +lenient +lenin +lens +lenses +lensing +lent +lentil +lentils +lento +leonardo +leone +leopard +leopards +leotard +leotards +leper +lepers +leprose +leprosy +leprous +lepton +leptons +lesbian +lesbians +lesion +lesions +lesotho +less +lessee +lessees +lessen +lessened +lessens +lesser +lesson +lessons +lessor +lessors +lest +lethal +lethally +lethargy +lets +letter +lettered +letters +letting +lettings +lettish +lettuce +lettuces +leucine +leukemia +level +levelled +leveller +levelly +levels +lever +leverage +levered +levering +levers +levi +levied +levies +levitate +levity +levy +levying +lewd +lewdness +lexeme +lexemes +lexical +lexicon +lexicons +leyden +liable +liaise +liaised +liaises +liaising +liaison +liaisons +liar +liars +libation +libel +libeled +libeler +libelled +libeller +libels +liberal +liberals +liberate +liberia +libero +liberty +libido +library +librate +librated +librates +libretti +libretto +libya +libyan +libyans +lice +licence +licences +license +licensed +licensee +licenses +lichee +lichen +lichened +lichens +lichi +lichis +lick +licked +licking +licks +licorice +lidded +lidless +lido +lids +lied +lieder +lien +liens +lies +lieu +life +lifebelt +lifeboat +lifeless +lifelike +lifeline +lifelong +liferaft +lifesize +lifespan +lifetime +lifework +lift +lifted +lifter +lifters +lifting +liftman +liftmen +liftoff +lifts +ligament +ligand +ligands +ligature +light +lighted +lighten +lightens +lighter +lighters +lightest +lighting +lightly +lights +lignite +likable +like +likeable +liked +likelier +likely +liken +likened +likeness +likening +likens +likes +likewise +liking +likings +lilac +lilacs +lilies +lilliput +lilongwe +lilt +lilting +lily +lima +limb +limber +limbers +limbless +limbo +limbs +lime +limekiln +limerick +limes +limeys +liminal +liming +limit +limited +limiter +limiters +limiting +limits +limo +limousin +limp +limped +limpet +limpets +limpid +limping +limply +limpopo +limps +linage +linchpin +lincoln +linden +line +lineage +lineages +lineally +linear +linearly +lined +linefeed +lineman +linemen +linen +linens +lineout +lineouts +liner +liners +lines +linesman +linesmen +lineup +lineups +linger +lingered +lingerer +lingerie +lingers +lingua +lingual +linguist +liniment +lining +linings +link +linkable +linkage +linkages +linked +linker +linkers +linking +links +linkup +linkups +linnet +linnets +lino +linoleum +linseed +lint +lintel +lintels +liny +lion +lioness +lionise +lionised +lions +lipase +lipid +lipids +lipped +lipread +lips +lipstick +liquefy +liqueur +liqueurs +liquid +liquids +liquify +liquor +liquors +lira +lire +lisbon +lisp +lisped +lisping +lisps +lissom +lissome +list +listed +listen +listened +listener +listens +listeria +listing +listings +listless +lists +litanies +litany +litchi +literacy +literal +literals +literary +literate +literati +lithe +lithely +lithium +litigant +litigate +litmus +litotes +litre +litres +litter +littered +litters +little +littler +littlest +littoral +liturgy +livable +live +liveable +lived +livelier +lively +liven +livened +livening +livens +liver +liveried +liveries +liverish +livers +livery +lives +livewire +livid +lividly +living +livings +lizard +lizards +llama +llamas +load +loadable +loaded +loader +loaders +loading +loadings +loads +loaf +loafed +loafer +loafers +loafing +loafs +loam +loams +loamy +loan +loanable +loaned +loaner +loaning +loans +loanword +loath +loathe +loathed +loathes +loathing +loaves +lobbed +lobbied +lobbies +lobbing +lobby +lobbying +lobbyist +lobe +lobed +lobelia +lobes +lobotomy +lobs +lobster +lobsters +lobular +local +locale +locales +localise +locality +locally +locals +locate +located +locates +locating +location +locative +locator +locators +loch +lochness +lochs +loci +lock +lockable +lockage +locked +locker +lockers +locket +locking +lockjaw +lockout +lockouts +locks +loco +locomote +locus +locust +locusts +lode +lodestar +lodge +lodged +lodger +lodgers +lodges +lodging +lodgings +loess +loft +lofted +loftier +loftiest +loftily +lofts +lofty +logbook +logbooks +logged +logger +loggers +logging +logic +logical +logician +logics +logistic +logjam +logo +logoff +logos +logs +loin +loins +loire +loiter +loitered +loiterer +loiters +loll +lolled +lollies +lolling +lollipop +lolly +london +londoner +lone +lonelier +lonely +loner +loners +lonesome +long +longed +longer +longest +longhand +longing +longings +longish +longlost +longs +look +looked +looker +lookers +looking +lookout +lookouts +looks +loom +loomed +looming +looms +loon +looney +loony +loop +looped +loophole +looping +loops +loopy +loose +loosed +loosely +loosen +loosened +loosens +looser +looses +loosest +loosing +loot +looted +looter +looters +looting +loots +lope +loped +lopes +loping +lopped +lopper +loppers +lopping +lopsided +lord +lording +lordly +lords +lordship +lore +lorelei +lorries +lorry +losable +lose +loser +losers +loses +losing +losings +loss +losses +lost +loth +lotion +lotions +lots +lottery +lotto +lotus +louche +loud +louder +loudest +loudly +loudness +louis +lounge +lounged +lounger +loungers +lounges +lounging +louse +lousiest +lousily +lousy +lout +loutish +louts +louver +louvers +louvre +louvred +louvres +lovable +love +loveable +loved +loveless +lovelier +lovelies +lovelorn +lovely +lover +lovers +loves +lovesick +loving +lovingly +lower +lowered +lowering +lowers +lowest +lowing +lowish +lowkey +lowland +lowlands +lowlier +lowliest +lowly +lowlying +lowness +lows +loyal +loyalist +loyally +loyalty +lozenge +lozenges +luanda +lubber +lubbers +lucid +lucidity +lucidly +lucifer +luck +luckier +luckiest +luckily +luckless +lucky +lucre +ludo +luggage +lugged +lugging +lugs +luke +lukewarm +lull +lullaby +lulled +lulling +lulls +lulu +lumbago +lumbar +lumber +lumbered +lumbers +lumen +luminal +luminary +luminous +lump +lumped +lumpen +lumpier +lumpiest +lumping +lumpish +lumps +lumpy +luna +lunacies +lunacy +lunar +lunate +lunatic +lunatics +lunch +lunched +luncheon +lunchers +lunches +lunching +lune +lung +lunge +lunged +lunges +lungfish +lungful +lungfuls +lunging +lungs +lupin +lupines +lupins +lurch +lurched +lurchers +lurches +lurching +lure +lured +lures +lurex +lurid +luridly +luring +lurk +lurked +lurker +lurkers +lurking +lurks +lusaka +luscious +lush +lusher +lushest +lushness +lust +lusted +lustful +lustier +lustiest +lustily +lusting +lustre +lustrous +lusts +lusty +lute +lutes +luther +luxor +luxuries +luxury +lychee +lychees +lying +lymph +lymphoid +lymphoma +lynch +lynched +lynches +lynching +lynchpin +lynx +lynxes +lyon +lyons +lyra +lyre +lyres +lyric +lyrical +lyricism +lyricist +lyrics +lyrist +lysine +macabre +macaque +macaques +macaroni +macaroon +macaw +macaws +mace +maces +machete +machetes +machine +machined +machines +machismo +macho +mackerel +macro +macron +madam +madame +madams +madcap +madden +maddened +maddens +madder +maddest +made +madeira +madhouse +madly +madman +madmen +madness +madras +madrid +madrigal +madwoman +maestro +mafia +mafiosi +magazine +magenta +maggot +maggots +magi +magic +magical +magician +magics +magma +magmas +magmatic +magnate +magnates +magnesia +magnet +magnetic +magneto +magnets +magnify +magnolia +magnum +magnums +magpie +magpies +mags +mahatma +mahogany +maid +maiden +maidenly +maidens +maids +mail +mailable +mailbox +mailed +mailer +mailing +mailings +mailman +mailmen +mails +mailshot +maim +maimed +maiming +maimings +maims +main +maine +mainland +mainline +mainly +mains +mainsail +mainstay +maintain +maize +maizes +majestic +majesty +majolica +major +majority +majors +make +makeover +maker +makers +makes +makeup +making +makings +maladies +malady +malaise +malaria +malarial +malawi +malay +malayan +malays +malaysia +maldives +male +maleness +males +malice +malices +malign +maligned +maligns +mall +mallard +mallards +mallet +mallets +mallow +malls +malt +malta +malted +maltese +malting +maltreat +malts +malty +malva +mama +mamas +mamba +mambas +mammal +mammalia +mammals +mammary +mammoth +mammoths +mammy +manacle +manacled +manacles +manage +managed +manager +managers +manages +managing +manatee +manciple +mandarin +mandate +mandated +mandates +mandela +mandible +mandolin +mandrake +mandril +mandrill +mane +maned +manes +maneuver +manfully +mange +manger +mangers +mangle +mangled +mangler +mangles +mangling +mango +mangrove +manhole +manholes +manhood +manhunt +manhunts +mania +maniac +maniacal +maniacs +manias +manic +manicure +manifest +manifold +manikin +manila +mankind +manliest +manly +manmade +manna +manned +manner +mannered +mannerly +manners +manning +manor +manorial +manors +manpower +manse +mansion +mansions +mansized +mantel +mantids +mantis +mantissa +mantle +mantled +mantles +mantling +mantra +mantrap +mantraps +mantras +manual +manually +manuals +manure +manured +manures +manuring +many +maoism +maoist +maoists +maori +maple +maples +mappable +mapped +mapper +mappers +mapping +mappings +maps +maputo +mara +marathon +marble +marbled +marbles +march +marched +marcher +marchers +marches +marching +mare +mares +margate +margin +marginal +margins +maria +marigold +marina +marinade +marinas +marinate +marine +mariner +mariners +marines +marital +maritime +mark +marked +markedly +marker +markers +market +marketed +marketer +markets +marking +markings +marks +marksman +marksmen +markup +markups +marl +marls +marmoset +marmot +marmots +maroon +marooned +maroons +marque +marquee +marquees +marques +marquess +marquis +marred +marriage +married +marries +marring +marrow +marrows +marry +marrying +mars +marsala +marsh +marshal +marshals +marshes +marshgas +marshier +marshy +mart +marten +martens +martial +martian +martians +martin +martinet +martini +martins +martyr +martyred +martyrs +martyry +marvel +marvels +marx +marxism +marxist +marxists +mary +marzipan +mascara +mascot +mascots +maser +maseru +mash +mashed +masher +mashing +mask +masked +masking +masks +mason +masonic +masonry +masons +masque +masques +mass +massacre +massage +massaged +massager +massages +massed +masses +masseur +masseurs +masseuse +massif +massing +massive +massless +mast +masted +master +mastered +masterly +masters +mastery +masthead +mastiff +mastitis +mastodon +mastoid +mastoids +masts +matador +matadors +match +matchbox +matched +matcher +matches +matching +mate +mated +mater +material +maternal +mates +math +maths +matinee +matinees +mating +matings +matins +matrices +matrix +matrixes +matron +matronly +matrons +mats +matt +matte +matted +matter +mattered +matters +matthew +matting +mattress +mature +matured +maturely +maturer +matures +maturing +maturity +maudlin +maul +mauled +mauler +maulers +mauling +mauls +maumau +mauve +maverick +mawkish +maxi +maxim +maxima +maximal +maximise +maxims +maximum +maya +mayas +maybe +mayday +maydays +mayflies +mayfly +mayhap +mayhem +mayor +mayoral +mayoress +mayors +maypole +maze +mazes +mazier +maziest +mazurka +mazy +mbabane +mead +meadow +meadows +meagre +meagrely +meal +mealie +mealies +meals +mealtime +mealy +mean +meander +meanders +meaner +meanest +meanie +meanies +meaning +meanings +meanly +meanness +means +meant +meantime +meany +measles +measly +measure +measured +measures +meat +meataxe +meatball +meatier +meatiest +meatless +meatpie +meats +meaty +mecca +mechanic +medal +medals +meddle +meddled +meddler +meddlers +meddles +meddling +media +medial +medially +median +medians +mediate +mediated +mediates +mediator +medic +medical +medicals +medicate +medicine +medics +medieval +mediocre +meditate +medium +mediums +medlar +medley +medleys +medulla +medusa +meek +meeker +meekest +meekly +meekness +meet +meeter +meeting +meetings +meets +mega +megabyte +megalith +megastar +megaton +megatons +megavolt +megawatt +meiosis +meiotic +melange +melanin +melanoma +meld +melee +mellow +mellowed +mellower +mellows +melodic +melodies +melody +melon +melons +melt +meltdown +melted +melter +melting +melts +member +members +membrane +memento +memo +memoir +memoirs +memorial +memories +memorise +memory +memphis +menace +menaced +menaces +menacing +menarche +mend +mended +mendel +mender +menders +mending +mends +menfolk +menhir +menhirs +menial +meniscus +menorah +menswear +mental +mentally +menthol +mention +mentions +mentor +mentors +menu +menus +meow +meows +merchant +mercies +merciful +mercuric +mercury +mercy +mere +merely +merest +merge +merged +merger +mergers +merges +merging +meridian +meringue +merino +merit +merited +meriting +merits +mermaid +mermaids +merman +mermen +merrier +merriest +merrily +merry +mesh +meshed +meshes +meshing +mesmeric +meson +mesons +mesozoic +mess +message +messages +messed +messes +messiah +messier +messiest +messily +messing +messy +mestizo +metal +metalled +metallic +metals +metaphor +meted +meteor +meteoric +meteors +meter +metered +metering +meters +methane +methanol +method +methods +methyl +metier +metonymy +metre +metres +metric +metrical +metrics +metro +mettle +mewing +mews +mexican +mexicans +mexico +miami +miasma +mica +mice +micelles +michigan +micro +microbe +microbes +microbic +microdot +micron +microns +midair +midas +midday +middays +midden +middle +middles +middling +midfield +midge +midges +midget +midgets +midi +midland +midlands +midlife +midline +midmost +midnight +midribs +midriff +midship +midships +midst +midway +midweek +midwife +midwives +mien +might +mightier +mightily +mights +mighty +migraine +migrant +migrants +migrate +migrated +migrates +mike +mikes +milady +milan +mild +milder +mildest +mildew +mildewed +mildews +mildewy +mildly +mildness +mile +mileage +mileages +milepost +miler +miles +milieu +milieus +milieux +militant +military +militate +militia +militias +milk +milked +milker +milkers +milkier +milkiest +milking +milkmaid +milkman +milkmen +milks +milky +milkyway +mill +milled +miller +millers +millet +milliner +milling +million +millions +millpond +mills +milord +milt +mime +mimed +mimes +mimetic +mimic +mimicked +mimicker +mimicry +mimics +miming +mimosa +minaret +minarets +mince +minced +mincer +mincers +minces +mincing +mind +minded +minder +minders +mindful +minding +mindless +minds +mindset +mine +mined +miner +mineral +minerals +miners +mines +mingle +mingled +mingles +mingling +mini +minibar +minibus +minicab +minify +minim +minima +minimal +minimise +minimum +mining +minings +minion +minions +minister +ministry +mink +minke +minks +minnow +minnows +minor +minority +minors +minster +minstrel +mint +minted +mintier +mintiest +minting +mints +minty +minuet +minuets +minus +minuses +minute +minuted +minutely +minutes +minutest +minutiae +minx +minxes +miosis +miracle +miracles +mirage +mirages +mire +mired +mires +mirror +mirrored +mirrors +mirth +mirthful +misapply +miscarry +miscast +mischief +miscible +miscount +miscue +miscues +misdate +misdeal +misdeed +misdeeds +misdoing +miser +miseries +miserly +misers +misery +misfield +misfiled +misfire +misfired +misfires +misfit +misfits +misgive +misguide +mishap +mishaps +mishear +misheard +mishears +misjudge +mislaid +mislay +mislead +misleads +misled +mismatch +misname +misnamed +misnomer +misogyny +misplace +misprint +misquote +misread +misrule +miss +missal +missals +missed +misses +missile +missiles +missing +mission +missions +missive +missives +missouri +misspell +misspelt +misspend +misspent +missteps +missus +missuses +missy +mist +mistake +mistaken +mistakes +misted +mister +misters +mistier +mistiest +mistily +mistime +mistimed +misting +mistook +mistreat +mistress +mistrust +mists +misty +mistype +mistyped +mistypes +misuse +misused +misuser +misuses +misusing +mite +mites +mitigate +mitosis +mitre +mitred +mitres +mitt +mitten +mittens +mitts +mixable +mixed +mixer +mixers +mixes +mixing +mixture +mixtures +mixup +mixups +mnemonic +moan +moaned +moaner +moaners +moaning +moans +moas +moat +moated +moats +mobbed +mobbing +mobbish +mobile +mobiles +mobilise +mobility +mobs +mobster +mobsters +moccasin +mock +mocked +mocker +mockers +mockery +mocking +mocks +mockup +mockups +modal +modality +mode +model +modelled +modeller +models +modem +modems +moderate +modern +moderner +modes +modest +modestly +modesty +modicum +modified +modifier +modifies +modify +modish +modishly +modular +modulate +module +modules +moduli +modulus +mogul +moguls +mohair +mohairs +moiety +moist +moisten +moistens +moister +moisture +molar +molarity +molars +molasses +mold +molds +moldy +mole +molecule +molehill +moles +moleskin +molest +molested +molester +molests +mollify +mollusc +molluscs +molten +molts +moment +moments +momentum +moms +monaco +monadic +monalisa +monarch +monarchs +monarchy +monastic +monaural +monday +mondays +monetary +money +moneyed +moneys +monger +mongers +mongol +mongols +mongoose +mongrel +mongrels +monies +monition +monitor +monitors +monk +monkey +monkeyed +monkeys +monkfish +monkish +monks +mono +monocle +monocled +monogamy +monogram +monolith +monomer +monomers +monomial +monopole +monopoly +monorail +monotone +monotony +monoxide +monroe +monsieur +monsoon +monsoons +monster +monsters +montage +montages +month +monthly +months +montreal +monument +mood +moodiest +moodily +moods +moody +mooed +mooing +moon +moonbeam +mooning +moonless +moonlit +moonrise +moons +moonshot +moor +moored +moorhen +moorhens +mooring +moorings +moorland +moors +moos +moose +moot +mooted +mope +moped +mopeds +mopes +moping +mopped +mopping +mops +moraine +moraines +moral +morale +morales +moralise +moralism +moralist +morality +morally +morals +morass +morasses +moray +morays +morbid +morbidly +mordant +more +moreover +mores +morgue +moribund +mormon +mormons +morn +morning +mornings +morns +moroccan +morocco +moron +moronic +morons +morose +morosely +morph +morpheme +morpheus +morphia +morphine +morphism +morrow +morse +morsel +morsels +mort +mortal +mortally +mortals +mortar +mortars +mortgage +mortice +mortices +mortify +mortise +mortises +mortuary +mosaic +mosaics +moscow +moses +mosque +mosques +mosquito +moss +mosses +mossier +mossiest +mossy +most +mostly +motel +motels +motes +motet +motets +moth +mothball +mother +mothered +motherly +mothers +moths +motif +motifs +motile +motility +motion +motional +motioned +motions +motivate +motive +motives +motley +motlier +motliest +motor +motorcar +motored +motoring +motorist +motors +motorway +mottled +motto +mould +moulded +moulder +moulders +mouldier +moulding +moulds +mouldy +moult +moulted +moulting +moults +mound +mounded +mounds +mount +mountain +mounted +mountie +mounties +mounting +mounts +mourn +mourned +mourner +mourners +mournful +mourning +mourns +mouse +mousey +moussaka +mousse +mousses +mousy +mouth +mouthed +mouthful +mouthing +mouths +movable +move +moveable +moved +movement +mover +movers +moves +movie +movies +moving +movingly +mowed +mower +mowers +mowing +mown +mows +mozart +much +muchness +muck +mucked +mucking +mucks +mucky +mucosa +mucous +mucus +muddied +muddier +muddies +muddiest +muddle +muddled +muddles +muddling +muddy +muddying +mudflats +mudflow +mudflows +mudguard +mudlarks +muds +muesli +muff +muffed +muffin +muffins +muffle +muffled +muffler +mufflers +muffling +muffs +mufti +mugged +mugger +muggers +muggier +mugging +muggings +muggy +mugs +mugshots +mulberry +mulch +mulches +mulching +mule +mules +mull +mullah +mullahs +mulled +mullet +mulling +mullions +multiple +multiply +mumble +mumbled +mumbler +mumbles +mumbling +mummies +mummify +mummy +mumps +mums +munch +munched +muncher +munchers +munches +munching +mundane +munich +munition +muons +mural +murals +murder +murdered +murderer +murders +murk +murkier +murkiest +murky +murmur +murmured +murmurer +murmurs +murray +muscadel +muscat +muscle +muscled +muscles +muscling +muscular +muse +mused +muses +museum +museums +mush +mushes +mushroom +mushy +music +musical +musicals +musician +musing +musingly +musings +musk +musket +muskets +muskier +muskiest +musks +musky +muslim +muslims +muslin +mussel +mussels +must +mustache +mustang +mustangs +mustard +muster +mustered +musters +mustier +mustiest +mustily +musts +musty +mutable +mutagens +mutant +mutants +mutate +mutated +mutates +mutating +mutation +mute +muted +mutely +muteness +mutes +mutilate +mutineer +muting +mutinied +mutinies +mutinous +mutiny +mutt +mutter +muttered +mutterer +mutters +mutton +muttons +mutts +mutual +mutually +muzak +muzzle +muzzled +muzzles +muzzling +myalgic +myelin +myna +mynahs +myope +myopia +myopic +myriad +myriads +myrrh +myself +mystery +mystic +mystical +mystics +mystify +mystique +myth +mythic +mythical +myths +nabbed +nabs +nadir +nagasaki +nagged +nagger +nagging +nags +naiad +naiads +nail +nailed +nailing +nails +nairobi +naive +naively +naivete +naivety +naked +nakedly +name +nameable +named +nameless +namely +names +namesake +namibia +namibian +naming +namings +nannies +nanny +naomi +napalm +nape +naphtha +napkin +napkins +naples +napoleon +napped +nappies +napping +nappy +naps +narcosis +narcotic +narrate +narrated +narrates +narrator +narrow +narrowed +narrower +narrowly +narrows +narwhal +nasal +nasally +nascent +nastier +nastiest +nastily +nasty +natal +nation +national +nations +native +natives +nativity +nato +natural +nature +natures +naturist +naught +naughts +naughty +nausea +nauseate +nauseous +nautical +nautili +nautilus +naval +nave +navel +navels +navies +navigate +navvies +navvy +navy +nazi +naziism +nazis +nazism +ndebele +near +nearby +neared +nearer +nearest +nearing +nearly +nearness +nears +nearside +neat +neaten +neatens +neater +neatest +neatly +neatness +nebula +nebulae +nebular +nebulas +nebulous +neck +neckband +necked +necking +necklace +neckline +necks +necktie +necropsy +necrosis +necrotic +nectar +nectars +need +needed +needful +needier +neediest +needing +needle +needled +needles +needless +needling +needs +needy +negate +negated +negates +negating +negation +negative +negev +neglect +neglects +negligee +negroid +neigh +neighed +neighing +neither +nematode +nemesis +neon +neonatal +neonate +neonates +neophyte +neoplasm +neoprene +nepal +nephew +nephews +nepotism +neptune +nerd +nerds +nerve +nerves +nervous +nervy +nest +nestable +nested +nestegg +nesting +nestle +nestled +nestles +nestling +nests +netball +nether +nets +nett +netted +netting +nettle +nettled +nettles +netts +network +networks +neural +neuron +neuronal +neurone +neurones +neurons +neuroses +neurosis +neurotic +neuter +neutered +neuters +neutral +neutrals +neutrino +neutron +neutrons +never +newborn +newcomer +newer +newest +newfound +newish +newlook +newly +newlywed +newness +news +newsboy +newscast +newsman +newsmen +newsreel +newsroom +newsy +newt +newton +newts +next +ngoing +nguni +ngunis +niagara +nibble +nibbled +nibbler +nibblers +nibbles +nibbling +nibs +nice +nicely +niceness +nicer +nicest +niceties +nicety +niche +niches +nick +nicked +nickel +nicking +nickname +nicks +nicotine +niece +nieces +niftily +nifty +niger +nigeria +niggle +niggled +niggles +niggling +nigh +night +nightcap +nightie +nighties +nightly +nights +nihilism +nihilist +nile +nils +nimble +nimbly +nimbus +nine +ninefold +nines +nineteen +nineties +ninety +nineveh +ninny +ninth +ninths +nipped +nipper +nipping +nipple +nipples +nippon +nips +nirvana +nitrate +nitrates +nitric +nitrogen +nitrous +nits +nitwit +nixon +noah +nobility +noble +nobleman +noblemen +nobler +nobles +noblest +nobly +nobodies +nobody +noctuids +nocturne +nodal +nodded +nodding +noddle +noddy +node +nodes +nods +nodular +nodule +noduled +nodules +noel +noggin +nogging +nohow +noise +noises +noisier +noisiest +noisily +noisome +noisy +nomad +nomadic +nomads +nominal +nominate +nominee +nominees +none +nonevent +nonsense +noodle +noodles +nook +nooks +noon +noonday +noons +noontide +noose +noosed +nooses +nordic +norm +normal +normalcy +normally +normals +norman +normandy +normans +normed +norms +norsemen +north +northern +northmen +norway +nose +nosed +nosedive +noses +nosey +nosier +nosiest +nosily +nosiness +nosing +nostril +nostrils +nostrum +nosy +notable +notables +notably +notaries +notary +notation +notch +notched +notches +notching +note +notebook +noted +notepad +notepads +notes +nothing +nothings +notice +noticed +notices +noticing +notified +notifies +notify +noting +notion +notional +notions +nougat +nougats +nought +noughts +noun +nounal +nouns +nourish +novel +novelist +novelle +novels +novelty +november +novice +novices +nowadays +nowhere +noxious +nozzle +nozzles +nuance +nuances +nuclear +nuclei +nucleic +nucleus +nude +nudeness +nudes +nudge +nudged +nudges +nudging +nudism +nudist +nudists +nudities +nudity +nugget +nuggets +nuisance +nuke +null +nullify +nullity +nulls +numb +numbed +number +numbered +numbers +numbing +numbly +numbness +numbs +numeracy +numeral +numerals +numerate +numeric +numerous +numskull +nunnery +nuns +nuptial +nuptials +nurse +nursed +nursery +nurses +nursing +nurture +nurtured +nurtures +nutation +nutmeg +nutmegs +nutrient +nuts +nutshell +nuttier +nutty +nuzzle +nuzzled +nuzzles +nuzzling +nyala +nylon +nylons +nymph +nymphs +oafish +oafs +oaken +oaks +oakum +oars +oarsman +oarsmen +oases +oasis +oast +oatcakes +oath +oaths +oatmeal +oats +obduracy +obdurate +obedient +obelisk +obelisks +obese +obesity +obey +obeyed +obeying +obeys +obituary +object +objected +objector +objects +oblate +obligate +oblige +obliged +obliges +obliging +oblique +obliqued +oblivion +oblong +oblongs +obloquy +oboe +oboes +oboist +obscene +obscure +obscured +obscurer +obscures +observe +observed +observer +observes +obsess +obsessed +obsesses +obsidian +obsolete +obstacle +obstruct +obtain +obtained +obtains +obtrude +obtruded +obtuse +obtusely +obverse +obviate +obviated +obviates +obvious +occasion +occident +occluded +occludes +occult +occults +occupant +occupied +occupier +occupies +occupy +occur +occurred +occurs +ocean +oceanic +oceans +ocelot +ocelots +ochre +ochres +octagon +octagons +octal +octane +octanes +octant +octave +octaves +octavo +octet +octets +october +octopus +ocular +oculist +odder +oddest +oddities +oddity +oddjob +oddly +oddment +oddments +oddness +odds +odes +odin +odious +odiously +odium +odiums +odometer +odorous +odour +odours +odyssey +oedema +oedipus +oestrus +oeuvre +oeuvres +offal +offbeat +offcut +offcuts +offence +offences +offend +offended +offender +offends +offer +offered +offering +offers +offhand +office +officer +officers +offices +official +offprint +offset +offshoot +offshore +often +ogle +ogled +ogling +ogre +ogres +ogrish +ohio +ohmic +ohms +oilcloth +oiled +oiler +oilers +oilfield +oilier +oiliest +oiliness +oiling +oilman +oilmen +oilrig +oils +oily +oink +oinked +oinks +ointment +okapi +okapis +okay +okayed +okays +oklahoma +oldage +olden +older +oldest +oldie +oldish +oldmaids +oldtimer +oleander +olive +oliveoil +oliver +olives +olms +olympia +olympiad +olympian +olympic +olympics +olympus +omega +omelette +omen +omens +ominous +omission +omit +omits +omitted +omitting +omnibus +omnivore +onager +onagers +once +oneness +oner +onerous +ones +oneself +onesided +ongoing +onion +onions +onlooker +only +onset +onshore +ontario +onto +ontogeny +ontology +onus +onuses +onward +onwards +onyx +onyxes +oocytes +oodles +oolitic +oology +oompah +oops +ooze +oozed +oozes +oozing +oozy +opacity +opal +opals +opaque +open +opened +opener +openers +opening +openings +openly +openness +opens +opera +operable +operand +operands +operas +operate +operated +operates +operatic +operator +operetta +opiate +opiates +opine +opined +opines +opining +opinion +opinions +opioid +opioids +opium +opossum +opponent +oppose +opposed +opposes +opposing +opposite +oppress +opted +optic +optical +optician +optics +optima +optimal +optimise +optimism +optimist +optimum +opting +option +optional +options +opts +opulence +opulent +opus +opuses +oracle +oracles +oracular +oral +orally +orang +orange +oranges +orangs +orate +orated +orates +orating +oration +orations +orator +oratorio +orators +oratory +orbit +orbital +orbitals +orbited +orbiter +orbiting +orbits +orbs +orca +orchard +orchards +orchid +orchids +ordain +ordained +ordains +ordeal +ordeals +order +ordered +ordering +orderly +orders +ordinal +ordinals +ordinary +ordinate +ordnance +ordure +ores +organ +organic +organics +organise +organism +organist +organs +organza +orgies +orgy +orient +oriental +oriented +orifice +orifices +origami +origin +original +origins +ornament +ornate +ornately +orphan +orphaned +orphans +orpheus +orthodox +oryxes +oscar +oscars +osiris +oslo +osmium +osmosis +osmotic +osprey +ospreys +ossified +ostler +ostlers +ostrich +other +others +otter +otters +ottoman +ouch +ought +ounce +ounces +ours +oust +ousted +ouster +ousting +ousts +outage +outages +outback +outbid +outbids +outboard +outbound +outbreak +outbred +outburst +outcall +outcast +outcasts +outcome +outcomes +outcries +outcrop +outcrops +outcry +outdated +outdid +outdo +outdoes +outdoing +outdone +outdoor +outdoors +outer +outface +outfall +outfalls +outfield +outfit +outfits +outflank +outflow +outflows +outfox +outfoxed +outfoxes +outgo +outgoing +outgrew +outgrow +outgrown +outguess +outhouse +outing +outings +outlast +outlasts +outlaw +outlawed +outlawry +outlaws +outlay +outlays +outlet +outlets +outlier +outliers +outline +outlined +outlines +outlive +outlived +outlives +outlook +outlooks +outlying +outmoded +outmost +outpace +outpaced +outplay +outpost +outposts +output +outputs +outrage +outraged +outrages +outran +outrank +outreach +outride +outrider +outright +outrun +outruns +outs +outsell +outset +outsets +outshine +outshone +outside +outsider +outsides +outsize +outsmart +outsold +outspan +outstay +outstep +outstrip +outvoted +outward +outwards +outweigh +outwit +outwith +outwits +outwork +oval +ovals +ovarian +ovaries +ovary +ovate +ovation +ovations +oven +ovens +over +overact +overacts +overall +overalls +overate +overcame +overcast +overcoat +overcome +overcook +overdid +overdo +overdoes +overdone +overdose +overdraw +overdue +overeat +overeats +overfed +overfeed +overfill +overflow +overfly +overfull +overhand +overhang +overhaul +overhead +overhear +overheat +overhung +overkill +overlaid +overlain +overland +overlap +overlaps +overlay +overlays +overleaf +overlie +overlies +overload +overlong +overlook +overlord +overly +overmuch +overpaid +overpass +overpay +overplay +overran +overrate +override +overripe +overrode +overrule +overrun +overruns +overs +oversaw +overseas +oversee +overseen +overseer +oversees +overshot +oversize +overstep +overt +overtake +overtax +overtime +overtly +overtone +overtook +overtops +overture +overturn +overuse +overused +overuses +overview +overwork +oviduct +ovoid +ovular +ovum +owed +owes +owing +owlet +owlets +owlish +owlishly +owls +owned +owner +owners +owning +owns +oxalate +oxalic +oxcart +oxen +oxford +oxidant +oxidants +oxide +oxides +oxidise +oxidised +oxidiser +oxtail +oxtails +oxygen +oxymoron +oyster +oysters +ozone +pace +paced +paceman +pacemen +pacer +pacers +paces +pacey +pacific +pacified +pacifier +pacifies +pacifism +pacifist +pacify +pacing +pack +packable +package +packaged +packages +packed +packer +packers +packet +packets +packing +packings +packs +pact +pacts +padded +padding +paddings +paddle +paddled +paddler +paddlers +paddles +paddling +paddock +paddocks +paddy +padlock +padlocks +padre +padres +pads +paean +paeans +paella +paeony +pagan +paganism +pagans +page +pageant +pageants +pageboy +paged +pageful +pager +pagers +pages +paginal +paginate +paging +pagoda +pagodas +paid +paidup +pail +pails +pain +pained +painful +paining +painless +pains +paint +paintbox +painted +painter +painters +painting +paints +pair +paired +pairing +pairings +pairs +pairwise +pajama +pajamas +pakistan +palace +palaces +palatal +palate +palates +palatial +palatine +palaver +pale +paled +paleface +palely +paleness +paler +pales +palest +palette +palettes +paling +palisade +pall +palled +pallet +pallets +pallid +pallmall +pallor +palls +palm +palmed +palming +palmist +palms +palmtop +palmtops +palmy +palp +palpable +palpably +palpate +palpated +palpates +pals +palsied +palsy +paltrier +paltry +paludal +pampas +pamper +pampered +pampers +pamphlet +panacea +panaceas +panache +panama +pancake +pancaked +pancakes +pancreas +panda +pandas +pandemic +pander +panders +pandora +pane +paned +panel +panelled +panels +panes +pang +panga +pangas +pangolin +pangs +panic +panicked +panicky +panics +panned +pannier +panniers +panning +panoply +panorama +pans +pansies +pansy +pant +panted +pantheon +panther +panthers +panties +pantile +pantiled +pantiles +panting +pantries +pantry +pants +panzer +papa +papacy +papal +papas +papaw +papaws +papaya +paper +papered +papering +papers +papery +papilla +papist +pappy +paprika +papua +papule +papyri +papyrus +parable +parables +parabola +parade +paraded +parader +parades +paradigm +parading +paradise +paradox +paraffin +paragon +paragons +paraguay +parakeet +parallax +parallel +paralyse +paramour +paranoia +paranoid +parapet +parapets +paraquat +parasite +parasol +parasols +parboil +parcel +parcels +parch +parched +parches +pardon +pardoned +pardons +pare +pared +parent +parental +parented +parents +pares +parfait +parfaits +pariah +pariahs +parietal +paring +paris +parish +parishes +parisian +parities +parity +park +parka +parkas +parked +parking +parkland +parks +parlance +parley +parlour +parlours +parlous +parodied +parodies +parodist +parody +parole +paroxysm +parquet +parried +parries +parrot +parrots +parry +parrying +parse +parsec +parsecs +parsed +parser +parsers +parses +parsing +parsings +parsley +parsnip +parsnips +parson +parsons +part +partake +partaken +partaker +partakes +parted +partial +particle +parties +parting +partings +partisan +partly +partner +partners +partook +parts +parttime +party +parvenu +pascal +pascals +paschal +pass +passable +passably +passage +passages +passant +passe +passed +passer +passers +passes +passim +passing +passion +passions +passive +passives +passmark +passover +passport +password +past +pasta +pastas +paste +pasted +pastel +pastels +pastes +pasteur +pastiche +pasties +pastille +pastime +pastimes +pasting +pastis +pastor +pastoral +pastors +pastrami +pastries +pastry +pasts +pasture +pastured +pastures +pasty +patch +patched +patches +patchier +patchily +patching +patchup +patchy +pate +patella +paten +patent +patented +patentee +patently +patents +pater +paternal +pates +path +pathetic +pathless +pathogen +pathos +paths +pathway +pathways +patience +patient +patients +patina +patio +patois +patriot +patriots +patrol +patrols +patron +patrons +pats +patted +patten +pattens +patter +pattered +pattern +patterns +patters +patties +patting +paucity +paul +paunch +paunchy +pauper +paupers +pause +paused +pauses +pausing +pave +paved +pavement +paves +pavilion +paving +pavings +pavlov +pawed +pawing +pawn +pawned +pawning +pawns +pawnshop +pawpaw +pawpaws +paws +payable +payback +payday +paydays +payed +payee +payees +payer +payers +paying +payload +payloads +payment +payments +payphone +payroll +payrolls +pays +payslips +peace +peaceful +peach +peaches +peachier +peachy +peacock +peacocks +peafowl +peahens +peak +peaked +peaking +peaks +peaky +peal +pealed +pealing +peals +peanut +peanuts +pear +pearl +pearls +pearly +pears +peas +peasant +peasants +peat +peatland +peaty +pebble +pebbled +pebbles +pebbly +pecan +peccary +peck +pecked +pecker +peckers +pecking +peckish +pecks +pectin +pectoral +peculiar +pedagogy +pedal +pedalled +pedals +pedant +pedantic +pedantry +pedants +peddle +peddled +peddler +peddlers +peddles +peddling +pedestal +pedigree +pediment +pedlar +pedlars +pedology +peek +peeked +peeking +peeks +peel +peeled +peeler +peelers +peeling +peelings +peels +peep +peeped +peeper +peepers +peephole +peeping +peeps +peer +peerage +peerages +peered +peering +peerless +peers +peevish +pegasus +pegged +pegging +pegs +pekan +peking +pele +pelican +pelicans +pellet +pellets +pelmet +pelmets +pelt +pelted +pelting +pelts +pelvic +pelvis +pelvises +penal +penalise +penalty +penance +penances +pence +penchant +pencil +pencils +pendant +pendants +pending +pendulum +penguin +penguins +penile +penitent +penknife +penname +pennames +pennant +pennants +penned +pennies +penning +penny +penology +pens +pension +pensions +pensive +pent +pentagon +penumbra +penury +peonies +people +peopled +peoples +peperoni +pepper +peppered +peppers +peppery +peps +peptic +peptide +peptides +perannum +percales +perceive +percent +percept +percepts +perch +perched +percher +perches +perching +percuss +perfect +perfects +perfidy +perforce +perform +performs +perfume +perfumed +perfumes +perfused +pergola +pergolas +perhaps +peri +perigee +peril +perilous +perils +perineal +perineum +period +periodic +periods +perish +perished +perishes +perjure +perjured +perjurer +perjury +perk +perked +perkier +perkiest +perkily +perking +perks +perky +perm +permeate +permed +perming +permit +permits +perms +permute +permuted +permutes +peroxide +perplex +perron +perry +persia +persian +persist +persists +person +persona +personae +personal +persons +perspex +perspire +persuade +pert +pertain +pertains +perth +pertly +pertness +perturb +peru +perusal +peruse +perused +peruses +perusing +peruvian +pervade +pervaded +pervades +perverse +pervert +perverts +peseta +pesetas +pesky +pest +pester +pestered +pestle +pests +petal +petals +petard +peter +petered +petering +peters +petit +petite +petition +petrel +petrels +petrify +petrol +pets +petted +pettier +pettiest +petting +pettish +petty +petulant +petunia +petunias +pews +pewter +phalanx +phantasy +phantom +phantoms +pharaoh +pharmacy +pharynx +phase +phased +phases +phasing +pheasant +phenol +phenols +phew +phlegm +phlox +phobia +phobias +phobic +phoenix +phone +phoned +phoneme +phonemes +phonemic +phoner +phones +phonetic +phoney +phoneys +phoning +phonon +phony +phooey +phosphor +photo +photon +photons +photos +phrasal +phrase +phrased +phrases +phrasing +phyla +phylum +physic +physical +physics +physio +physique +pianist +pianists +piano +pianola +piazza +piazzas +pica +picasso +piccolo +pick +pickaxe +pickaxes +picked +picker +pickerel +pickers +picket +picketed +pickets +picking +pickings +pickle +pickled +pickles +pickling +picks +pickup +pickups +picnic +picnics +pictural +picture +pictured +pictures +pidgin +piebald +piece +pieced +pieces +piecing +pied +pier +pierce +pierced +piercer +piercers +pierces +piercing +piers +pies +pieta +piety +piffle +pigeon +pigeons +piggery +piggish +piggy +piglet +piglets +pigment +pigments +pigs +pigsties +pigsty +pigtail +pigtails +pike +pikemen +pikes +pilaster +pilchard +pile +piled +piles +pileup +pilfer +pilfered +pilgrim +pilgrims +piling +pill +pillage +pillaged +pillages +pillar +pillared +pillars +pillbox +pillion +pillory +pillow +pillowed +pillows +pills +pilot +piloted +piloting +pilots +pimp +pimping +pimple +pimpled +pimples +pimply +pimps +pinafore +pinball +pincer +pincered +pincers +pinch +pinched +pincher +pinches +pinching +pine +pineal +pined +pines +ping +pingpong +pings +pinhead +pinheads +pinhole +pinholes +pining +pinion +pinioned +pinions +pink +pinked +pinker +pinkie +pinkies +pinking +pinkish +pinkness +pinks +pinky +pinnacle +pinned +pinning +pinpoint +pinprick +pins +pint +pints +pinup +pinups +piny +pion +pioneer +pioneers +pions +pious +piously +pipe +piped +pipeline +piper +pipers +pipes +pipette +pipettes +pipework +piping +pipings +pipit +pipits +pipped +pippin +pipping +pips +piquancy +piquant +pique +piqued +piracies +piracy +piranha +piranhas +pirate +pirated +pirates +pirating +pisa +pistol +pistols +piston +pistons +pitbull +pitch +pitched +pitcher +pitchers +pitches +pitching +piteous +pitfall +pitfalls +pith +pithead +pithier +pithiest +pithily +piths +pithy +pitiable +pitiably +pitied +pities +pitiful +pitiless +piton +pitons +pits +pittance +pitted +pitting +pity +pitying +pivot +pivotal +pivoted +pivoting +pivots +pixel +pixels +pixie +pixies +pizazz +pizza +pizzas +pizzeria +placard +placards +placate +placated +placates +place +placebo +placed +placemen +placenta +placer +placers +places +placid +placidly +placing +placings +plague +plagued +plagues +plaguing +plaice +plaid +plaids +plain +plainest +plainly +plains +plaint +plait +plaited +plaiting +plaits +plan +planar +plane +planed +planes +planet +planets +plangent +planing +plank +planking +planks +plankton +planned +planner +planners +planning +plans +plant +plantain +planted +planter +planters +planting +plants +plaque +plaques +plasm +plasma +plasmas +plasmid +plasmids +plaster +plasters +plastic +plastics +plate +plateau +plateaus +plateaux +plated +plateful +platelet +platen +platens +plates +platform +plating +platinum +plato +platonic +platoon +platoons +platter +platters +platypus +plaudits +play +playable +playback +playboy +playboys +played +player +players +playful +playing +playings +playmate +playroom +plays +playtime +plaza +plazas +plea +plead +pleaded +pleading +pleads +pleas +pleasant +please +pleased +pleases +pleasing +pleasure +pleat +pleated +pleats +pleb +plebeian +plebs +plectrum +pledge +pledged +pledges +pledging +plenary +plenty +plenum +plethora +pleura +pleural +pleurisy +plexus +pliable +pliant +plied +pliers +plies +plight +plights +plinth +plinths +plod +plodded +plodder +plodding +plods +plop +plopped +plopping +plops +plosive +plot +plots +plotted +plotter +plotters +plotting +plough +ploughed +ploughs +plover +plovers +ploy +ploys +pluck +plucked +plucker +pluckier +plucking +plucks +plucky +plug +plugged +plugging +plughole +plugs +plum +plumage +plumages +plumb +plumbago +plumbed +plumber +plumbers +plumbing +plumbs +plume +plumed +plumes +pluming +plummet +plummets +plummy +plump +plumped +plumper +plumping +plums +plumtree +plumy +plunder +plunders +plunge +plunged +plunger +plungers +plunges +plunging +plural +plurals +plus +pluses +plush +plushy +pluto +plutonic +plying +plywood +poach +poached +poacher +poachers +poaches +poaching +pock +pocked +pocket +pocketed +pockets +pocks +podded +podgy +podia +podium +podiums +pods +poem +poems +poet +poetess +poetic +poetical +poetics +poetise +poetry +poets +pogo +pogrom +pogroms +poignant +point +pointed +pointer +pointers +pointing +points +pointy +poise +poised +poises +poising +poison +poisoned +poisoner +poisons +poke +poked +poker +pokers +pokes +poking +poky +poland +polar +polarise +polarity +polder +pole +polecat +polecats +poled +polemic +polemics +poles +polestar +poleward +police +policed +polices +policies +policing +policy +polio +polish +polished +polisher +polishes +polite +politely +politer +politest +politic +politics +polity +polka +polkas +poll +polled +pollen +pollens +polling +polls +pollster +pollute +polluted +polluter +pollutes +polo +poloneck +polonies +polonium +polony +poltroon +polygamy +polyglot +polygon +polygons +polygyny +polymath +polymer +polymers +polyp +polyps +pomade +pomades +pomelo +pomp +pompeii +pompey +pompous +ponce +poncho +pond +ponder +pondered +ponders +ponds +ponies +pontiff +pontiffs +pontoon +pontoons +pony +ponytail +pooch +pooches +poodle +poodles +poof +pooh +pool +pooled +pooling +pools +poolside +poop +poor +poorer +poorest +poorly +poorness +popcorn +pope +popes +popeyed +poplar +poplars +popmusic +popped +popper +poppet +poppies +popping +poppy +pops +populace +popular +populate +populism +populist +populous +popup +porch +porches +porcine +pore +pored +pores +poring +pork +porkchop +porker +porky +porn +porno +porns +porosity +porous +porphyry +porpoise +porridge +port +portable +portage +portal +portals +ported +portend +portends +portent +portents +porter +porters +porthole +portico +porting +portion +portions +portly +portrait +portray +portrays +ports +portugal +pose +posed +poseidon +poser +posers +poses +poseur +poseurs +posh +posies +posing +posit +posited +positing +position +positive +positron +posits +posse +possess +possible +possibly +possum +possums +post +postage +postal +postbag +postbox +postcard +postcode +posted +poster +posters +posting +postings +postlude +postman +postmark +postmen +postpone +posts +postural +posture +postured +postures +posy +potable +potash +potato +potch +potency +potent +potently +pothole +potholes +potion +potions +pots +potshot +potshots +pottage +potted +potter +pottered +potters +pottery +potties +potting +potty +pouch +pouches +pouffe +pouffes +poult +poultice +poultry +pounce +pounced +pounces +pouncing +pound +poundage +pounded +pounding +pounds +pour +pourable +poured +pouring +pours +pout +pouted +pouter +pouting +pouts +poverty +powder +powdered +powders +powdery +power +powered +powerful +powering +powers +practice +practise +prague +prairie +prairies +praise +praised +praises +praising +praline +pram +prams +prance +pranced +prancer +prancing +prang +prank +pranks +prat +prattle +prattled +prattler +prawn +prawns +pray +prayed +prayer +prayers +praying +prays +preach +preached +preacher +preaches +preamble +preamp +prebend +precede +preceded +precedes +precept +precepts +precess +precinct +precious +precis +precise +preclude +predate +predated +predates +predator +predict +predicts +preen +preened +preening +preens +prefab +prefabs +preface +prefaced +prefaces +prefect +prefects +prefer +prefers +prefix +prefixed +prefixes +pregnant +preheat +prejudge +prelate +prelates +prelude +preludes +premier +premiere +premiers +premise +premised +premises +premiss +premium +premiums +premolar +prenatal +prep +prepaid +prepare +prepared +preparer +prepares +prepays +preps +presence +present +presents +preserve +preset +presets +preside +presided +presides +press +pressed +presses +pressing +pressman +pressmen +pressup +pressups +pressure +prestige +presto +presume +presumed +presumes +pretence +pretend +pretends +pretext +pretexts +pretor +pretoria +prettier +prettify +prettily +pretty +prevail +prevails +prevent +prevents +preview +previews +previous +prevue +prevues +prey +preyed +preying +preys +priapic +price +priced +prices +pricewar +pricey +pricier +pricing +prick +pricked +pricking +prickle +prickled +prickles +prickly +pricks +pricy +pride +prided +prides +pried +pries +priest +priestly +priests +prig +priggish +prim +primacy +primal +primary +primate +primates +prime +primed +primer +primers +primes +primeval +priming +primly +primness +primrose +primus +prince +princely +princes +princess +print +printed +printer +printers +printing +printout +prints +prions +prior +priories +priority +priors +priory +prise +prised +prises +prising +prism +prisms +prison +prisoner +prisons +prissy +pristine +privacy +private +privates +privet +privy +prize +prized +prizer +prizes +prizing +probable +probably +probate +probe +probed +prober +probes +probing +probity +problem +problems +proceed +proceeds +process +proclaim +proctor +proctors +procure +procured +procures +prod +prodded +prodding +prodeo +prodigal +prodigy +prods +produce +produced +producer +produces +product +products +profane +profaned +profess +proffer +proffers +profile +profiled +profiles +profit +profited +profits +proforma +profound +profuse +progeny +program +programs +progress +prohibit +project +projects +prolapse +prolific +prolix +prologue +prolong +prolongs +promise +promised +promises +promote +promoted +promoter +promotes +prompt +prompted +prompter +promptly +prompts +prone +prong +prongs +pronoun +pronouns +pronto +proof +proofed +proofing +proofs +prop +propane +propel +propels +proper +properly +property +prophecy +prophesy +prophet +prophets +proposal +propose +proposed +proposer +proposes +propound +propped +propping +props +pros +prosaic +prosaist +prose +prosodic +prosody +prospect +prosper +prospers +prostate +protea +protean +proteas +protease +protect +protects +protege +protegee +proteges +protein +proteins +protest +protests +protists +protocol +proton +protons +protozoa +protract +protrude +proud +prouder +proudest +proudly +provable +provably +prove +proved +proven +provence +proverb +proverbs +proves +provide +provided +provider +provides +province +proving +provoke +provoked +provoker +provokes +provost +prow +prowess +prowl +prowled +prowler +prowlers +prowling +prowls +prows +proxies +proximal +proximo +proxy +prude +prudence +prudent +prudery +prudish +prune +pruned +pruners +prunes +pruning +prunings +prurient +pruritus +prussia +prussian +prussic +prying +pryings +psalm +psalmist +psalmody +psalms +psalter +psalters +psaltery +pseudo +psyche +psychic +psychics +psycho +ptolemy +puberty +pubic +public +publican +publicly +publish +pubs +pudding +puddings +puddle +puddles +puerile +puff +puffed +puffer +puffin +puffing +puffins +puffs +puffy +pugilist +pugs +puissant +puke +puking +puling +pull +pulled +puller +pullets +pulley +pulleys +pulling +pullover +pulls +pulp +pulped +pulping +pulpit +pulpits +pulps +pulpy +pulsar +pulsars +pulsate +pulsated +pulsates +pulse +pulsed +pulses +pulsing +puma +pumas +pumice +pummel +pummels +pump +pumped +pumping +pumpkin +pumpkins +pumps +punch +punched +puncher +punches +punching +punchy +punctate +punctual +puncture +pundit +pundits +pungency +pungent +punier +puniest +punish +punished +punishes +punitive +punk +punks +punky +punned +punnet +punning +puns +punster +punt +punted +punter +punters +punting +punts +puny +pupa +pupae +pupal +pupated +pupates +pupating +pupil +pupils +puppet +puppetry +puppets +puppies +puppy +pups +purblind +purchase +purdah +pure +puree +purees +purely +pureness +purer +purest +purge +purged +purges +purging +purgings +purified +purifier +purifies +purify +purims +purines +purist +purists +puritan +puritans +purities +purity +purl +purlieus +purling +purlins +purloin +purls +purple +purples +purplish +purport +purports +purpose +purposed +purposes +purr +purred +purring +purrs +purse +pursed +purser +purses +pursing +pursuant +pursue +pursued +pursuer +pursuers +pursues +pursuing +pursuit +pursuits +purvey +purveyed +purveyor +purview +push +pushable +pushed +pusher +pushers +pushes +pushier +pushing +pushups +pushy +puss +pussy +pussycat +pustular +pustule +pustules +putative +putput +putrefy +putrid +puts +putsch +putt +putted +putter +putters +putti +putting +putts +putty +puzzle +puzzled +puzzler +puzzles +puzzling +pygmies +pygmy +pyjama +pyjamas +pylon +pylons +pyramid +pyramids +pyre +pyres +pyridine +pyrite +pyrites +pyrolyse +pyroxene +python +pythons +qatar +quack +quacked +quacking +quackish +quacks +quadrant +quaff +quaffed +quaffing +quagga +quaggas +quagmire +quail +quailed +quails +quaint +quainter +quaintly +quake +quaked +quaker +quakers +quakes +quaking +qualify +quality +qualm +qualms +quantify +quantise +quantity +quantum +quark +quarks +quarrel +quarrels +quarried +quarries +quarry +quart +quarter +quarters +quartet +quartets +quartic +quartics +quartile +quarto +quarts +quartz +quasar +quasars +quash +quashed +quashing +quasi +quatrain +quaver +quavered +quavers +quay +quays +quayside +queasy +quebec +queen +queenly +queens +queer +queerest +queerly +quell +quelled +quelling +quells +quench +quenched +quencher +quenches +queried +queries +quern +query +querying +quest +questing +question +quests +queue +queued +queueing +queues +queuing +quibble +quibbles +quiche +quiches +quick +quicken +quickens +quicker +quickest +quickly +quid +quids +quiesce +quiesced +quiet +quieted +quieten +quietens +quieter +quietest +quieting +quietly +quiets +quietus +quiff +quill +quills +quilt +quilted +quilting +quilts +quince +quinces +quinine +quintet +quintets +quintic +quip +quipped +quipper +quips +quire +quirk +quirkier +quirks +quirky +quisling +quit +quite +quits +quitted +quitter +quitting +quiver +quivered +quivers +quixotic +quiz +quizzed +quizzes +quizzing +quoins +quoits +quondam +quorate +quorum +quota +quotable +quotas +quote +quoted +quoter +quotes +quotient +quoting +quovadis +rabat +rabats +rabbi +rabbis +rabbit +rabbits +rabble +rabid +rabidly +rabies +raccoon +raccoons +race +raced +racer +racers +races +rachis +racial +racially +racier +raciest +racily +racing +racings +racism +racist +racists +rack +racked +racket +rackets +racking +racks +racoon +racquet +racquets +racy +radar +radars +radial +radially +radials +radian +radiance +radiancy +radians +radiant +radiate +radiated +radiates +radiator +radical +radicals +radices +radii +radio +radioed +radioing +radios +radish +radishes +radium +radius +radix +radon +raffia +raffle +raffled +raffles +raft +rafter +rafters +rafting +raftman +rafts +raftsman +ragbag +rage +raged +rages +ragged +raggedly +raging +ragout +rags +ragtime +ragwort +raid +raided +raider +raiders +raiding +raids +rail +railed +railes +railing +railings +raillery +railroad +rails +railway +railways +raiment +rain +rainbow +rainbows +raincoat +raindrop +rained +rainfall +rainier +rainiest +raining +rainless +rainout +rains +rainy +raise +raised +raiser +raises +raisin +raising +raisins +rajah +rake +raked +rakes +raking +rakish +rallied +rallies +rally +rallying +ramble +rambled +rambler +ramblers +rambles +rambling +ramified +ramifies +ramify +rammed +rammer +ramming +ramp +rampage +rampaged +rampages +rampant +rampart +ramparts +ramped +ramping +ramps +ramrod +rams +ranch +rancher +ranchers +ranches +ranching +rancid +rancour +rand +random +randomly +rands +randy +rang +range +ranged +ranger +rangers +ranges +ranging +rangy +rani +ranis +rank +ranked +ranker +rankers +rankest +ranking +rankings +rankle +rankled +rankles +rankling +rankness +ranks +ransack +ransom +ransomed +ransoms +rant +ranted +ranter +ranters +ranting +rantings +rants +rapacity +rape +raped +rapes +rapeseed +rapid +rapidity +rapidly +rapids +rapier +rapiers +rapine +raping +rapist +rapists +rapped +rapping +rapport +rapports +raps +rapt +raptor +raptors +rapture +raptures +rare +rarebit +rarefied +rarely +rareness +rarer +rarest +raring +rarities +rarity +rascal +rascally +rascals +rased +rash +rasher +rashers +rashes +rashest +rashly +rashness +rasing +rasp +rasped +rasper +rasping +rasps +raspy +raster +rasters +rate +rated +rater +rates +rather +ratified +ratifier +ratifies +ratify +rating +ratings +ratio +ration +rational +rationed +rations +ratios +ratlike +ratrace +rats +rattier +rattle +rattled +rattler +rattles +rattling +ratty +raucous +ravage +ravaged +ravages +ravaging +rave +raved +ravel +ravelled +ravels +raven +ravening +ravenous +ravens +raver +ravers +raves +ravine +ravines +raving +ravingly +ravings +ravioli +ravish +ravished +ravisher +ravishes +rawest +rawness +rayed +rayon +rays +raze +razed +razes +razing +razor +razoring +razors +reabsorb +reaccept +reach +reached +reaches +reaching +react +reactant +reacted +reacting +reaction +reactive +reactor +reactors +reacts +read +readable +readably +readapt +reader +readers +readied +readier +readies +readiest +readily +reading +readings +readjust +readmit +readmits +reads +ready +readying +reaffirm +reagent +reagents +real +realign +realigns +realise +realised +realises +realism +realist +realists +reality +reallife +really +realm +realms +realness +reals +realty +ream +reams +reap +reaped +reaper +reapers +reaping +reappear +reapply +reaps +rear +reared +rearer +rearing +rearm +rearmed +rearming +rearms +rears +rearview +rearward +reason +reasoned +reasoner +reasons +reassert +reassess +reassign +reassume +reassure +reawaken +rebate +rebates +rebel +rebelled +rebels +rebind +rebirth +rebirths +rebook +reboot +rebooted +reborn +rebound +rebounds +rebuff +rebuffed +rebuffs +rebuild +rebuilds +rebuilt +rebuke +rebuked +rebukes +rebuking +reburial +reburied +rebury +rebus +rebut +rebuttal +rebutted +recall +recalled +recalls +recant +recanted +recants +recap +recapped +recaps +recast +recasts +recede +receded +recedes +receding +receipt +receipts +receive +received +receiver +receives +recency +recent +recently +receptor +recess +recessed +recesses +recharge +recheck +recipe +recipes +recital +recitals +recite +recited +recites +reciting +reckless +reckon +reckoned +reckoner +reckons +reclaim +reclaims +recline +reclined +recliner +reclines +reclothe +recluse +recluses +recode +recoded +recodes +recoding +recoil +recoiled +recoils +recopied +recopy +record +recorded +recorder +records +recount +recounts +recoup +recouped +recouple +recoups +recourse +recover +recovers +recovery +recreate +recruit +recruits +rectal +rectify +recto +rector +rectors +rectory +rectrix +rectum +rectums +recur +recured +recures +recuring +recurred +recurs +recycle +recycled +recycles +redcoats +redcross +redden +reddened +reddens +redder +reddest +reddish +redeem +redeemed +redeemer +redeems +redefine +redeploy +redesign +redfaced +redhead +redheads +redial +redirect +redneck +redness +redo +redoing +redolent +redone +redouble +redoubt +redoubts +redound +redox +redraft +redraw +redrawn +redraws +redress +reds +redsea +redshift +redtape +reduce +reduced +reducer +reducers +reduces +reducing +redwood +reed +reeds +reef +reefed +reefing +reefs +reek +reeked +reeking +reeks +reel +reelects +reeled +reeling +reels +refer +referee +refereed +referees +referent +referral +referred +refers +refile +refiled +refiling +refill +refilled +refills +refine +refined +refiner +refiners +refinery +refines +refining +refinish +refit +refits +refitted +reflect +reflects +reflex +reflexes +refloat +reflux +refluxed +refocus +refolded +reform +reformat +reformed +reformer +reforms +refract +refracts +refrain +refrains +refreeze +refresh +refs +refuel +refuels +refuge +refugee +refugees +refuges +refund +refunded +refunds +refusal +refusals +refuse +refused +refuses +refusing +refute +refuted +refutes +refuting +regain +regained +regains +regal +regale +regaled +regales +regalia +regaling +regality +regally +regard +regarded +regards +regatta +regattas +regelate +regency +regent +regents +reggae +regicide +regime +regimen +regimens +regiment +regimes +regina +reginas +region +regional +regions +register +registry +regress +regret +regrets +regroup +regrow +regrowth +regular +regulars +regulate +rehash +rehashed +rehashes +reheard +rehears +rehearse +reheat +reheated +reheats +rehouse +rehoused +reich +reify +reign +reigned +reigning +reigns +reimpose +rein +reindeer +reined +reining +reins +reinsert +reinvent +reinvest +reissue +reissued +reissues +reject +rejected +rejects +rejoice +rejoiced +rejoices +rejoin +rejoined +rejoins +rekindle +relabel +relaid +relapse +relapsed +relapses +relate +related +relates +relating +relation +relative +relator +relaunch +relax +relaxant +relaxed +relaxes +relaxing +relay +relayed +relaying +relays +relearn +release +released +releases +relegate +relent +relented +relents +relevant +reliable +reliably +reliance +reliant +relic +relics +relict +relicts +relied +relief +reliefs +relies +relieve +relieved +relieves +relight +religion +relined +relink +relinked +relish +relished +relishes +relit +relive +relived +relives +reliving +reload +reloaded +reloads +relocate +relocked +rely +relying +remade +remain +remained +remains +remake +remakes +remaking +remand +remanded +remands +remap +remaps +remark +remarked +remarks +remarry +remaster +rematch +remedial +remedied +remedies +remedy +remember +remind +reminded +reminder +reminds +remiss +remit +remits +remittal +remitted +remix +remixed +remixes +remnant +remnants +remodel +remorse +remote +remotely +remoter +remotest +remould +remount +remounts +removal +removals +remove +removed +remover +removers +removes +removing +remus +renal +rename +renamed +renames +renaming +render +rendered +renders +rending +rends +renegade +renege +reneged +reneging +renew +renewal +renewals +renewed +renewing +renews +renounce +renovate +renown +renowned +rent +rental +rentals +rented +renter +renters +rentiers +renting +rents +renumber +reoccupy +reoccur +reopen +reopened +reopens +reorder +reorders +repack +repacked +repaid +repaint +repair +repaired +repairer +repairs +repaper +repartee +repast +repasts +repay +repaying +repays +repeal +repealed +repeals +repeat +repeated +repeater +repeats +repel +repelled +repels +repent +repented +repents +rephrase +repine +repined +repining +replace +replaced +replaces +replant +replay +replayed +replays +replete +replica +replicas +replied +replier +repliers +replies +replug +reply +replying +report +reported +reporter +reports +repose +reposed +reposes +reposing +repress +reprieve +reprint +reprints +reprisal +reprise +reproach +reproof +reproofs +reprove +reproved +reps +reptile +reptiles +republic +repulse +repulsed +repute +reputed +reputes +request +requests +requiem +requiems +require +required +requires +requital +requite +requited +reran +reread +rereads +rerolled +reroute +rerouted +reroutes +rerun +reruns +resale +rescale +rescaled +rescales +rescan +rescans +rescind +rescue +rescued +rescuer +rescuers +rescues +rescuing +resea +resealed +research +reseated +reselect +resell +reseller +resemble +resend +resent +resented +resents +reserve +reserved +reserver +reserves +reset +resets +resettle +reshape +reshaped +reshapes +reshow +reside +resided +resident +resides +residing +residual +residue +residues +residuum +resign +resignal +resigned +resigns +resin +resinous +resins +resiny +resist +resisted +resistor +resists +resit +resiting +resits +resize +resizing +resold +resolute +resolve +resolved +resolver +resolves +resonant +resonate +resort +resorted +resorts +resound +resounds +resource +respect +respects +respire +respired +respite +respond +responds +response +respray +resprays +rest +restart +restarts +restate +restated +restates +rested +restful +resting +restive +restless +restock +restore +restored +restorer +restores +restrain +restrict +restroom +rests +restyled +resubmit +result +resulted +results +resume +resumed +resumes +resuming +resupply +retail +retailed +retailer +retails +retain +retained +retainer +retains +retake +retaken +retakes +retaking +retard +retarded +retards +retch +retched +retching +retell +retest +retested +retests +rethink +reticent +reticule +retied +retina +retinal +retinas +retinue +retinues +retire +retired +retiree +retires +retiring +retitle +retitled +retold +retook +retort +retorted +retorts +retouch +retrace +retraced +retraces +retract +retracts +retrain +retral +retread +retreads +retreat +retreats +retrench +retrial +retried +retries +retrieve +retro +retrofit +retry +retrying +retsina +retted +retune +retuning +return +returned +returns +retype +retyped +retypes +retyping +reunify +reunion +reunions +reunite +reunited +reunites +reusable +reuse +reused +reuses +reusing +revalue +revalued +revalues +revamp +revamped +revamps +reveal +revealed +reveals +reveille +revel +revelled +reveller +revelry +revels +revenant +revenge +revenged +revenges +revenue +revenues +revere +revered +reverend +reverent +reveres +reverie +reveries +revering +reversal +reverse +reversed +reverser +reverses +revert +reverted +reverts +review +reviewed +reviewer +reviews +revile +reviled +reviling +revisal +revise +revised +reviser +revises +revising +revision +revisit +revisits +revival +revivals +revive +revived +reviver +revives +revivify +reviving +revoke +revoked +revoker +revokers +revokes +revoking +revolt +revolted +revolts +revolve +revolved +revolver +revolves +revs +revue +revues +revved +revving +reward +rewarded +rewards +rewind +rewinds +rewire +rewired +rewiring +reword +reworded +rework +reworked +reworks +rewound +rewrap +rewrite +rewrites +rewrote +rhapsody +rhea +rhein +rhenium +rheology +rheostat +rhesus +rhetoric +rhine +rhinitis +rhino +rhizome +rhodesia +rhodium +rhombic +rhombus +rhubarb +rhumbas +rhyme +rhymed +rhymer +rhymes +rhyming +rhythm +rhythmic +rhythms +rial +rials +rialto +ribald +ribaldry +ribbed +ribbing +ribbon +ribbons +ribcage +ribosome +ribs +rice +rich +richer +riches +richest +richly +richness +rick +rickets +rickety +ricking +ricks +ricksha +rickshas +rickshaw +ricochet +riddance +ridden +ridding +riddle +riddled +riddles +riddling +ride +rider +riders +rides +ridge +ridged +ridges +ridicule +riding +ridings +rids +rife +riff +riffle +riffled +riffs +rifle +rifled +rifleman +riflemen +rifles +rifling +riflings +rift +rifting +rifts +rigged +rigger +riggers +rigging +right +righted +righten +righter +rightful +righting +rightist +rightly +rights +rigid +rigidify +rigidity +rigidly +rigor +rigorous +rigour +rigours +rigs +rile +riled +riles +riling +rill +rills +rime +rimless +rimmed +rims +rind +rinds +ring +ringed +ringer +ringers +ringing +ringless +ringlet +ringlets +rings +ringside +ringworm +rink +rinks +rinse +rinsed +rinses +rinsing +riot +rioted +rioter +rioters +rioting +riotous +riots +ripcord +ripe +ripely +ripen +ripened +ripeness +ripening +ripens +riper +ripest +riping +ripoff +riposte +riposted +ripostes +ripped +ripper +rippers +ripping +ripple +rippled +ripples +rippling +rips +ripstop +rise +risen +riser +risers +rises +risible +rising +risings +risk +risked +riskier +riskiest +risking +risks +risky +risotto +risque +rissole +rissoles +rite +rites +ritual +ritually +rituals +rival +rivalled +rivalry +rivals +riven +river +riverine +rivers +rivet +riveted +riveter +riveting +rivets +riviera +rivulet +rivulets +roach +roaches +road +roadmap +roads +roadshow +roadside +roadster +roadway +roadways +roam +roamed +roamer +roaming +roams +roan +roar +roared +roarer +roaring +roars +roast +roasted +roaster +roasting +roasts +robbed +robber +robbers +robbery +robbing +robe +robed +robes +robin +robins +robot +robotic +robotics +robots +robs +robust +robustly +rock +rocked +rocker +rockers +rockery +rocket +rocketed +rocketry +rockets +rockfall +rockier +rockiest +rocking +rocks +rocky +rococo +rocs +rode +rodent +rodents +rodeo +rodeos +rods +roebuck +roentgen +roes +rogue +roguery +rogues +roguish +roister +role +roles +roll +rollcall +rolled +roller +rollers +rolling +rolls +rolypoly +roman +romance +romanced +romancer +romances +romans +romantic +romany +rome +rommel +romp +romped +romper +romping +romps +romulus +rondavel +roof +roofed +roofer +roofing +roofings +roofless +roofs +rooftop +rooftops +rooibos +rook +rookery +rookies +rooks +room +roomful +roomier +roomiest +roommate +rooms +roomy +roost +roosted +rooster +roosters +roosting +roosts +root +rooted +rooting +rootings +rootless +roots +rope +roped +ropes +roping +rosaries +rosary +rose +rosebud +rosebuds +rosebush +rosemary +roses +rosette +rosettes +rosewood +rosier +rosiest +rosily +rosin +roster +rosters +rostrum +rostrums +rosy +rota +rotary +rotas +rotate +rotated +rotates +rotating +rotation +rotator +rotators +rotatory +rote +rotor +rotors +rots +rotted +rotten +rottenly +rotter +rotting +rotund +rotunda +rouble +roubles +rouge +rouged +rouges +rough +roughage +roughed +roughen +roughens +rougher +roughest +roughie +roughing +roughly +roughs +roulette +round +rounded +roundel +roundels +rounder +rounders +roundest +rounding +roundish +roundly +rounds +roundup +roundups +rouse +roused +rouses +rousing +rout +route +routed +routeing +router +routers +routes +routine +routines +routing +routs +rove +roved +rover +rovers +roves +roving +rovings +rowboat +rowboats +rowdier +rowdiest +rowdily +rowdy +rowdyism +rowed +rower +rowers +rowing +rows +royal +royalist +royally +royals +royalty +ruanda +rubbed +rubber +rubbers +rubbery +rubbing +rubbings +rubbish +rubbishy +rubble +rubbles +rubella +rubicon +rubicund +rubidium +rubies +rubric +rubs +ruby +ruck +rucks +rucksack +ruction +ructions +rudder +rudders +ruddy +rude +rudely +rudeness +ruder +rudest +rueful +ruefully +rues +ruff +ruffian +ruffians +ruffle +ruffled +ruffles +ruffling +ruffs +rugby +rugged +ruggedly +rugs +ruin +ruined +ruiner +ruining +ruinous +ruins +rule +rulebook +ruled +ruler +rulers +rules +ruling +rulings +rumania +rumba +rumbas +rumble +rumbled +rumbles +rumbling +rumen +ruminant +ruminate +rummage +rummaged +rummages +rummy +rumour +rumoured +rumours +rump +rumple +rumpled +rumpling +rumps +rumpus +rumpuses +runaway +rundown +rune +runes +rung +rungs +runnable +runner +runners +runnerup +runnier +runniest +running +runny +runs +runt +runts +runway +runways +rupee +rupees +rupert +rupture +ruptured +ruptures +rural +ruralist +rurally +ruse +rush +rushed +rushes +rushhour +rushier +rushing +rusk +rusks +russet +russia +russian +rust +rusted +rustic +rustics +rustier +rustiest +rusting +rustle +rustled +rustler +rustlers +rustles +rustling +rusts +rusty +ruth +ruthless +ruts +rutted +rwanda +sabbat +sabbath +sabbaths +saber +sable +sables +sabotage +saboteur +sabra +sabras +sabre +sabres +sachet +sachets +sack +sacked +sackful +sackfuls +sacking +sacks +sacral +sacred +sacredly +sacristy +sacrum +sacs +sadden +saddened +saddens +sadder +saddest +saddle +saddled +saddler +saddlers +saddles +saddling +sadism +sadist +sadistic +sadists +sadly +sadness +sadsack +safari +safaris +safe +safely +safeness +safer +safes +safest +safeties +safety +saffron +saga +sagacity +sagas +sage +sagely +sages +sagest +sagged +sagging +sago +sags +sahara +sahib +said +saigon +sail +sailed +sailer +sailing +sailings +sailor +sailors +sails +saint +sainted +saintly +saints +saipan +sake +sakes +saki +salaam +salad +salads +salami +salamis +salaried +salaries +salary +sale +saleable +salem +sales +salesman +salesmen +salience +salient +saline +salinity +saliva +salivary +salivas +salivate +sallied +sallies +sallow +sally +sallying +salmon +salmons +salome +salon +salons +saloon +saloons +salsa +salt +salted +saltier +saltiest +salts +salty +salutary +salute +saluted +salutes +saluting +salvage +salvaged +salvager +salvages +salve +salved +salver +salvers +salving +salvo +samba +sambas +same +sameness +samizdat +samoa +samosas +samovar +sampan +sample +sampled +sampler +samplers +samples +sampling +samurai +sanctify +sanction +sanctity +sanctum +sand +sandal +sandals +sandbag +sandbags +sandbank +sanddune +sanded +sander +sandier +sandiest +sanding +sandman +sandpit +sands +sandwich +sandy +sane +sanely +saner +sanest +sang +sanguine +sanitary +sanitise +sanity +sank +sanserif +sanskrit +santiago +sapient +sapling +saplings +sapped +sapper +sappers +sapphire +sapping +saps +sarcasm +sarcasms +sarcoma +sardine +sardines +sardinia +sardonic +sarge +sari +saris +sarong +sash +sashes +satan +satanic +satanism +satchel +satchels +sated +satiate +satiated +satin +sating +satins +satiny +satire +satires +satiric +satirise +satirist +satisfy +satrap +satraps +satsumas +saturate +saturday +saturn +satyr +satyric +satyrs +sauce +saucepan +saucer +saucers +sauces +saucier +sauciest +saucily +saucy +saudi +saudis +sauna +saunas +saunter +saunters +sausage +sausages +saute +savage +savaged +savagely +savagery +savages +savaging +savanna +savannah +savant +savants +save +saved +saveloy +saver +savers +saves +saving +savings +saviour +saviours +savour +savoured +savours +savoury +savvy +sawdust +sawed +sawing +sawmill +sawmills +sawn +saws +sawtooth +sawyer +sawyers +saxon +saxons +saxony +saying +sayings +says +scab +scabbard +scabbed +scabby +scabies +scabs +scaffold +scalable +scalar +scalars +scald +scalded +scalding +scalds +scale +scaled +scalene +scales +scaling +scallop +scallops +scalp +scalped +scalpel +scalpels +scalping +scalps +scaly +scam +scamp +scamped +scamper +scampi +scams +scan +scandal +scandals +scanned +scanner +scanners +scanning +scans +scansion +scant +scantier +scantily +scanty +scape +scapula +scar +scarab +scarce +scarcely +scarcer +scarcest +scarcity +scare +scared +scares +scarf +scarfs +scarier +scariest +scarify +scarily +scaring +scarlet +scarlets +scarp +scarred +scarring +scars +scarves +scary +scat +scathe +scathed +scathing +scatter +scatters +scavenge +scenario +scene +scenery +scenes +scenic +scent +scented +scenting +scents +sceptic +sceptics +sceptre +sceptred +sceptres +schedule +schema +schemas +schemata +scheme +schemed +schemer +schemes +scheming +scherzi +scherzo +schism +schisms +schist +schists +schizoid +schmalz +schnapps +scholar +scholars +school +schooled +schools +schooner +schwa +schwas +sciatica +science +sciences +scifi +scimitar +scissor +scissors +scoff +scoffed +scoffing +scold +scolded +scolder +scolding +scolds +scone +scones +scoop +scooped +scooper +scoopful +scooping +scoops +scoot +scooter +scooters +scooting +scoots +scope +scopes +scorch +scorched +scorcher +scorches +score +scored +scorer +scorers +scores +scoring +scorn +scorned +scornful +scorning +scorns +scorpion +scot +scotch +scotched +scotches +scotfree +scotland +scots +scotsman +scottish +scour +scoured +scourge +scourged +scourges +scouring +scours +scout +scouted +scouting +scouts +scowl +scowled +scowling +scowls +scrabble +scram +scramble +scrams +scrap +scrape +scraped +scraper +scrapers +scrapes +scrapie +scraping +scrapped +scrappy +scraps +scratch +scratchy +scrawl +scrawled +scrawls +scrawny +scream +screamed +screamer +screams +scree +screech +screechy +screed +screeds +screen +screened +screens +screw +screwed +screwing +screws +screwy +scribal +scribble +scribe +scribed +scribes +scribing +scrimped +script +scripted +scripts +scroll +scrolled +scrolls +scrooge +scrooges +scrotum +scrub +scrubbed +scrubber +scrubby +scrubs +scruff +scruffy +scrum +scrums +scruple +scruples +scrutiny +scuba +scubas +scud +scudded +scudding +scuds +scuff +scuffed +scuffing +scuffle +scuffled +scuffles +scull +sculled +sculler +scullery +sculling +sculls +sculpt +sculpted +sculptor +scum +scupper +scurried +scurries +scurry +scurvy +scuttle +scuttled +scuttles +scythe +scythed +scythes +scything +seabed +seabird +seabirds +seaboard +seaborne +seacow +seacows +seafarer +seafood +seafront +seagod +seagoing +seagreen +seagull +seagulls +seal +sealant +sealants +sealed +sealer +sealers +sealing +sealion +seals +seam +seamail +seaman +seamed +seamen +seamier +seamless +seams +seamy +seance +seances +seaplane +seaport +seaports +sear +search +searched +searcher +searches +seared +searing +sears +seas +seascape +seashore +seasick +seaside +season +seasonal +seasoned +seasoner +seasons +seat +seated +seating +seatings +seats +seattle +seaward +seawards +seawater +seaweed +seaweeds +secant +secede +seceded +secedes +seceding +seclude +secluded +second +seconded +seconder +secondly +seconds +secrecy +secret +secrete +secreted +secretes +secretly +secrets +sect +section +sections +sector +sectoral +sectored +sectors +sects +secular +secure +secured +securely +securer +secures +securest +securing +security +sedan +sedate +sedated +sedately +sedater +sedates +sedating +sedation +sedative +sedge +sedges +sediment +sedition +seduce +seduced +seducer +seducers +seduces +seducing +seeable +seed +seedbed +seeded +seeder +seedier +seediest +seeding +seedless +seedling +seeds +seedy +seeing +seeings +seek +seeker +seekers +seeking +seeks +seem +seemed +seeming +seemlier +seemly +seems +seen +seep +seepage +seeped +seeping +seeps +seer +seers +sees +seesaw +seesaws +seethe +seethed +seethes +seething +segment +segments +seine +seisin +seismic +seize +seized +seizer +seizes +seizing +seizure +seizures +seldom +select +selected +selectee +selector +selects +selenium +self +selfish +selfless +selfmade +selfpity +selfsame +sell +sellable +seller +sellers +selling +sells +selves +semantic +semen +semester +semi +seminar +seminars +seminary +semite +semites +semitic +semitics +senate +senates +senator +senators +send +sender +senders +sending +sends +senegal +senhor +senhors +senile +senility +senior +seniors +senora +sense +sensed +senses +sensible +sensibly +sensing +sensings +sensor +sensors +sensory +sensual +sensuous +sent +sentence +sentient +sentinel +sentries +sentry +seoul +separate +sepia +septet +septets +septic +sequel +sequels +sequence +sequent +sequin +sequins +sequoia +seraglio +serai +seraphic +seraphim +seraphs +serenade +serenata +serene +serenely +serener +serenest +serenity +serf +serfdom +serfhood +serfs +serge +sergeant +serial +serially +serials +series +serif +serifed +serifs +serious +sermon +sermons +serology +serpent +serpents +serrate +serrated +serried +serum +serums +servant +servants +serve +served +server +servers +serves +service +serviced +services +servile +serving +servings +sesame +sesotho +sessile +session +sessions +setback +setbacks +seth +sets +setswana +settee +settees +setter +setters +setting +settings +settle +settled +settler +settlers +settles +settling +setts +setup +seven +sevens +seventh +seventy +sever +several +severe +severed +severely +severer +severest +severing +severity +severs +sewage +sewed +sewer +sewerage +sewerrat +sewers +sewing +sewings +sewn +sews +sexed +sexes +sexier +sexiest +sexily +sexiness +sexing +sexism +sexist +sexists +sexless +sexology +sextant +sextants +sextet +sextets +sexton +sextons +sexual +sexually +sexy +shabbier +shabbily +shabby +shack +shackle +shackled +shackles +shacks +shade +shaded +shades +shadier +shadiest +shadily +shading +shadings +shadow +shadowed +shadows +shadowy +shady +shaft +shafted +shafting +shafts +shag +shagged +shaggy +shags +shah +shahs +shakable +shake +shaken +shaker +shakers +shakes +shakeup +shakeups +shakier +shakiest +shakily +shaking +shaky +shale +shall +shallot +shallots +shallow +shallows +sham +shaman +shamanic +shamans +shamble +shambled +shambles +shame +shamed +shameful +shames +shaming +shammed +shamming +shampoo +shampoos +shamrock +shams +shandy +shank +shanks +shanties +shanty +shape +shaped +shapely +shaper +shapers +shapes +shaping +sharable +shard +shards +share +shared +sharer +shares +sharing +shark +sharks +sharp +sharpen +sharpens +sharper +sharpest +sharply +sharps +shatter +shatters +shave +shaved +shaven +shaver +shavers +shaves +shaving +shavings +shaw +shawl +shawls +sheaf +shear +sheared +shearer +shearers +shearing +shears +sheath +sheathe +sheathed +sheaths +sheaves +shed +shedding +sheds +sheen +sheep +sheepdog +sheepish +sheer +sheered +sheerest +sheet +sheeted +sheeting +sheets +sheik +sheikh +sheikhs +sheiks +shekel +shekels +shelf +shell +shellac +shelled +shelling +shells +shelter +shelters +shelve +shelved +shelves +shelving +shepherd +sherbet +sherds +sheriff +sheriffs +sherlock +sherries +sherry +shetland +shied +shield +shielded +shields +shies +shift +shifted +shifter +shifters +shiftier +shiftily +shifting +shifts +shifty +shilling +shimmer +shimmers +shin +shinbone +shindig +shine +shined +shiner +shines +shingle +shingles +shinier +shiniest +shining +shinned +shinning +shins +shiny +ship +shipload +shipmate +shipment +shipped +shipping +ships +shipyard +shire +shires +shirk +shirked +shirking +shirt +shirts +shiver +shivered +shivers +shivery +shoal +shoals +shock +shocked +shocker +shockers +shocking +shocks +shod +shoddier +shoddily +shoddy +shoe +shoebox +shoed +shoehorn +shoeing +shoelace +shoeless +shoes +shogun +shoguns +shone +shoo +shooed +shooing +shook +shoot +shooter +shooters +shooting +shoots +shop +shoplift +shopped +shopper +shoppers +shopping +shops +shore +shored +shores +shoring +shorn +short +shortage +shortcut +shorted +shorten +shortens +shorter +shortest +shorting +shortish +shortly +shorts +shorty +shot +shotgun +shotguns +shots +should +shoulder +shout +shouted +shouter +shouters +shouting +shouts +shove +shoved +shovel +shovels +shoves +shoving +show +showcase +showdown +showed +shower +showered +showers +showery +showgirl +showier +showiest +showing +showings +showman +showmen +shown +showoff +showroom +shows +showy +shrank +shrapnel +shred +shredded +shredder +shreds +shrew +shrewd +shrewder +shrewdly +shrews +shriek +shrieked +shrieker +shrieks +shrift +shrill +shrilled +shrills +shrilly +shrimp +shrimps +shrine +shrines +shrink +shrinks +shrivel +shrivels +shroud +shrouded +shrouds +shrub +shrubby +shrubs +shrug +shrugged +shrugs +shrunk +shrunken +shudder +shudders +shuffle +shuffled +shuffler +shuffles +shun +shunned +shunning +shuns +shunt +shunted +shunter +shunters +shunting +shunts +shushed +shut +shutdown +shuts +shutter +shutters +shutting +shuttle +shuttled +shuttles +shutup +shyer +shyest +shying +shyly +shyness +siam +siamese +siberia +siberian +sibilant +sibling +siblings +sibyl +sicilian +sicily +sick +sickbay +sickbed +sicken +sickened +sickens +sicker +sickest +sickle +sickles +sickly +sickness +sickroom +side +sideband +sidecar +sided +sidekick +sideline +sidelong +sider +sidereal +sides +sideshow +sidestep +sidewalk +sideways +siding +sidings +sidle +sidled +sidling +siege +sieges +sienna +sierra +siesta +siestas +sieve +sieved +sieves +sieving +sift +sifted +sifter +sifters +sifting +siftings +sifts +sigh +sighed +sighing +sighs +sight +sighted +sighting +sightly +sights +sightsee +sigma +sigmoid +sign +signal +signally +signals +signed +signer +signers +signet +signify +signing +signings +signor +signora +signors +signpost +signs +silage +silence +silenced +silencer +silences +silent +silently +silica +silicate +silicon +silicone +silk +silken +silkier +silkiest +silkily +silklike +silks +silkworm +silky +sillier +silliest +silly +silo +silt +silted +silting +silts +silty +silver +silvered +silvers +silvery +simeon +similar +simile +similes +simmer +simmered +simmers +simper +simpered +simpers +simple +simpler +simplest +simplex +simplify +simplism +simply +simulate +sinai +since +sincere +sine +sinecure +sines +sinew +sinews +sinewy +sinful +sinfully +sing +singable +singe +singed +singeing +singer +singers +singes +singing +single +singles +singly +sings +singsong +singular +sinister +sink +sinkable +sinker +sinkers +sinking +sinks +sinless +sinned +sinner +sinners +sinning +sins +sinter +sinters +sinuous +sinus +sinuses +sinusoid +siphon +siphoned +siphons +sipped +sipper +sippers +sipping +sips +sire +sired +siren +sirens +sires +sirius +sirloin +sirloins +sirs +sisal +sissies +sissy +sister +sisterly +sisters +sitar +sitcom +sitcoms +site +sited +sites +siting +sitings +sits +sitter +sitters +sitting +sittings +situate +situated +sixes +sixfold +sixpence +sixteen +sixth +sixths +sixties +sixtieth +sixty +size +sizeable +sized +sizes +sizing +sizzle +sizzled +sizzles +sizzling +sjambok +skate +skated +skater +skaters +skates +skating +skein +skeletal +skeleton +skeptic +skerries +sketch +sketched +sketcher +sketches +sketchy +skew +skewed +skewer +skewered +skewers +skewness +skews +skid +skidded +skidding +skids +skied +skier +skiers +skies +skiing +skilful +skill +skilled +skillet +skillful +skills +skim +skimmed +skimmer +skimming +skimp +skimped +skimping +skimpy +skims +skin +skincare +skindeep +skinhead +skinless +skinned +skinner +skinners +skinnier +skinning +skinny +skins +skip +skipped +skipper +skippers +skipping +skips +skirl +skirmish +skirt +skirted +skirting +skirts +skis +skit +skits +skittish +skittle +skittles +skua +skuas +skulk +skulked +skulking +skulks +skull +skullcap +skulls +skunk +skunks +skydive +skydived +skydiver +skydives +skyhigh +skylark +skylarks +skylight +skyline +skylines +skyscape +skyward +skywards +slab +slabs +slack +slacked +slacken +slackens +slacker +slackers +slackest +slacking +slackly +slacks +slag +slags +slain +slake +slaked +slalom +slaloms +slam +slammed +slamming +slams +slander +slanders +slang +slanging +slant +slanted +slanting +slants +slap +slapdash +slapped +slapper +slapping +slaps +slash +slashed +slasher +slashes +slashing +slat +slate +slated +slater +slaters +slates +slating +slats +slatted +slav +slave +slaved +slaver +slavered +slavers +slavery +slaves +slavic +slaving +slavish +slavs +slay +slayed +slayer +slayers +slaying +slays +sleaze +sleazier +sleazy +sled +sledding +sledge +sledges +sledging +sleds +sleek +sleeker +sleekly +sleeks +sleep +sleeper +sleepers +sleepier +sleepily +sleeping +sleeps +sleepy +sleet +sleets +sleeve +sleeved +sleeves +sleigh +sleighs +sleight +sleights +slender +slept +sleuth +sleuths +slew +slewed +slewing +slice +sliced +slicer +slicers +slices +slicing +slicings +slick +slicked +slicker +slickest +slickly +slicks +slid +slide +slided +slider +sliders +slides +sliding +slight +slighted +slighter +slightly +slights +slily +slim +slime +slimes +slimier +slimiest +slimline +slimly +slimmed +slimmer +slimmers +slimmest +slimming +slimness +slims +slimy +sling +slinging +slings +slink +slinking +slinky +slip +slippage +slipped +slipper +slippers +slippery +slipping +slips +slipshod +slipup +slipway +slit +slither +slithers +slithery +slits +slitting +sliver +slivers +slob +slobber +slobbers +slobbery +slobs +slog +slogan +slogans +slogged +slogging +slogs +sloop +slop +slope +sloped +slopes +sloping +slopped +sloppier +sloppily +slopping +sloppy +slops +slosh +sloshed +sloshing +slot +sloth +slothful +sloths +slots +slotted +slotting +slouch +slouched +slouches +slough +sloughed +slovak +slovenia +slovenly +slow +slowdown +slowed +slower +slowest +slowing +slowish +slowly +slowness +slowpoke +slows +sludge +sludgy +slug +sluggard +slugged +slugging +sluggish +slugs +sluice +sluiced +sluices +sluicing +slum +slumber +slumbers +slumming +slump +slumped +slumping +slumps +slums +slung +slunk +slur +slurp +slurped +slurping +slurps +slurred +slurring +slurry +slurs +slush +slushed +slushes +slushier +slushy +slut +sluts +slyer +slyly +slyness +smack +smacked +smacker +smacking +smacks +small +smaller +smallest +smallish +smallpox +smalls +smart +smarted +smarten +smarter +smartest +smarting +smartly +smarts +smash +smashed +smasher +smashes +smashing +smear +smeared +smearing +smears +smegma +smell +smelled +smellier +smelling +smells +smelly +smelt +smelted +smelter +smelters +smelting +smidgeon +smile +smiled +smiler +smilers +smiles +smiling +smirk +smirked +smirking +smirks +smite +smith +smiths +smithy +smiting +smitten +smock +smocks +smog +smoggy +smogs +smoke +smoked +smoker +smokers +smokes +smokier +smokiest +smoking +smoky +smolder +smooch +smooth +smoothed +smoother +smoothly +smooths +smote +smother +smothers +smoulder +smudge +smudged +smudges +smudgier +smudging +smudgy +smug +smuggle +smuggled +smuggler +smuggles +smugly +smugness +smut +smuts +smutty +snack +snacks +snaffle +snag +snagged +snagging +snags +snail +snails +snake +snaked +snakepit +snakes +snaking +snaky +snap +snapped +snapper +snappier +snappily +snapping +snappy +snaps +snapshot +snare +snared +snares +snaring +snarl +snarled +snarling +snarls +snatch +snatched +snatcher +snatches +sneak +sneaked +sneakers +sneakier +sneakily +sneaking +sneaks +sneaky +sneer +sneered +sneering +sneers +sneeze +sneezed +sneezes +sneezing +snick +snide +sniff +sniffed +sniffer +sniffers +sniffing +sniffle +sniffles +sniffly +sniffs +snifter +snigger +sniggers +snip +snipe +sniper +snipers +snipes +sniping +snipped +snippet +snippets +snipping +snips +snits +snivel +snob +snobbery +snobbish +snobs +snoek +snooker +snoop +snooped +snooper +snoopers +snooping +snoops +snoopy +snooze +snoozed +snoozes +snoozing +snore +snored +snorer +snorers +snores +snoring +snorkel +snorkels +snort +snorted +snorting +snorts +snotty +snout +snouts +snow +snowball +snowdrop +snowed +snowfall +snowier +snowiest +snowing +snowline +snowman +snowmen +snows +snowy +snub +snubbed +snubbing +snubs +snuff +snuffbox +snuffed +snuffing +snuffle +snuffled +snuffles +snuffs +snug +snugger +snuggle +snuggled +snuggles +snugly +snugness +soak +soaked +soaker +soakers +soaking +soakings +soaks +soandso +soap +soapbox +soaped +soapier +soapiest +soaping +soaps +soapy +soar +soared +soaring +soars +sobbed +sobbing +sobbings +sober +sobered +soberer +sobering +soberly +sobers +sobriety +sobs +socalled +soccer +sociable +sociably +social +socially +socials +societal +society +sock +socked +socket +sockets +socking +socks +socrates +soda +sodas +sodded +sodden +soddy +sodium +sodom +sodomise +sodomite +sodomy +sods +sofa +sofas +soffit +soft +softball +soften +softened +softener +softens +softer +softest +softie +softish +softly +softness +software +softwood +softy +soggier +soggiest +soggy +soil +soiled +soiling +soilings +soils +soiree +sojourn +sojourns +solace +solaces +solanum +solar +solaria +solarium +sold +solder +soldered +solders +soldier +soldiers +soldiery +sole +solecism +solely +solemn +solemnly +solenoid +soler +soles +solfa +solicit +solicits +solid +solidify +solidity +solidly +solids +solitary +solitude +solo +soloing +soloist +soloists +solstice +soluble +solute +solutes +solution +solvable +solve +solved +solvency +solvent +solvents +solver +solvers +solves +solving +soma +somali +somalia +somas +somatic +sombre +sombrely +sombrero +some +somebody +someday +somehow +someone +sometime +someway +someways +somewhat +sonar +sonars +sonata +sonatas +sones +song +songbird +songbook +songs +sonic +soninlaw +sonnet +sonnets +sonny +sonora +sonority +sonorous +sons +soon +sooner +soonest +soonish +soot +soothe +soothed +soothers +soothes +soothing +sootier +soots +sooty +sophist +sophists +sopping +soppy +soprano +sorbet +sorbets +sorcerer +sorcery +sordid +sordidly +sore +sorely +soreness +sores +sorghum +sorority +sorrel +sorrier +sorriest +sorrow +sorrowed +sorrows +sorry +sort +sortable +sorted +sorter +sorters +sortie +sorties +sorting +sorts +soso +sotho +soudan +souffle +sought +souk +souks +soul +souled +soulful +soulless +souls +sound +sounded +sounder +soundest +sounding +soundly +sounds +soup +soups +soupy +sour +source +sourced +sources +sourcing +soured +sourest +souring +sourly +sourness +sours +soused +south +southern +souvenir +soviet +sowed +sower +sowers +soweto +sowing +sown +sows +soya +soybean +soybeans +space +spaceage +spaced +spaceman +spacemen +spacer +spacers +spaces +spacey +spacial +spacing +spacings +spacious +spade +spaded +spades +spain +spam +span +spangle +spangled +spangles +spaniel +spaniels +spanish +spank +spanked +spanker +spanking +spanks +spanned +spanner +spanners +spanning +spans +spar +spare +spared +sparely +spares +sparing +spark +sparked +sparking +sparkle +sparkled +sparkler +sparkles +sparkly +sparks +sparred +sparring +sparrow +sparrows +spars +sparse +sparsely +sparser +sparsest +sparsity +sparta +spartan +spartans +spas +spasm +spasms +spastic +spastics +spat +spate +spatial +spats +spatter +spatters +spatula +spatulas +spawn +spawned +spawning +spawns +spay +spayed +spaying +spays +speak +speaker +speakers +speaking +speaks +spear +speared +spearing +spears +spec +special +specials +species +specific +specify +specimen +specious +speck +speckle +speckled +speckles +specks +specs +spectra +spectral +spectre +spectres +spectrum +specular +speculum +sped +speech +speeches +speed +speedcop +speeded +speedier +speedily +speeding +speeds +speedup +speedway +speedy +spell +spelled +speller +spellers +spelling +spells +spelt +spencer +spend +spender +spenders +spending +spends +spent +spew +spewed +spewing +spews +sphagnum +sphere +spheres +spheric +spheroid +sphinx +spice +spiced +spicer +spicery +spices +spicier +spicily +spicing +spicy +spider +spiders +spidery +spied +spies +spigot +spike +spiked +spikes +spikier +spikiest +spiking +spiky +spill +spillage +spilled +spiller +spilling +spills +spilt +spin +spinach +spinal +spindle +spindles +spindly +spindry +spine +spines +spinet +spinner +spinners +spinney +spinning +spinoff +spinoffs +spins +spinster +spiny +spiral +spirally +spirals +spirant +spirants +spire +spires +spirit +spirited +spirits +spit +spite +spiteful +spitfire +spits +spitting +spittle +spittoon +splash +splashed +splashes +splashy +splat +splatter +splayed +splaying +spleen +spleens +splendid +splice +spliced +splicer +splicers +splices +splicing +spline +splines +splint +splinted +splinter +splints +split +splits +splitter +splodge +splodges +splurge +splutter +spoil +spoilage +spoiled +spoiler +spoilers +spoiling +spoils +spoilt +spoke +spoken +spokes +sponge +sponged +sponger +sponges +spongier +sponging +spongy +sponsor +sponsors +spoof +spoofs +spook +spooked +spooking +spooks +spooky +spool +spooled +spooling +spools +spoon +spooned +spoonful +spooning +spoons +spoor +sporadic +spore +spores +sporran +sporrans +sport +sported +sporting +sportive +sports +sporty +spot +spotless +spotlit +spoton +spots +spotted +spotter +spotters +spottier +spotting +spotty +spouse +spouses +spout +spouted +spouting +spouts +sprain +sprained +sprains +sprang +sprat +sprats +sprawl +sprawled +sprawls +spray +sprayed +sprayer +sprayers +spraying +sprays +spread +spreads +spree +spreeing +sprig +sprigs +spring +springer +springs +springy +sprinkle +sprint +sprinted +sprinter +sprints +sprite +sprites +sprocket +sprout +sprouted +sprouts +spruce +spruced +sprucing +sprung +spry +spud +spume +spun +spunky +spur +spurge +spurges +spurious +spurn +spurned +spurning +spurns +spurred +spurring +spurs +spurt +spurted +spurting +spurts +sputnik +sputniks +sputter +sputum +spyglass +spyhole +spying +spyings +squabble +squad +squadron +squads +squalid +squall +squalls +squally +squalor +squander +square +squared +squarely +squarer +squares +squaring +squarish +squash +squashed +squashes +squashy +squat +squats +squatted +squatter +squaw +squawk +squawked +squawks +squeak +squeaked +squeaker +squeaks +squeaky +squeal +squealed +squealer +squeals +squeegee +squeeze +squeezed +squeezer +squeezes +squeezy +squelch +squelchy +squib +squibs +squid +squids +squiggle +squint +squinted +squints +squire +squires +squirm +squirmed +squirms +squirrel +squirt +squirted +squirts +srilanka +stab +stabbed +stabber +stabbing +stable +stabled +stabler +stables +stabling +stably +stabs +staccato +stack +stacked +stacker +stacking +stacks +stadia +stadium +stadiums +staff +staffed +staffing +staffs +stag +stage +staged +stager +stages +stagey +stagger +staggers +staging +stagings +stagnant +stagnate +stags +staid +stain +stained +stainer +staining +stains +stair +stairs +stairway +stake +staked +stakes +staking +stale +stalin +stalk +stalked +stalker +stalkers +stalking +stalks +stall +stalled +stalling +stallion +stalls +stalwart +stamen +stamens +stamina +stammer +stammers +stamp +stamped +stampede +stamper +stampers +stamping +stamps +stance +stances +stand +standard +standby +standing +stands +stank +stanza +stanzas +stapes +staple +stapled +stapler +staplers +staples +stapling +star +starch +starched +starches +starchy +stardom +stardust +stare +stared +starer +stares +starfish +stargaze +staring +stark +starker +starkest +starkly +starless +starlet +starlets +starlike +starling +starlit +starred +starrier +starring +starry +stars +starship +start +started +starter +starters +starting +startle +startled +startles +starts +startup +startups +starve +starved +starves +starving +stashed +stashes +stashing +stasis +state +stated +stately +states +static +statical +statics +stating +station +stations +stator +stators +statuary +statue +statues +stature +statures +status +statuses +statute +statutes +staunch +stave +staved +staves +staving +stay +stayed +stayers +staying +stays +stead +steadied +steadier +steadily +steady +steak +steaks +steal +stealer +stealers +stealing +steals +stealth +stealthy +steam +steamed +steamer +steamers +steamier +steaming +steams +steamy +steed +steeds +steel +steeled +steeling +steels +steely +steep +steeped +steepen +steepens +steeper +steepest +steeping +steeple +steepled +steeples +steeply +steeps +steer +steerage +steered +steering +steers +stellar +stem +stemmed +stemming +stems +stench +stenches +stencil +stencils +stenosis +stentor +step +steppe +stepped +steppes +stepping +steps +stepson +stepsons +stepwise +stereo +stereos +sterile +sterling +stern +sterner +sternest +sternly +sterns +sternum +steroid +steroids +stet +stew +steward +stewards +stewed +stewing +stews +stick +sticker +stickers +stickily +sticking +stickler +sticks +sticky +sties +stiff +stiffen +stiffens +stiffer +stiffest +stiffly +stifle +stifled +stifles +stifling +stigma +stigmas +stigmata +stiletto +still +stilled +stiller +stilling +stills +stilt +stilted +stilts +stimuli +stimulus +sting +stinged +stinger +stingers +stingier +stingily +stinging +stingray +stings +stingy +stink +stinker +stinkers +stinking +stinks +stinky +stint +stinted +stints +stipel +stipend +stipends +stippled +stipples +stir +stirfry +stirred +stirrer +stirrers +stirring +stirrup +stirrups +stirs +stitch +stitched +stitcher +stitches +stoa +stoat +stoats +stock +stockade +stockcar +stocked +stockier +stockily +stocking +stockist +stocks +stocky +stodge +stodgier +stodgy +stoep +stoic +stoical +stoicism +stoics +stoke +stoked +stoker +stokers +stokes +stoking +stole +stolen +stolid +stolidly +stoma +stomach +stomachs +stomata +stomp +stomped +stomping +stomps +stone +stoned +stones +stonier +stoniest +stonily +stoning +stony +stood +stooge +stooges +stool +stools +stoop +stooped +stooping +stoops +stop +stopcock +stopgap +stopover +stoppage +stopped +stopper +stoppers +stopping +stops +storage +storages +store +stored +storeman +stores +storey +storeys +stories +storing +stork +storks +storm +stormed +stormer +stormers +stormier +storming +storms +stormy +story +stout +stouter +stoutest +stoutly +stove +stoves +stow +stowage +stowaway +stowed +stowing +stows +straddle +strafe +strafed +strafing +straggle +straggly +straight +strain +strained +strainer +strains +strait +straiten +straits +strand +stranded +strands +strange +stranger +strangle +strap +strapped +strapper +straps +strata +strategy +stratum +stratus +straw +strawman +straws +stray +strayed +strayer +straying +strays +streak +streaked +streaker +streaks +streaky +stream +streamed +streamer +streams +street +streets +strength +stress +stressed +stresses +stretch +stretchy +strew +strewed +strewing +strewn +striated +stricken +strict +stricter +strictly +stride +strident +strider +strides +striding +strife +strifes +strike +striker +strikers +strikes +striking +string +stringed +stringer +strings +stringy +strip +stripe +striped +striper +stripes +stripier +striping +stripped +stripper +strips +stripy +strive +strived +striven +striver +strives +striving +strode +stroke +stroked +strokes +stroking +stroll +strolled +stroller +strolls +strong +stronger +strongly +strop +stropped +strops +strove +struck +strudel +strudels +struggle +strum +strummed +strumpet +strung +strut +struts +strutted +strutter +stub +stubbed +stubbing +stubble +stubbled +stubbles +stubbly +stubborn +stubby +stubs +stucco +stuccoed +stuck +stuckup +stud +studded +student +students +studied +studier +studiers +studies +studio +studios +studious +studs +study +studying +stuff +stuffed +stuffer +stuffier +stuffing +stuffs +stuffy +stultify +stumble +stumbled +stumbles +stump +stumped +stumping +stumps +stumpy +stun +stung +stunned +stunner +stunning +stuns +stunt +stunted +stunting +stuntman +stunts +stupefy +stupid +stupider +stupidly +stupor +stupors +sturdier +sturdily +sturdy +sturgeon +stutter +stutters +style +styled +styles +styli +styling +stylised +stylish +stylist +stylists +stylus +styluses +stymie +stymied +styrene +styx +suasion +suave +suavely +subbed +subbing +subclass +subdue +subdued +subdues +subduing +subgroup +subhuman +subject +subjects +sublayer +sublime +sublimed +sublimes +submerge +submit +submits +subplot +subplots +subpoena +subs +subset +subsets +subside +subsided +subsides +subsidy +subsist +subsists +subsoil +subsonic +subspace +subsume +subsumed +subsumes +subtend +subtends +subtext +subtitle +subtle +subtler +subtlest +subtlety +subtly +subtotal +subtract +subtype +subtypes +subunit +subunits +suburb +suburban +suburbia +suburbs +subvert +subverts +subway +subways +subzero +succeed +succeeds +success +succinct +succour +succumb +succumbs +such +suchlike +suck +suckable +sucked +sucker +suckers +sucking +suckle +suckled +suckles +suckling +sucks +sucrose +suction +sudan +sudden +suddenly +suds +sued +suede +sues +suet +suffer +suffered +sufferer +suffers +suffice +sufficed +suffices +suffix +suffixed +suffixes +suffrage +suffuse +suffused +suffuses +sugar +sugared +sugaring +sugars +sugary +suggest +suggests +suicidal +suicide +suicides +suing +suit +suitable +suitably +suitcase +suite +suited +suites +suiting +suitor +suitors +suits +sulk +sulked +sulkier +sulkiest +sulkily +sulking +sulks +sulky +sullen +sullenly +sullied +sully +sullying +sulphate +sulphide +sulphur +sultan +sultana +sultanas +sultans +sultry +sumatra +summa +summable +summary +summed +summer +summers +summery +summing +summit +summits +summon +summoned +summoner +summons +sumo +sump +sumps +sums +sunbath +sunbathe +sunbeam +sunbeams +sunbed +sunbeds +sunblock +sunburn +sunburns +sunburnt +sunburst +suncream +sundaes +sunday +sundays +sundial +sundials +sundown +sundried +sundries +sundry +sung +sunk +sunken +sunking +sunless +sunlight +sunlit +sunned +sunnier +sunniest +sunning +sunny +sunrise +sunrises +sunroof +suns +sunset +sunsets +sunshade +sunshine +sunspot +sunspots +suntan +super +superb +superbly +superfix +superior +superman +supermen +supine +supped +supper +suppers +supping +supplant +supple +supplied +supplier +supplies +supply +support +supports +suppose +supposed +supposes +suppress +supremal +supreme +supremo +sups +surd +sure +surely +sureness +surer +surest +sureties +surety +surf +surface +surfaced +surfacer +surfaces +surfed +surfeit +surfer +surfers +surfing +surfings +surfs +surge +surged +surgeon +surgeons +surgery +surges +surgical +surging +surliest +surlily +surly +surmise +surmised +surmises +surmount +surname +surnames +surpass +surplice +surplus +surprise +surreal +surrey +surreys +surround +surtax +survey +surveyed +surveyor +surveys +survival +survive +survived +survives +survivor +sushi +sushis +suspect +suspects +suspend +suspends +suspense +sustain +sustains +suture +sutures +swab +swabbed +swabbing +swabs +swad +swaddled +swads +swag +swagger +swags +swahili +swains +swallow +swallows +swam +swamp +swamped +swampier +swamping +swamps +swampy +swan +swans +swansong +swap +swapped +swapper +swappers +swapping +swaps +sward +swarm +swarmed +swarming +swarms +swarthy +swastika +swat +swathe +swathed +swathes +swats +swatted +swatting +sway +swayed +swaying +sways +swazi +swazis +swear +swearer +swearers +swearing +swears +sweat +sweated +sweater +sweaters +sweatier +sweatily +sweating +sweats +sweaty +swede +sweden +swedish +sweep +sweeper +sweepers +sweeping +sweeps +sweet +sweeten +sweetens +sweeter +sweetest +sweetie +sweetish +sweetly +sweetpea +sweets +swell +swelled +swelling +swells +sweltry +swept +swerve +swerved +swerves +swerving +swift +swifter +swiftest +swiftlet +swiftly +swifts +swill +swilled +swilling +swim +swimmer +swimmers +swimming +swims +swimsuit +swimwear +swindle +swindled +swindler +swindles +swine +swines +swing +swinger +swingers +swinging +swings +swingy +swipe +swiped +swipes +swirl +swirled +swirling +swirls +swish +swished +swishing +swishy +swiss +switch +switched +switcher +switches +swivel +swivels +swollen +swoon +swooned +swooning +swoons +swoop +swooped +swooping +swoops +swop +swopped +swopping +swops +sword +swords +swore +sworn +swot +swots +swotted +swotting +swum +swung +sycamore +sydney +syllabi +syllabic +syllable +syllabub +syllabus +sylph +sylphs +symbiont +symbol +symbolic +symbols +symmetry +sympathy +symphony +symposia +symptom +symptoms +synapse +synapses +synaptic +sync +syndrome +synergy +synod +synodic +synods +synonym +synonyms +synonymy +synopses +synopsis +synoptic +synovial +syntax +syphilis +syphon +syphoned +syphons +syria +syrian +syringe +syringes +syrup +syrups +syrupy +system +systemic +systems +systoles +systolic +taal +tabasco +tabbed +tabbing +tabby +table +tableau +tableaux +tablebay +tabled +tables +tablet +tablets +tabling +tabloid +tabloids +taboo +taboos +tabs +tabular +tabulate +tachyon +tachyons +tacit +tacitly +taciturn +tack +tacked +tackier +tackiest +tacking +tackle +tackled +tackler +tackles +tackling +tacks +tacky +tact +tactful +tactic +tactical +tactics +tactile +tactless +tactual +tadpole +tadpoles +taffeta +tagged +tagging +tags +tahiti +tahr +tail +tailed +tailing +tailless +tailor +tailored +tailors +tails +tailspin +tailwind +taint +tainted +tainting +taints +taipei +taiwan +take +takeable +takeaway +taken +takeover +taker +takers +takes +taking +takings +talc +talcum +tale +talent +talented +talents +tales +talisman +talk +talkback +talked +talker +talkers +talkie +talkies +talking +talkings +talks +tall +tallboy +taller +tallest +tallied +tallies +tallish +tallness +tallow +tally +tallyho +tallying +talmud +talon +talons +tame +tamed +tamely +tameness +tamer +tamers +tames +tamest +taming +tamp +tamped +tamper +tampered +tampers +tandem +tandems +tang +tangelo +tangent +tangents +tangible +tangibly +tangle +tangled +tangles +tangling +tango +tangy +tank +tankage +tankard +tankards +tanked +tanker +tankers +tankful +tanking +tanks +tanned +tanner +tanners +tannery +tannic +tannin +tanning +tannins +tannoy +tans +tantalum +tantrum +tantrums +tanzania +tapas +tapdance +tape +taped +taper +tapered +taperer +tapering +tapers +tapes +tapestry +tapeworm +taping +tapioca +tapir +tapped +tappers +tapping +tappings +taproom +taps +tardily +tardy +tares +target +targeted +targets +tariff +tariffs +tarmac +tarn +tarnish +tarns +tarot +tarragon +tarred +tarried +tarrier +tarriest +tarring +tarry +tarrying +tars +tarsal +tarsus +tart +tartan +tartans +tartar +tartaric +tartly +tartness +tartrate +tarts +tarty +tarzan +task +tasked +tasking +tasks +tasmania +tassel +tassels +taste +tasted +tasteful +taster +tasters +tastes +tastier +tastiest +tasting +tastings +tasty +tattered +tatters +tattle +tattoo +tattooed +tattoos +tatty +taught +taunt +taunted +taunter +taunting +taunts +taut +tauter +tautest +tautly +tautness +tavern +taverna +tavernas +taverns +tawdry +tawny +taxable +taxation +taxed +taxes +taxfree +taxi +taxicab +taxied +taxies +taxiing +taxing +taxis +taxman +taxonomy +taxpayer +taylor +teabag +teabags +teach +teacher +teachers +teaches +teaching +teacloth +teacup +teacups +teak +teal +team +teamed +teaming +teammate +teams +teamster +teamwork +teaparty +teapot +teapots +tear +tearaway +teardrop +tearful +teargas +tearing +tearless +tearoom +tearooms +tears +teas +tease +teased +teaser +teasers +teases +teashop +teashops +teasing +teaspoon +teat +teatime +teatimes +teats +tech +tectonic +teddies +teddy +tedious +tedium +tediums +teds +teed +teehee +teeing +teem +teemed +teeming +teems +teen +teenage +teenaged +teenager +teeniest +teens +teensy +teeny +teepee +teepees +tees +teeter +teetered +teeth +teethe +teethed +teethes +teething +teetotal +teheran +telaviv +telecoms +telegram +teletext +telethon +teletype +televise +telex +telexes +tell +teller +tellers +telling +tells +telltale +telly +temerity +temper +tempera +tempered +tempers +tempest +tempests +tempi +template +temple +temples +tempo +temporal +tempt +tempted +tempter +tempters +tempting +tempts +tenable +tenacity +tenancy +tenant +tenanted +tenantry +tenants +tench +tend +tended +tendency +tender +tendered +tenderer +tenderly +tenders +tending +tendon +tendons +tendril +tendrils +tends +tenement +tenet +tenets +tenfold +tenners +tennis +tenon +tenor +tenors +tens +tense +tensed +tensely +tenser +tenses +tensest +tensile +tensing +tension +tensions +tensity +tensor +tensors +tent +tentacle +tented +tenth +tenths +tents +tenuous +tenure +tenured +tenures +tenurial +tepee +tepid +tequila +term +termed +terminal +terming +termini +terminus +termite +termites +termly +terms +tern +ternary +terns +terrace +terraced +terraces +terrain +terrains +terrapin +terrazzo +terrible +terribly +terrier +terriers +terrific +terrify +terrine +terror +terrors +terry +terse +tersely +terser +tertiary +tesseral +test +testable +tested +tester +testers +testes +testicle +testier +testiest +testify +testily +testing +testings +testis +tests +testtube +testy +tetanus +tetchily +tetchy +tether +tethered +tethers +tetra +texan +texans +texas +text +textbook +textile +textiles +texts +textual +textural +texture +textured +textures +thai +thalamus +thallium +thames +than +thane +thank +thanked +thankful +thanking +thanks +that +thatch +thatched +thatcher +thaw +thawed +thawing +thaws +theatre +theatres +thebes +thee +theft +thefts +their +theirs +theism +theist +theistic +theists +them +themas +thematic +theme +themed +themes +then +thence +theology +theorem +theorems +theories +theorise +theorist +theory +therapy +there +thereby +therefor +therein +thereof +thereon +thereto +thermal +thermals +therms +thesauri +these +thesis +thespian +theta +they +thick +thicken +thickens +thicker +thickest +thicket +thickets +thickish +thickly +thickset +thief +thieve +thieved +thievery +thieves +thieving +thievish +thigh +thighs +thimble +thimbles +thin +thine +thing +things +think +thinker +thinkers +thinking +thinks +thinly +thinned +thinner +thinners +thinness +thinnest +thinning +thinnish +thins +third +thirdly +thirds +thirst +thirsted +thirsts +thirsty +thirteen +thirties +thirty +this +thistle +thistles +thither +thomas +thong +thongs +thor +thoracic +thorax +thorium +thorn +thornier +thorns +thorny +thorough +those +thou +though +thought +thoughts +thousand +thrall +thrash +thrashed +thrasher +thrashes +thread +threaded +threads +threat +threaten +threats +three +threes +thresh +threshed +thresher +threw +thrice +thrift +thrifts +thrifty +thrill +thrilled +thriller +thrills +thrive +thrived +thrives +thriving +throat +throats +throaty +throb +throbbed +throbs +thrombus +throne +throned +thrones +throng +thronged +throngs +throttle +through +throw +thrower +throwers +throwing +thrown +throws +thrum +thrush +thrushes +thrust +thruster +thrusts +thud +thudded +thudding +thuds +thug +thuggery +thuggish +thugs +thumb +thumbed +thumbing +thumbs +thump +thumped +thumping +thumps +thunder +thunders +thundery +thursday +thus +thwack +thwart +thwarted +thwarts +thyme +thymus +thyroid +thyroids +thyself +tiara +tiaras +tibia +tibiae +tick +ticked +ticker +tickers +ticket +ticketed +tickets +ticking +tickle +tickled +tickler +tickles +tickling +ticklish +ticks +tics +tidal +tidbit +tidbits +tiddlers +tide +tideless +tides +tideway +tidied +tidier +tidies +tidiest +tidily +tidiness +tiding +tidings +tidy +tidying +tiebreak +tied +tier +tiered +tiers +ties +tiger +tigerish +tigers +tight +tighten +tightens +tighter +tightest +tightly +tights +tightwad +tigress +tigris +tikka +tilde +tildes +tile +tiled +tiler +tiles +tiling +tilings +till +tillage +tilled +tiller +tillers +tilling +tills +tilt +tilted +tilting +tilts +timber +timbered +timbre +time +timebase +timed +timeless +timely +timeout +timer +timers +times +timid +timidity +timidly +timing +timings +tincan +tincture +tinder +tinfoil +tinge +tinged +tinges +tingle +tingled +tingles +tinglier +tingling +tingly +tinier +tiniest +tinker +tinkered +tinkers +tinkle +tinkled +tinkling +tinkly +tinned +tinner +tinnier +tinniest +tinnily +tinnitus +tinny +tinpot +tins +tinsel +tinsels +tint +tinted +tinting +tintings +tints +tinware +tiny +tipoff +tipoffs +tipped +tipper +tipping +tipple +tippling +tips +tipster +tipsters +tipsy +tiptoe +tiptoed +tiptoes +tiptop +tirade +tirades +tire +tired +tiredly +tireless +tires +tiresome +tiring +tiro +tissue +tissues +titan +titanic +titanium +titans +titbit +titbits +tithe +tithes +tithing +title +titled +titles +titling +titrated +titre +titres +tits +titter +tittered +titters +titular +toad +toadies +toads +toady +toast +toasted +toaster +toasters +toasting +toasts +toasty +tobacco +tobago +toboggan +toby +toccata +tocsin +today +toddle +toddled +toddler +toddlers +toddling +toddy +todies +toed +toehold +toeing +toeless +toenail +toenails +toes +toffee +toffees +toffy +tofu +toga +togas +together +toggle +toggled +toggles +toggling +togo +togs +toil +toiled +toiler +toilet +toiletry +toilets +toilette +toiling +toils +toitoi +tokamak +token +tokenism +tokens +tokyo +tolbooth +told +toledo +tolerant +tolerate +toll +tolled +tollgate +tolling +tolls +toluene +tomahawk +tomato +tomb +tombola +tomboy +tomboys +tombs +tomcat +tome +tomes +tomorrow +tomtom +tonal +tonality +tonally +tone +toned +tonedeaf +toneless +toner +toners +tones +tonga +tongs +tongue +tongues +tonic +tonics +tonight +toning +tonnage +tonnages +tonne +tonnes +tons +tonsil +tonsils +tonsure +tony +took +tool +toolbox +tooled +tooling +tools +toot +tooted +tooth +toothed +toothier +toothy +tooting +tootle +topaz +topazes +topcoat +topheavy +topiary +topic +topical +topics +topless +toplevel +topmost +topnotch +topology +topped +topper +topping +toppings +topple +toppled +topples +toppling +tops +topsoil +topspin +torah +torch +torched +torches +torchlit +tore +tori +tories +torment +torments +torn +tornado +toronto +torpedo +torpid +torpor +torque +torques +torrent +torrents +torrid +torsion +torsions +torso +tortoise +torts +tortuous +torture +tortured +torturer +tortures +torus +tory +toss +tossed +tossers +tosses +tossing +tossup +tossups +total +totality +totalled +totally +totals +totem +totemic +totems +tots +totted +totter +tottered +totters +totting +toucans +touch +touche +touched +toucher +touches +touchier +touching +touchy +tough +toughen +toughens +tougher +toughest +toughie +toughies +toughly +toughs +toupee +tour +toured +tourer +tourers +touring +tourism +tourist +tourists +touristy +tourney +tours +tousled +tousles +tout +touted +touting +touts +toward +towards +towed +towel +towelled +towels +tower +towered +towering +towers +towing +town +towns +township +townsman +townsmen +towpath +towpaths +tows +toxaemia +toxic +toxicity +toxin +toxins +toyed +toying +toymaker +toys +toyshop +trace +traced +tracer +tracers +tracery +traces +trachea +tracheal +tracing +tracings +track +trackbed +tracked +tracker +trackers +tracking +tracks +trackway +tract +traction +tractor +tractors +tracts +trad +trade +traded +tradein +tradeins +trader +traders +trades +trading +tradings +traduced +traducer +traffic +tragedy +tragic +tragical +trail +trailed +trailer +trailers +trailing +trails +train +trained +trainee +trainees +trainer +trainers +training +trains +trait +traitor +traitors +traits +tram +tramcar +tramcars +trammel +tramp +tramped +tramping +trample +trampled +tramples +tramps +trams +tramway +tramways +trance +trances +tranche +tranches +tranny +tranquil +transact +transept +transfer +transit +transits +transmit +transom +trap +trapdoor +trapeze +trapped +trapper +trappers +trapping +traps +trash +trashed +trashy +trauma +traumas +traumata +travail +travails +travel +travels +traverse +travesty +trawl +trawled +trawler +trawlers +trawling +trawlnet +trawls +tray +trays +treacle +tread +treader +treading +treadle +treads +treason +treasons +treasure +treasury +treat +treated +treaties +treating +treatise +treats +treaty +treble +trebled +trebles +trebling +tree +treeless +trees +treetop +treetops +trefoil +trefoils +trek +trekked +trekker +trekkers +trekking +treks +trellis +tremble +trembled +trembler +trembles +tremolo +tremor +tremors +trench +trenched +trencher +trenches +trend +trendier +trends +trendy +trespass +tress +tresses +trestle +trestles +trews +triad +triadic +triads +triage +trial +trials +triangle +tribal +tribally +tribe +tribes +tribunal +tribune +tribunes +tribute +tributes +trice +trick +tricked +trickery +trickier +trickily +tricking +trickle +trickled +trickles +tricks +tricky +tricycle +trident +tridents +tried +trier +tries +triffid +triffids +trifle +trifled +trifler +trifles +trifling +trigger +triggers +trigram +trigrams +trigs +trikes +trilby +trill +trilled +trilling +trillion +trills +trilogy +trim +trimaran +trimmed +trimmer +trimmers +trimming +trimodal +trims +trinidad +trinity +trinket +trinkets +trio +trip +tripe +triplane +triple +tripled +triples +triplet +triplets +triplex +tripling +triply +tripod +tripods +tripoli +tripped +trippers +tripping +trips +triptych +tripwire +trireme +tristan +trite +tritium +triumph +triumphs +trivia +trivial +trod +trodden +troika +troikas +troll +trolley +trolleys +trolling +trollish +trolls +trombone +troop +trooped +trooper +troopers +trooping +troops +trope +tropes +trophies +trophy +tropic +tropical +tropics +trot +trots +trotted +trotter +trotters +trotting +trouble +troubled +troubles +trough +troughs +trounce +trounced +trounces +troupe +trouper +troupers +troupes +trouser +trousers +trout +trouts +trove +trowel +trowels +troy +truancy +truant +truants +truce +truces +truck +trucks +trudge +trudged +trudges +trudging +true +trueblue +truer +truest +truffle +truffles +truism +truisms +truly +trump +trumped +trumpery +trumpet +trumpets +trumps +truncate +trundle +trundled +trundles +trunk +trunking +trunks +trunnion +truss +trussed +trusses +trussing +trust +trusted +trustee +trustees +trustful +trusties +trusting +trusts +trusty +truth +truthful +truths +trying +tsetse +tshirt +tsunami +tswana +tswanas +tuareg +tuaregs +tuatara +tuba +tubas +tubby +tube +tubed +tubeless +tuber +tubers +tubes +tubing +tubs +tubular +tubules +tuck +tucked +tucker +tuckers +tucking +tucks +tues +tuesday +tuesdays +tuft +tufted +tufting +tufts +tugela +tugged +tugging +tugs +tuition +tulip +tulips +tumble +tumbled +tumbler +tumblers +tumbles +tumbling +tumbrils +tummies +tummy +tumour +tumours +tumult +tumults +tumulus +tuna +tunable +tunas +tundra +tundras +tune +tuned +tuneful +tuneless +tuner +tuners +tunes +tungsten +tunic +tunics +tuning +tunings +tunisia +tunisian +tunnel +tunnels +tunny +tuns +tuppence +turban +turbans +turbid +turbine +turbines +turbo +turbot +tureen +tureens +turf +turfed +turfs +turfy +turgid +turgidly +turin +turk +turkey +turkeys +turkish +turks +turmeric +turmoil +turmoils +turn +turncoat +turned +turner +turners +turning +turnings +turnip +turnips +turnkey +turnout +turnouts +turnover +turnpike +turns +turret +turreted +turrets +turtle +turtles +tuscany +tusk +tusked +tusker +tusks +tussle +tussles +tussling +tussock +tussocks +tussocky +tutelage +tutelary +tutor +tutored +tutorial +tutoring +tutors +tutu +tuxedo +twain +twang +twanged +twanging +twangs +tweak +tweaked +tweaking +tweaks +twee +tweed +tweeds +tweedy +tweeness +tweet +tweeter +tweeters +tweets +tweezers +twelfth +twelfths +twelve +twelves +twenties +twenty +twice +twiddle +twiddled +twiddler +twiddles +twiddly +twig +twigged +twiggy +twigs +twilight +twilit +twill +twin +twine +twined +twines +twinge +twinges +twining +twinkle +twinkled +twinkles +twinned +twinning +twins +twirl +twirled +twirling +twirls +twist +twisted +twister +twisters +twisting +twists +twisty +twit +twitch +twitched +twitches +twitchy +twitter +twofaced +twofold +twosome +tycoon +tycoons +tying +tyke +tykes +type +typecast +typed +typeface +typeless +types +typeset +typesets +typhoid +typhoon +typhoons +typhus +typical +typified +typifies +typify +typing +typings +typist +typists +typology +tyrannic +tyranny +tyrant +tyrants +tyre +tyres +uboats +udder +udders +uganda +ugandan +uglier +ugliest +ugliness +ugly +uhuh +ukraine +ukulele +ukuleles +ulcer +ulcerate +ulcerous +ulcers +ulster +ulsters +ulterior +ultimacy +ultimate +ultimo +ultra +umbra +umbrae +umbrage +umbras +umbrella +umlaut +umlauts +umpire +umpired +umpires +umpiring +umpteen +unabated +unable +unafraid +unaided +unalike +unamused +unapt +unarm +unarmed +unarms +unary +unasked +unaware +unawares +unawed +unbanned +unbar +unbarred +unbars +unbeaten +unbend +unbent +unbiased +unbidden +unbind +unblock +unboiled +unbolt +unbolted +unbooked +unborn +unbosom +unbound +unbowed +unbraced +unbroken +unbuckle +unburden +unburied +unburned +unburnt +unbutton +uncalled +uncanny +uncapped +uncared +uncaring +uncased +uncaught +unchain +uncivil +unclad +uncle +unclean +unclear +unclench +uncles +unclesam +unclog +unclosed +uncoil +uncoiled +uncoils +uncombed +uncomely +uncommon +uncooked +uncorked +uncouple +uncouth +uncover +uncovers +uncross +unction +unctuous +uncured +uncurled +uncut +undated +undead +under +underarm +undercut +underdog +underfed +undergo +underlay +underlie +underpay +underpin +undersea +undid +undo +undoing +undoings +undone +undress +undue +undulate +unduly +undying +unearned +unearth +unearths +unease +uneasier +uneasily +uneasy +uneaten +unedited +unending +unequal +unerring +uneven +unevenly +unfair +unfairly +unfasten +unfed +unfelt +unfenced +unfilled +unfired +unfirm +unfit +unfits +unfix +unfixed +unflawed +unfold +unfolded +unfolds +unforced +unformed +unfreeze +unfrozen +unfunded +unfunny +unfurl +unfurled +unfurls +unfussy +ungainly +unglazed +ungodly +unguided +unhand +unhandy +unhappy +unharmed +unheard +unheated +unheeded +unheroic +unhidden +unhinge +unhinged +unholy +unhook +unhooked +unhooks +unhoped +unhuman +unhurt +unicorn +unicorns +unicycle +unideal +unified +unifier +unifies +uniform +uniforms +unify +unifying +union +unionism +unionist +unions +unipolar +unique +uniquely +unisex +unison +unisons +unissued +unit +unitary +unite +united +unites +unities +uniting +units +unity +universe +unjam +unjammed +unjust +unjustly +unkempt +unkept +unkind +unkindly +unknown +unknowns +unlace +unlaced +unlacing +unladen +unlawful +unleaded +unlearn +unleash +unless +unlike +unlikely +unlined +unlink +unlinked +unlisted +unlit +unload +unloaded +unloads +unlock +unlocked +unlocks +unloose +unloved +unlovely +unloving +unlucky +unmade +unmaking +unmanly +unmanned +unmapped +unmarked +unmask +unmasked +unmasks +unmet +unmixed +unmoved +unmoving +unnamed +unneeded +unnerve +unnerved +unnoted +unopened +unowned +unpack +unpacked +unpacks +unpaid +unpaired +unpasted +unpaved +unpeeled +unpick +unpicked +unplaced +unplug +unproved +unproven +unquiet +unquote +unquoted +unravel +unravels +unread +unready +unreal +unrest +unrests +unriddle +unripe +unroll +unrolled +unruly +unsafe +unsafely +unsaid +unsalted +unsaved +unsavory +unscaled +unscrew +unseal +unsealed +unseat +unseated +unseeded +unseeing +unseemly +unseen +unsent +unset +unsettle +unshaded +unshaken +unshaped +unshapen +unshared +unshaved +unshaven +unshod +unshorn +unsigned +unsliced +unsmooth +unsocial +unsoiled +unsold +unsolder +unsolved +unsorted +unsought +unsound +unspent +unspoilt +unspoken +unstable +unstack +unstated +unsteady +unstuck +unsubtle +unsubtly +unsuited +unsung +unsure +untagged +untamed +untangle +untapped +untasted +untaught +untaxed +untaxing +untended +untested +untidier +untidily +untidy +untie +untied +unties +until +untimely +untiring +untitled +unto +untold +untoward +untraced +untried +untrue +untrusty +untruth +untruths +unturned +untwist +untying +untyped +unusable +unusably +unused +unusual +unvalued +unveil +unveiled +unveils +unversed +unvoiced +unwanted +unwarily +unwarmed +unwarned +unwary +unwashed +unweaned +unweary +unwed +unwedded +unwedge +unwell +unwieldy +unwind +unwinds +unwisdom +unwise +unwisely +unwisest +unworn +unworthy +unwound +unwrap +unwraps +unzip +unzipped +unzips +upbeat +upbraid +upbraids +upcast +upcoming +update +updated +updater +updates +updating +upended +upfield +upfront +upgrade +upgraded +upgrades +upheaval +upheld +uphill +uphold +upholder +upholds +upkeep +upland +uplands +uplift +uplifted +uplifts +uplink +uplinks +upload +uploaded +uploads +upmarket +upmost +upon +upped +upper +uppercut +uppers +upraised +uprate +uprated +uprating +upright +uprights +uprise +uprising +upriver +uproar +uproars +uproo +uproot +uprooted +uproots +upset +upsets +upshot +upside +upsilon +upstage +upstaged +upstages +upstairs +upstart +upstarts +upstream +upsurge +upsurges +upswing +uptake +upthrust +uptown +upturn +upturned +upward +upwardly +upwards +upwind +uranium +uranus +urban +urbane +urbanely +urbanise +urbanity +urchin +urchins +urea +ureter +ureters +urethane +urethra +urethrae +urethral +urethras +urge +urged +urgency +urgent +urgently +urges +urging +urgings +urinary +urine +urns +ursine +uruguay +usable +usage +usages +usances +useable +used +useful +usefully +useless +user +users +uses +usher +ushered +ushering +ushers +using +usual +usually +usurer +usurers +usurious +usurp +usurped +usurper +usurping +usury +utah +utensil +utensils +uteri +uterine +uterus +utilise +utilised +utilises +utility +utmost +utopia +utopian +utopians +utopias +utter +uttered +utterer +uttering +utterly +utters +uturns +uvula +uvular +vacancy +vacant +vacantly +vacate +vacated +vacates +vacating +vacation +vaccine +vaccines +vacua +vacuity +vacuole +vacuoles +vacuous +vacuum +vacuums +vaduz +vagabond +vagrancy +vagrant +vagrants +vague +vaguely +vaguer +vaguest +vain +vainer +vainest +vainly +valance +vale +valence +valency +vales +valet +valets +valhalla +valiant +valid +validate +validity +validly +valise +valley +valleys +valour +valuable +value +valued +valuer +valuers +values +valuing +valuta +valve +valves +vamp +vamped +vamper +vamping +vampire +vampires +vamps +vanadium +vandal +vandals +vane +vaned +vanes +vangogh +vanguard +vanilla +vanish +vanished +vanishes +vanities +vanity +vanquish +vans +vantage +vapid +vaporise +vaporous +vapour +vapours +variable +variably +variance +variant +variants +variate +variates +varicose +varied +varies +varietal +variety +various +varnish +varsity +vary +varying +vascular +vase +vaseline +vases +vassal +vassals +vast +vaster +vastly +vastness +vatican +vats +vault +vaulted +vaulting +vaults +vaunted +vaunting +veal +vector +vectored +vectors +veer +veered +veering +veers +vegan +vegans +vegetate +vegetive +veggies +vehement +vehicle +vehicles +veil +veiled +veiling +veils +vein +veined +veins +velar +veld +veldt +vellum +velocity +velour +velum +velvet +velvets +velvety +venal +venality +vend +venders +vendetta +vending +vendor +vendors +vends +veneer +veneered +veneers +venerate +venereal +venetian +vengeful +venial +venice +venison +venom +venomous +venoms +venose +venous +vent +vented +venting +ventings +ventral +vents +venture +ventured +venturer +ventures +venue +venues +venus +veracity +veranda +verandah +verandas +verb +verbal +verbally +verbals +verbatim +verbiage +verbose +verbs +verdant +verdict +verdicts +verdure +verge +verged +verger +verges +verging +verified +verifier +verifies +verify +verily +verities +verity +vermin +vernal +vernier +verona +verse +versed +verses +versicle +version +versions +versus +vertebra +vertex +vertical +vertices +vertigo +verve +very +vesicle +vesicles +vespers +vessel +vessels +vest +vestal +vested +vestige +vestiges +vesting +vestment +vestry +vests +vesuvius +veteran +veterans +veto +vetoed +vetoing +vets +vetted +vetting +vexation +vexed +vexes +vexing +viable +viably +viaduct +viaducts +vial +vials +vibes +vibrancy +vibrant +vibrate +vibrated +vibrates +vibrato +vibrator +vicar +vicarage +vicars +vice +viceroy +viceroys +vices +vicinity +vicious +victim +victims +victor +victoria +victors +victory +victuals +video +videoed +videoing +videos +vied +vienna +vier +vies +view +viewable +viewed +viewer +viewers +viewing +viewings +views +vigil +vigilant +vigils +vignette +vigorous +vigour +viking +vikings +vile +vilely +vileness +viler +vilest +vilified +vilify +villa +village +villager +villages +villain +villains +villainy +villas +vims +vine +vinegar +vinegars +vines +vineyard +vino +vintage +vintages +vintner +vinyl +vinyls +viol +viola +violas +violate +violated +violates +violator +violence +violent +violet +violets +violin +violins +violist +viper +vipers +virago +viral +virgil +virgin +virginal +virginia +virgins +virile +virility +virology +virtual +virtue +virtues +virtuosi +virtuoso +virtuous +virulent +virus +viruses +visa +visage +visas +viscose +viscount +viscous +vise +visible +visibly +vision +visions +visit +visitant +visited +visiting +visitor +visitors +visits +visor +visors +vista +vistas +visual +visually +visuals +vital +vitalise +vitality +vitally +vitals +vitamin +vitamins +vitiate +vitiated +vitiates +vitreous +vitriol +viva +vivacity +vivid +vividly +vivified +vixen +vixens +vizier +vocal +vocalise +vocalist +vocally +vocals +vocation +vocative +vodka +vogue +voice +voiced +voices +voicing +voicings +void +voidable +voided +voiding +voids +voile +volatile +volcanic +volcano +vole +voles +volga +volition +volley +volleyed +volleys +volt +voltage +voltages +volts +voluble +volubly +volume +volumes +volute +vomit +vomited +vomiting +vomits +voodoo +voracity +vortex +vortexes +vortices +vote +voted +voteless +voter +voters +votes +voting +votive +vouch +vouched +voucher +vouchers +vouches +vowed +vowel +vowels +vowing +vows +voyage +voyaged +voyager +voyagers +voyages +voyaging +voyeur +voyeurs +vulcan +vulgar +vulgarly +vulgate +vulpine +vulture +vultures +vulva +vying +wackier +wacky +wadding +waddle +waddled +waddles +waddling +wade +waded +wader +waders +wades +wadi +wading +wadings +wadis +wads +wafer +wafers +waffle +waffled +waffles +waft +wafted +wafting +wafts +wafture +wage +waged +wager +wagered +wagerer +wagers +wages +wagged +waggery +wagging +waggish +waggle +waggled +waggles +waggling +waggly +waggons +waging +wagon +wagons +wags +wagtail +wagtails +waif +waifs +wail +wailed +wailer +wailing +wails +wainscot +waist +waists +wait +waited +waiter +waiters +waiting +waitress +waits +waive +waived +waiver +waivers +waives +waiving +wake +waked +wakeful +waken +wakened +wakening +wakens +wakes +waking +wales +walk +walkable +walked +walker +walkers +walking +walkout +walkover +walks +walkway +walkways +wall +wallaby +walled +wallet +wallets +walling +wallop +wallow +wallowed +wallows +walls +walnut +walnuts +walrus +walruses +waltz +waltzed +waltzes +waltzing +wand +wander +wandered +wanderer +wanders +wands +wane +waned +wanes +waning +wanly +want +wanted +wanting +wanton +wantonly +wants +wapiti +wapitis +warble +warbled +warbler +warblers +warbles +warbling +ward +warded +warden +wardens +warder +warders +warding +wardrobe +wards +wardship +ware +wares +warfare +warhead +warheads +warhorse +wariest +warily +wariness +waring +warlike +warlock +warlocks +warlord +warlords +warm +warmed +warmer +warmers +warmest +warming +warmish +warmly +warmness +warms +warmth +warmup +warn +warned +warners +warning +warnings +warns +warp +warpaint +warpath +warped +warping +warps +warrant +warrants +warranty +warred +warren +warrens +warring +warrior +warriors +wars +warsaw +warship +warships +wart +warthog +warthogs +wartime +warts +warty +wary +wash +washable +washday +washed +washer +washers +washes +washing +washings +washout +washy +wasp +waspish +wasps +wast +wastage +wastages +waste +wasted +wasteful +waster +wasters +wastes +wasting +wastings +wastrel +watch +watchdog +watched +watcher +watchers +watches +watchful +watching +watchman +watchmen +water +waterbed +watered +watering +waterloo +waterman +watermen +waters +waterway +watery +watt +wattage +wattle +watts +wave +waveband +waved +waveform +wavelet +wavelets +wavelike +waver +wavered +waverers +wavering +wavers +waves +wavier +waviest +wavily +waving +wavings +wavy +waxed +waxen +waxes +waxing +waxpaper +waxwork +waxworks +waxy +wayout +ways +wayside +wayward +weak +weaken +weakened +weakens +weaker +weakest +weakish +weakling +weakly +weakness +weal +wealth +wealthy +wean +weaned +weaning +weanling +weans +weapon +weaponry +weapons +wear +wearable +wearer +wearers +wearied +wearier +wearies +weariest +wearily +wearing +wears +weary +wearying +weasel +weaselly +weasels +weather +weathers +weave +weaved +weaver +weavers +weaves +weaving +weavings +webbed +webbing +webby +webfoot +webs +website +wedded +wedding +weddings +wedge +wedged +wedges +wedging +wedlock +weds +weed +weeded +weedier +weediest +weeding +weeds +weedy +week +weekday +weekdays +weekend +weekends +weeklies +weekly +weeks +ween +weeny +weep +weeper +weeping +weepings +weeps +weepy +weevil +weevils +weigh +weighed +weighing +weighs +weight +weighted +weights +weighty +weir +weird +weirder +weirdest +weirdly +weirdo +weirs +welcome +welcomed +welcomer +welcomes +weld +welded +welder +welders +welding +welds +welfare +well +wellborn +wellbred +welled +wellfed +wellhead +welling +wellkept +wellmade +welloff +wellpaid +wellread +wells +welltodo +wellused +wellworn +welly +welsh +welshman +welt +welter +welters +welts +wench +wenches +wend +wended +wending +wends +went +wept +were +werewolf +west +westerly +western +westerns +westward +wether +wetland +wetlands +wetly +wetness +wets +wetsuit +wetsuits +wettable +wetted +wetter +wettest +wetting +whack +whacked +whacker +whacko +whacks +whale +whaler +whalers +whales +whaling +wham +whap +wharf +wharfs +wharves +what +whatever +whatnot +wheals +wheat +wheaten +wheats +whee +wheedle +wheedled +wheel +wheeled +wheeler +wheelers +wheelie +wheeling +wheels +wheeze +wheezed +wheezes +wheezing +wheezy +whelk +whelked +whelks +whelp +when +whence +whenever +where +whereas +whereby +wherein +whereof +whereon +whereto +wherever +wherry +whet +whether +whetted +whetting +whey +which +whiff +whiffs +while +whiled +whiles +whiling +whilst +whim +whimper +whimpers +whims +whimsy +whine +whined +whines +whining +whinnied +whinny +whip +whipcord +whiplash +whipped +whipper +whippet +whippets +whipping +whippy +whips +whir +whirl +whirled +whirling +whirls +whirr +whirred +whirring +whisk +whisked +whisker +whiskers +whiskery +whiskey +whiskeys +whiskies +whisking +whisks +whisky +whisper +whispers +whist +whistle +whistled +whistler +whistles +whists +white +whitely +whiten +whitened +whitener +whitens +whiter +whites +whitest +whither +whiting +whitish +whittle +whittled +whizkids +whizz +whizzkid +whoa +whodunit +whoever +whole +wholes +wholly +whom +whomever +whoop +whooped +whooping +whoops +whoosh +whop +whore +whores +whoring +whorled +whorls +whose +whys +wick +wicked +wickedly +wicker +wicket +wickets +wicks +wide +wideeyed +widely +widen +widened +wideness +widening +widens +wideopen +wider +wides +widest +widgeon +widget +widow +widowed +widower +widowers +widows +width +widths +wield +wielded +wielder +wielding +wields +wife +wifeless +wifely +wigeon +wigeons +wigging +wiggle +wiggled +wiggler +wiggles +wiggling +wigs +wigwam +wigwams +wild +wildcat +wildcats +wilder +wildest +wildeyed +wildfire +wildfowl +wildlife +wildly +wildness +wildoats +wilds +wile +wiles +wilful +wilfully +wilier +wiliest +wiling +will +willed +willing +willow +willows +willowy +wills +wilt +wilted +wilting +wilts +wily +wimp +wimple +wimpy +wince +winced +winces +winch +winched +winches +winching +wincing +wind +windbag +windbags +winded +winder +winders +windfall +windier +windiest +windily +winding +windings +windlass +windless +windmill +window +windowed +windows +windpipe +winds +windsock +windsor +windsurf +windward +windy +wine +wined +winery +wines +wineskin +wing +winged +winger +wingers +winging +wingless +wings +wingspan +wining +wink +winked +winker +winkers +winking +winkle +winkled +winkles +winks +winnable +winner +winners +winning +winnings +winnow +wins +winsome +winter +wintered +winters +wintery +wintrier +wintry +wipe +wiped +wiper +wipers +wipes +wiping +wire +wired +wireless +wirer +wires +wirier +wiriest +wiring +wirings +wiry +wisdom +wisdoms +wise +wiseguys +wisely +wiser +wisest +wish +wishbone +wished +wishes +wishful +wishing +wisp +wisps +wispy +wistful +witch +witchery +witches +with +withdraw +withdrew +wither +withered +withers +withheld +withhold +within +without +witless +witness +wits +witter +wittier +wittiest +wittily +witting +witty +wives +wizard +wizardry +wizards +wizened +woad +wobble +wobbled +wobbler +wobbles +wobblier +wobbling +wobbly +wodan +wodge +woeful +woefully +woes +woke +woken +woks +wold +wolds +wolf +wolfcubs +wolfed +wolfish +wolves +woman +womanise +womanish +womanly +womans +womb +wombat +wombats +wombs +women +wonder +wondered +wonders +wondrous +wont +wood +woodbine +woodcock +woodcut +woodcuts +wooded +wooden +woodenly +woodland +woodlice +woodman +woodmen +woodpile +woods +woodshed +woodsman +woodwind +woodwork +woodworm +woody +wooed +wooer +woof +woofer +woofers +wooing +wool +woollen +woollens +woollier +woollies +woollike +woolly +wools +wooly +woos +word +wordage +worded +wordgame +wordier +wordiest +wording +wordings +wordless +wordplay +words +wordy +wore +work +workable +workaday +workbook +workday +workdays +worked +worker +workers +workfare +working +workings +workless +workload +workman +workmate +workmen +workout +workouts +workroom +works +workshop +workshy +worktop +worktops +workweek +world +worldly +worlds +worldwar +worm +wormhole +worming +wormlike +worms +wormy +worn +worried +worrier +worriers +worries +worry +worrying +worse +worsen +worsened +worsens +worser +worship +worships +worst +worsted +worth +worthier +worthies +worthily +worthy +would +wound +wounded +wounding +wounds +wove +woven +wowed +wows +wrack +wracked +wraith +wraiths +wrangle +wrangled +wrangler +wrangles +wrap +wrapped +wrapper +wrappers +wrapping +wraps +wrasse +wrath +wrathful +wraths +wreak +wreaked +wreaking +wreaks +wreath +wreathe +wreathed +wreathes +wreaths +wreck +wreckage +wrecked +wrecker +wreckers +wrecking +wrecks +wren +wrench +wrenched +wrenches +wrens +wrest +wrested +wresting +wrestle +wrestled +wrestler +wrestles +wretch +wretched +wretches +wriggle +wriggled +wriggles +wriggly +wright +wring +wringer +wringing +wrings +wrinkle +wrinkled +wrinkles +wrinkly +wrist +wrists +writ +writable +write +writer +writers +writes +writhe +writhed +writhes +writhing +writing +writings +writs +written +wrong +wronged +wronger +wrongest +wrongful +wronging +wrongly +wrongs +wrote +wrought +wrung +wryly +wryness +xenon +xhosa +xhosas +xmas +xray +xrayed +xraying +xrays +yacht +yachting +yachts +yaks +yale +yalelock +yams +yank +yankee +yankees +yanks +yapping +yaps +yard +yardage +yards +yarn +yarns +yawed +yawl +yawls +yawn +yawned +yawning +yawns +yaws +yeah +yeaned +year +yearbook +yearling +yearlong +yearly +yearn +yearned +yearning +yearns +years +yeas +yeast +yeasts +yeasty +yell +yelled +yelling +yellings +yellow +yellowed +yellower +yellows +yellowy +yells +yelp +yelped +yelping +yelpings +yelps +yemen +yens +yeoman +yeomanry +yeomen +yeti +yetis +yews +yiddish +yield +yielded +yielding +yields +yippee +yodel +yodelled +yodeller +yodels +yoga +yogi +yoke +yoked +yokel +yokels +yokes +yolk +yolks +yonder +yore +york +yorker +yorkers +young +younger +youngest +youngish +your +yours +yourself +youth +youthful +youths +yowl +yoyo +yttrium +yuck +yukon +yule +yuletide +yummiest +yummy +yuppie +yuppies +zaire +zambezi +zambia +zambian +zambians +zaniest +zany +zanzibar +zapping +zappy +zaps +zeal +zealot +zealotry +zealots +zealous +zeals +zebra +zebras +zebu +zebus +zees +zenith +zeniths +zeolite +zeolites +zephyr +zephyrs +zeppelin +zero +zeroed +zeroing +zest +zesty +zeta +zeus +zigzag +zigzags +zillion +zillions +zimbabwe +zinc +zion +zionism +zionist +zionists +zipped +zipper +zippers +zipping +zippy +zips +zither +zithers +zombi +zombie +zombies +zonal +zonation +zone +zoned +zones +zoning +zoology +zoom +zoomed +zooming +zooms +zoos +zulu +zulus""".splitlines() + +from thunno2 import codepage +from thunno2 import helpers +import string, re + +ignore_chars = string.ascii_letters + string.digits + r""".,!?:\"'%() ‘’""" +dictionary_codepage = "".join( + char for char in codepage.CODEPAGE if char not in ignore_chars +) + +assert len(dictionary_codepage) == 180 + + +def dictionary_compress_word(word): + if word not in words: + return -1 + index = words.index(word) + base_180_num = helpers.number_to_base_digits(index, 180) + return "".join(map(dictionary_codepage.__getitem__, base_180_num)).rjust(2, "¡") + + +def dictionary_decompress_string(s): + base_180_num = [*map(dictionary_codepage.index, s)] + index = helpers.from_list_of_digits_2(base_180_num, 180) + return words[index] + + +def backslashify(s): + r = "" + for c in s: + if c in dictionary_codepage + "\\": + r += "\\" + c + else: + r += c + return r + + +def optimal_dictionary_compression(s): + ws = re.findall("([a-z]*)([^a-z]*)", str(s).lower()) + ret = "" + for word, other_stuff in ws: + if not (word + other_stuff): + continue + compressions = [] + for x in helpers.all_slices(word): + compressions.append( + "".join( + dictionary_compress_word(w) + if dictionary_compress_word(w) != -1 + else w + for w in x + ) + + backslashify(other_stuff) + ) + ret += min(compressions, key=len) + return ret diff --git a/src/build/lib/thunno2/flags.py b/src/build/lib/thunno2/flags.py new file mode 100644 index 0000000..98704b5 --- /dev/null +++ b/src/build/lib/thunno2/flags.py @@ -0,0 +1,227 @@ +from thunno2 import interpreter, commands, helpers +import re + + +def process_input_flags(flags, inputs): + if "w" in flags: + commands.ctx.warnings = True + + if "W" in flags: + inputs = [inputs] + else: + inputs = inputs.splitlines() + + if "E" not in flags: + new_input = [] + for inp in inputs: + try: + x = eval(inp) + if type(x) in (int, float, str, list): + new_input.append(x) + elif isinstance(x, bool): + new_input.append(int(x)) + elif isinstance(x, (set, tuple)): + new_input.append(list(x)) + elif isinstance(x, dict): + new_input.append(list(map(list, x.items()))) + else: + new_input.append(inp) + except: + new_input.append(inp) + inputs = new_input[:] + + for flag in flags: + if flag == "Z": + commands.ctx.stack.push(0) + elif flag == "T": + commands.ctx.stack.push(10) + elif flag == "H": + commands.ctx.stack.push(100) + + if "B" in flags: + new_input = [] + for inp in inputs: + if isinstance(inp, str): + new_input.append([ord(c) for c in inp]) + else: + new_input.append(inp) + inputs = new_input[:] + + if "+" in flags: + new_input = [] + for inp in inputs: + if isinstance(inp, (int, float)): + new_input.append(inp + flags.count("+")) + else: + new_input.append(inp) + inputs = new_input[:] + + if "-" in flags: + new_input = [] + for inp in inputs: + if isinstance(inp, (int, float)): + new_input.append(inp - flags.count("-")) + else: + new_input.append(inp) + inputs = new_input[:] + + if "c" in flags: + commands.ctx.vyxal_mode = True + + return inputs + + +def process_output_flags(flags, do_print=True): + for flag in flags: + if "J" == flag: + commands.ctx.stack.push(helpers.empty_join(next(commands.ctx.stack.rmv(1)))) + + if "j" == flag: + commands.ctx.stack.push(helpers.empty_join(list(commands.ctx.stack))) + + if "N" == flag: + commands.ctx.stack.push( + helpers.newline_join(next(commands.ctx.stack.rmv(1))) + ) + + if "n" == flag: + commands.ctx.stack.push(helpers.newline_join(list(commands.ctx.stack))) + + if "Ṡ" == flag: + commands.ctx.stack.push(helpers.space_join(next(commands.ctx.stack.rmv(1)))) + + if "ṡ" == flag: + commands.ctx.stack.push(helpers.space_join(list(commands.ctx.stack))) + + if "S" == flag: + commands.ctx.stack.push(commands.commands["S"]()[0]) + + if "s" == flag: + commands.ctx.stack.push(helpers.it_sum(commands.ctx.stack)) + + if "L" == flag: + commands.ctx.stack.push(commands.commands["l"]()[0]) + + if "l" == flag: + commands.ctx.stack.push(len(commands.ctx.stack)) + + if "h" == flag: + commands.ctx.stack.push(commands.commands["h"]()[0]) + + if "t" == flag: + commands.ctx.stack.push(commands.commands["t"]()[0]) + + if "B" == flag: + x = (commands.ctx.stack + commands.ctx.other_il + [0])[0] + if isinstance(x, list): + r = "" + for i in x: + try: + r += chr(int(i)) + except: + pass + commands.ctx.stack.push(r) + + if "G" == flag: + commands.ctx.stack.push(commands.commands["G"]()[0]) + + if "M" == flag: + commands.ctx.stack.push(commands.commands["M"]()[0]) + + if "b" == flag: + commands.ctx.stack.push(commands.commands["ɓ"]()[0]) + + if "!" == flag: + commands.ctx.stack.push(commands.commands["¬"]()[0]) + + if "Ḷ" == flag: + a = next(commands.ctx.stack.rmv(1)) + if isinstance(a, str): + commands.ctx.stack.push(a.upper()) + else: + commands.ctx.stack.push(a) + + if "Ṭ" == flag: + a = next(commands.ctx.stack.rmv(1)) + if isinstance(a, str): + commands.ctx.stack.push(a.title()) + else: + commands.ctx.stack.push(a) + + if "Ụ" == flag: + a = next(commands.ctx.stack.rmv(1)) + if isinstance(a, str): + commands.ctx.stack.push(a.upper()) + else: + commands.ctx.stack.push(a) + + if do_print: + do_printing(flags) + + +def do_printing(flags): + if (commands.ctx.implicit_print or ("O" in flags)) and not ("o" in flags): + print(next(commands.ctx.stack.rmv(1))) + + +def run(flags, code, inputs): + if "V" in flags: + new_flags = "".join(f for f in flags if f != "V") + for line in inputs.splitlines(): + try: + x = eval(line) + if isinstance(x, tuple): + new_inputs = process_input_flags(new_flags, "\n".join(map(repr, x))) + else: + new_inputs = [x] + except: + new_inputs = [line] + commands.ctx.og_input_list = new_inputs.copy() + commands.ctx.other_il = new_inputs.copy() + print(line, "--> ", end="") + interpreter.run(code, context=0, iteration_index=0) + process_output_flags(new_flags) + return None + + elif "C" in flags: + new_flags = "".join(f for f in flags if f != "C") + for l in inputs.splitlines(): + m = re.match(r"(.+) ?(?:=>|-+>) ?(.+)", l) + try: + line, output = m[1], m[2] + try: + x = eval(line) + if isinstance(x, tuple): + new_inputs = process_input_flags( + new_flags, "\n".join(map(repr, x)) + ) + else: + new_inputs = [x] + except: + new_inputs = [line] + try: + expected = process_input_flags("", output)[0] + except: + expected = output.strip() + except Exception as e: + print(f"FAIL ❌ (Got error {e})") + continue + commands.ctx.og_input_list = new_inputs.copy() + commands.ctx.other_il = new_inputs.copy() + commands.ctx.stack = commands.Stack() + print(line, "--> ", end="") + interpreter.run(code, context=0, iteration_index=0) + process_output_flags(new_flags, False) + actual_output = next(commands.ctx.stack.rmv(1)) + print(actual_output, end="\t") + if actual_output == expected: + print("PASS ✅") + else: + print(f"FAIL ❌ (Expected {expected})") + return None + + inputs = process_input_flags(flags, inputs) + commands.ctx.og_input_list = inputs.copy() + commands.ctx.other_il = inputs.copy() + interpreter.run(code, context=0, iteration_index=0) + process_output_flags(flags) diff --git a/src/build/lib/thunno2/helpers.py b/src/build/lib/thunno2/helpers.py new file mode 100644 index 0000000..ab7942f --- /dev/null +++ b/src/build/lib/thunno2/helpers.py @@ -0,0 +1,3179 @@ +"""An unordered, chaotic mess of helper functions""" + + +import copy +import itertools +import math +import random +import re +import string + +from thunno2 import codepage +from thunno2 import canvas + + +"""Creative Commons Legal Code + +CC0 1.0 Universal + + CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE + LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN + ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS + INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES + REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS + PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM + THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED + HEREUNDER. + +Statement of Purpose + +The laws of most jurisdictions throughout the world automatically confer +exclusive Copyright and Related Rights (defined below) upon the creator +and subsequent owner(s) (each and all, an "owner") of an original work of +authorship and/or a database (each, a "Work"). + +Certain owners wish to permanently relinquish those rights to a Work for +the purpose of contributing to a commons of creative, cultural and +scientific works ("Commons") that the public can reliably and without fear +of later claims of infringement build upon, modify, incorporate in other +works, reuse and redistribute as freely as possible in any form whatsoever +and for any purposes, including without limitation commercial purposes. +These owners may contribute to the Commons to promote the ideal of a free +culture and the further production of creative, cultural and scientific +works, or to gain reputation or greater distribution for their Work in +part through the use and efforts of others. + +For these and/or other purposes and motivations, and without any +expectation of additional consideration or compensation, the person +associating CC0 with a Work (the "Affirmer"), to the extent that he or she +is an owner of Copyright and Related Rights in the Work, voluntarily +elects to apply CC0 to the Work and publicly distribute the Work under its +terms, with knowledge of his or her Copyright and Related Rights in the +Work and the meaning and intended legal effect of CC0 on those rights. + +1. Copyright and Related Rights. A Work made available under CC0 may be +protected by copyright and related or neighboring rights ("Copyright and +Related Rights"). Copyright and Related Rights include, but are not +limited to, the following: + + i. the right to reproduce, adapt, distribute, perform, display, + communicate, and translate a Work; + ii. moral rights retained by the original author(s) and/or performer(s); +iii. publicity and privacy rights pertaining to a person's image or + likeness depicted in a Work; + iv. rights protecting against unfair competition in regards to a Work, + subject to the limitations in paragraph 4(a), below; + v. rights protecting the extraction, dissemination, use and reuse of data + in a Work; + vi. database rights (such as those arising under Directive 96/9/EC of the + European Parliament and of the Council of 11 March 1996 on the legal + protection of databases, and under any national implementation + thereof, including any amended or successor version of such + directive); and +vii. other similar, equivalent or corresponding rights throughout the + world based on applicable law or treaty, and any national + implementations thereof. + +2. Waiver. To the greatest extent permitted by, but not in contravention +of, applicable law, Affirmer hereby overtly, fully, permanently, +irrevocably and unconditionally waives, abandons, and surrenders all of +Affirmer's Copyright and Related Rights and associated claims and causes +of action, whether now known or unknown (including existing as well as +future claims and causes of action), in the Work (i) in all territories +worldwide, (ii) for the maximum duration provided by applicable law or +treaty (including future time extensions), (iii) in any current or future +medium and for any number of copies, and (iv) for any purpose whatsoever, +including without limitation commercial, advertising or promotional +purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each +member of the public at large and to the detriment of Affirmer's heirs and +successors, fully intending that such Waiver shall not be subject to +revocation, rescission, cancellation, termination, or any other legal or +equitable action to disrupt the quiet enjoyment of the Work by the public +as contemplated by Affirmer's express Statement of Purpose. + +3. Public License Fallback. Should any part of the Waiver for any reason +be judged legally invalid or ineffective under applicable law, then the +Waiver shall be preserved to the maximum extent permitted taking into +account Affirmer's express Statement of Purpose. In addition, to the +extent the Waiver is so judged Affirmer hereby grants to each affected +person a royalty-free, non transferable, non sublicensable, non exclusive, +irrevocable and unconditional license to exercise Affirmer's Copyright and +Related Rights in the Work (i) in all territories worldwide, (ii) for the +maximum duration provided by applicable law or treaty (including future +time extensions), (iii) in any current or future medium and for any number +of copies, and (iv) for any purpose whatsoever, including without +limitation commercial, advertising or promotional purposes (the +"License"). The License shall be deemed effective as of the date CC0 was +applied by Affirmer to the Work. Should any part of the License for any +reason be judged legally invalid or ineffective under applicable law, such +partial invalidity or ineffectiveness shall not invalidate the remainder +of the License, and in such case Affirmer hereby affirms that he or she +will not (i) exercise any of his or her remaining Copyright and Related +Rights in the Work or (ii) assert any associated claims and causes of +action with respect to the Work, in either case contrary to Affirmer's +express Statement of Purpose. + +4. Limitations and Disclaimers. + + a. No trademark or patent rights held by Affirmer are waived, abandoned, + surrendered, licensed or otherwise affected by this document. + b. Affirmer offers the Work as-is and makes no representations or + warranties of any kind concerning the Work, express, implied, + statutory or otherwise, including without limitation warranties of + title, merchantability, fitness for a particular purpose, non + infringement, or the absence of latent or other defects, accuracy, or + the present or absence of errors, whether or not discoverable, all to + the greatest extent permissible under applicable law. + c. Affirmer disclaims responsibility for clearing rights of other persons + that may apply to the Work or any use thereof, including without + limitation any person's Copyright and Related Rights in the Work. + Further, Affirmer disclaims responsibility for obtaining any necessary + consents, permissions or other rights required for any use of the + Work. + d. Affirmer understands and acknowledges that Creative Commons is not a + party to this document and has no duty or obligation with respect to + this CC0 or use of the Work. +""" + + +def convert_all_to_string(func): + def wrapper(*args, fn=func): + return fn(*map(str, args)) + + return wrapper + + +def try_int_conversion(func): + def wrapper(*args, fn=func): + try: + return fn(*map(int, args)) + except: + return [*args] + + return wrapper + + +def try_float_conversion(func): + def wrapper(*args, fn=func): + try: + return fn(*map(float, args)) + except: + return [*args] + + return wrapper + + +def try_number_conversion(func): + def wrapper(*args, fn=func): + new_args = [] + try: + for a in args: + if isinstance(a, int): + new_args.append(a) + elif isinstance(a, str): + try: + new_args.append(int(a)) + except: + new_args.append(float(a)) + elif isinstance(a, float): + new_args.append(a) + else: + raise + except: + return args + return fn(*new_args) + + return wrapper + + +def safe_max_len(*lsts): + m = 0 + for lst in lsts: + if isinstance(lst, list): + if len(lst) > m: + m = len(lst) + return m + + +def first_non_none(l): + for i in l: + if i is not None: + return i + + +def isalpha(s): + return int(s.isalpha()) + + +def number_to_base_digits(n, b): + if n == 0: + return [0] + digits = [] + while n: + digits.append(int(n % b)) + n //= b + return digits[::-1] + + +def ntb(b, n): + if b == 0: + return [n] + if b == 1: + return n * [0] + return number_to_base_digits(n, b) + + +def number_to_base(base, num): + num, base = int(num), int(base) + if base <= 0: + return str(num) + if base == 1: + return num * "0" + return number_to_base_digits(num, base) + + +def ntbs(b, n): + r = number_to_base_digits(n, b) + if b <= 64: + digits = string.digits + string.ascii_uppercase + string.ascii_lowercase + "+/" + else: + digits = codepage.CODEPAGE * math.ceil(b / 256) + return "".join(map(digits.__getitem__, r)) + + +def to_custom_base_string(base, num): + num = int(num) + if len(base) == 0: + return str(num) + if len(base) == 1: + return num * base + return "".join(map(base.__getitem__, number_to_base_digits(num, len(base)))) + + +def length_to_base(base, s): + base = int(base) + if base <= 0: + return str(len(s)) + if base == 1: + return len(s) * "0" + return number_to_base_digits(len(s), base) + + +def length_custom_base_string(str2, str1): + num = len(str1) + if len(str2) == 0: + return str(num) + if len(str2) == 1: + return num * "0" + return "".join(map(str2.__getitem__, number_to_base_digits(len(str1), len(str2)))) + + +def pass_(*args): + return args[::-1] + + +def from_list_of_digits_2(num, base): + r = 0 + for x, y in enumerate(reversed(num)): + r += int(base) ** x * int(y) + return r + + +def decompress(s, char): + ci = codepage.CODEPAGE.index(char) + indices = [i - (i > ci) for i in codepage.codepage_index(*s)] + return from_list_of_digits_2(indices, 255) + + +def chr2(num): + return chr(int(num)) + + +def ord2(s): + return [ord(c) for c in s] + + +def digits(num): + return [int(d) for d in str(num) if d in "0123456789"] + + +def is_even(num): + return int(num % 2 == 0) + + +def eval2(s): + try: + return eval(s) + except: + return 0 + + +def factors(num): + num = int(num) + return [i for i in range(1, num + 1) if num % i == 0] + + +def substrings(s): + return [s[i:j] for i in range(len(s)) for j in range(i + 1, len(s) + 1)] + + +def max2(num): + return max(int(d) for d in str(num) if d in "0123456789") + + +def max3(x): + try: + return max(x) + except: + return x + + +def from_hex(x): + try: + return int(str(x), 16) + except: + return x + + +def codepage_chr(num): + return codepage.CODEPAGE[int(num) % 256] + + +def codepage_ord(s): + return [*codepage.codepage_index(*s)] + + +def indexing_0(num, lst): + if not lst: + return lst + return lst[int(num) % len(lst)] + + +def swapped_ind0(lst, num): + if not lst: + return lst + return lst[int(num) % len(lst)] + + +def interleave_lst(lst1, lst2): + if len(lst1) == len(lst2): + r = [] + for i, j in zip(lst2, lst1): + r.append(i) + r.append(j) + return r + elif len(lst1) > len(lst2): + r = [] + for i, j in zip(lst2, lst1): + r.append(i) + r.append(j) + r.extend(lst1[len(lst2) :]) + return r + else: + r = [] + for i, j in zip(lst2, lst1): + r.append(i) + r.append(j) + r.extend(lst2[len(lst1) :]) + return r + + +def interleave_str(s1, s2): + if len(s1) == len(s2): + r = "" + for i, j in zip(s2, s1): + r += i + j + return r + elif len(s1) > len(s2): + r = "" + for i, j in zip(s2, s1): + r += i + j + r += s1[len(s2) :] + return r + else: + r = "" + for i, j in zip(s2, s1): + r += i + j + r += s2[len(s1) :] + return r + + +def binary_range(num1, num2): + if num1 < num2: + return binary_range(num2, num1)[::-1] + return list(range(num2, num1 + 1)) + + +def empty_join(iterable): + if not isinstance(iterable, list): + return str(iterable) + return "".join(map(empty_join, iterable)) + + +def safe_len(x): + try: + return len(x) + except: + return 1 + + +def lowered_range(num): + if num < 0: + return [-i for i in lowered_range(-num)] + return list(range(int(num))) + + +def min2(num): + return min(int(d) for d in str(num) if d in "0123456789") + + +def min3(x): + try: + return min(x) + except: + return x + + +def safe_int(x): + try: + return int(x) + except: + return str(x) + + +def two_power(n): + return 2**n + + +def is_prime(n): + i = int(n) + return int(i >= 2 and all(i % k for k in range(2, i))) + + +def slice1(num, lst): + return lst[:: int(num)] + + +def slice2(lst, num): + return lst[:: int(num)] + + +def not_equal(x, y): + return int(x != y) + + +def one_range(num): + if num < 0: + return [-i for i in one_range(-num)] + return list(range(1, int(num) + 1)) + + +def digit_sum(num): + return sum(int(d) for d in str(num) if d in "0123456789") + + +def it_sum(lst): + if not lst: + return 0 + if all(isinstance(item, (int, float)) for item in lst): + return sum(lst) + if all(isinstance(item, list) for item in lst): + return sum(lst[1:], lst[0]) + return "".join(map(str, lst)) + + +def uniquify_lst(lst): + r = [] + for i in lst: + if i not in r: + r.append(i) + return r + + +def uniquify_str(s): + r = "" + for c in s: + if c not in r: + r += c + return r + + +def uniquify_num(num): + return eval(uniquify_str(str(num))) + + +def indices_where_truthy(l): + return [i for i, x in enumerate(l) if x] + + +def indices_where_truthy_num(n): + return [i for i, x in enumerate(str(n)) if x in "123456789"] + + +def rot_13(s): + r = "" + for c in s: + if ord("A") <= ord(c.upper()) <= ord("M"): + r += chr(ord(c) + 13) + elif ord("N") <= ord(c.upper()) <= ord("Z"): + r += chr(ord(c) - 13) + else: + r += c + return r + + +def wrap(x): + return [x] + + +def zip2(l1, l2): + return list(map(list, zip(l2, l1))) + + +def range_zip1(n1, n2): + n1 = int(n1) + return zip2(one_range(n1), [n2] * abs(n1)) + + +def range_zip2(n, l): + return zip2(one_range(int(n)), l) + + +def range_zip3(l, n): + return zip2(l, one_range(int(n))) + + +def append(x, l): + return l + [x] + + +def safe_index(x, y, e=-1): + if y in x: + return x.index(y) + return e + + +def convert_from_base(base, num): + if base <= 0: + return num + elif base == 1: + return len(str(num)) + if base <= 64: + digits = string.digits + string.ascii_uppercase + string.ascii_lowercase + "+/" + else: + digits = codepage.CODEPAGE * math.ceil(base / 256) + return from_list_of_digits_2( + list(map((lambda c: safe_index(digits, c, 0)), str(num))), base + ) + + +def convert_from_custom_base(base, num): + return from_list_of_digits_2( + list(map((lambda c: safe_index(base, c, 0)), str(num))), len(base) + ) + + +def nCr(r, n): + n, r = int(n), int(r) + f = math.factorial + return f(n) // f(r) // f(n - r) + + +def string_count(x, y): + if isinstance(x, list): + return [string_count(i, y) for i in x] + return str(y).count(str(x)) + + +def list_count(x, y): + if isinstance(x, list): + return [list_count(i, y) for i in x] + return y.count(x) + + +def duplicate(x): + return x, x + + +def ten_power(n): + return 10**n + + +def comma_split(s): + return s.split(",") + + +def prime_factors(n): + n = int(n) + for i in range(2, n + 1): + if is_prime(i) and n % i == 0: + return [i] + prime_factors(n // i) + return [] + + +def case(s): + r = [] + for c in s: + if c.islower(): + r.append(0) + elif c.isupper(): + r.append(1) + else: + r.append(-1) + return r + + +def gcd(l): + l = [int(i) for i in l if isinstance(i, (int, float)) or str(i).isdigit()] + if not l: + return 0 + for x in reversed(range(1, max(l))): + if all(y % x == 0 for y in l): + return x + + +def digits_gcd(n): + return gcd([int(i) for i in str(n) if i in "0123456789"]) + + +def ords_gcd(s): + return gcd(list(map(ord, s))) + + +def head_extract(x): + if not x: + return x + return x[1:], x[0] + + +def num_head_extract(n): + r = () + for i in head_extract(str(n)): + try: + r += (eval(i),) + except: + r += (i,) + return r + + +def num_ind0(x, y): + s = str(y)[int(x) % len(str(y))] + try: + return int(s) + except: + return s + + +def length_ind0(x, y): + return indexing_0(len(str(x)), y) + + +def vectorised_ind0(x, y): + r = [] + for i in x: + try: + r.append(indexing_0(i, y)) + except: + r.append(length_ind0(i, y)) + return r + + +def increment(num): + return num + 1 + + +def decrement(num): + return num - 1 + + +def str_increment(s): + return "".join(chr(ord(c) + 1) for c in s) + + +def str_decrement(s): + return "".join(chr(ord(c) - 1) for c in s) + + +def join(joiner, iterable): + return str(joiner).join(map(str, iterable)) + + +def num_join(j, n): + return join(j, str(n)) + + +def num_length(n): + return len(str(n)) + + +def mean(lst): + l = [] + for i in lst: + try: + l.append(float(i)) + except: + pass + if not l: + return 0 + return sum(l) / len(l) + + +def num_mean(n): + return mean([int(i) for i in str(n) if i in "0123456789"]) + + +def ord_mean(s): + return mean(map(ord, s)) + + +def str_rmv(x, y): + return str(y).replace(str(x), "") + + +def num_rmv(x, y): + try: + return eval(str_rmv(x, y)) + except: + return str_rmv(x, y) + + +def list_rmv(x, y): + z = y.copy() + while x in z: + z.remove(x) + return z + + +def swapped_list_rmv(x, y): + return list_rmv(y, x) + + +def digit_product(num): + return math.prod([int(i) for i in str(num) if i in "0123456789"]) + + +def product(lst): + l = [] + for i in lst: + if isinstance(i, (int, float)): + l.append(i) + else: + try: + l.append(int(i)) + except: + try: + l.append(float(i)) + except: + pass + if not l: + return 1 + return math.prod(l) + + +def ord_product(s): + return math.prod(list(map(ord, s))) + + +def swapped_append(x, y): + return append(y, x) + + +def _digits(x): + if isinstance(x, (str, list)): + return list(x) + return [int(i) for i in str(x) if i in "0123456789"] + + +def append2(x, y): + return _digits(y) + [x] + + +def string_replace(x, y, z): + return str(z).replace(str(y), str(x)) + + +def list_replace(x, y, z): + return [x if i == y else i for i in z] + + +def digit_reverse(num): + r = str(num)[::-1] + try: + try: + return int(r) + except: + return eval(r) + except: + return r + + +def reverse(x): + return x[::-1] + + +def swap(a, b): + return a, b + + +def tail_extract(x): + if not x: + return x + return x[:-1], x[-1] + + +def num_tail_extract(n): + r = () + for i in tail_extract(str(n)): + try: + r += (eval(i),) + except: + r += (i,) + return r + + +def remove_whitespace(s): + return "".join(s.split()) + + +def uninterleave(l): + return [l[0::2], l[1::2]] + + +def num_uninterleave(n): + return uninterleave(_digits(n)) + + +def uninterleave_dump(l): + return l[0::2], l[1::2] + + +def num_uninterleave_dump(n): + return uninterleave_dump(_digits(n)) + + +def bool2(x): + return int(bool(x)) + + +def isalphanum(s): + return int(s.isalnum()) + + +def any2(l): + return int(any(l)) + + +def from_binary(x): + try: + return int(str(x), 2) + except: + return x + + +def add(x, y): + return y + x + + +def string_add(x, y): + return str(y) + str(x) + + +def subtract(x, y): + return y - x + + +def slice_start(s, n): + return s[n:] + + +def slice_end(n, s): + return s[:-n] + + +def strip(a, b): + return b.strip([a]) + + +def multiply(x, y): + if isinstance(x, (str, list)): + return x * int(y) + elif isinstance(y, (str, list)): + return int(x) * y + return y * x + + +def string_cartesian_product(a, b): + return ["".join(l) for l in itertools.product(b, a)] + + +def divide(x, y): + return y / x + + +def split2(a, b): + if a < 1: + return b + if not b: + return [b] * a + x, y = divmod(len(b), int(a)) + k = 0 + r = [] + while k < len(b): + r.append(b[k : k + x + (y > 0)]) + k += x + (y > 0) + if y > 0: + y -= 1 + return r + + +def split1(a, b): + return split2(b, a) + + +def split3(a, b): + return b.split(a) + + +def exponentiate(x, y): + return y**x + + +def append_first1(a, b): + if not a: + return " " * b + while len(a) < b: + a += a[0] + return a + + +def append_first2(a, b): + return append_first1(b, a) + + +def regex_findall(a, b): + return list(re.findall(a, b)) + + +def modulo(x, y): + return y % x + + +def str_format(a, b): + return str(b).replace("%", str(a)) + + +def swapped_format(a, b): + return str_format(b, a) + + +def integer_divide(x, y): + return int(y // x) + + +def first_split1(a, b): + s = split1(a, b) + if s: + return s[0] + return s + + +def first_split2(a, b): + s = split2(a, b) + if s: + return s[0] + return s + + +def first_split3(a, b): + s = split3(a, b) + if s: + return s[0] + return s + + +def slice_start2(n, s): + return s[n:] + + +def slice_end2(s, n): + return s[:-n] + + +def swapped_subtract(x, y): + return x - y + + +def strip2(a, b): + return a.strip(b) + + +def split4(a, b): + return a.split(b) + + +def swapped_divide(x, y): + return x / y + + +def swapped_integer_divide(x, y): + return int(x // y) + + +def last_split1(a, b): + s = split1(a, b) + if s: + return s[-1] + return s + + +def last_split2(a, b): + s = split2(a, b) + if s: + return s[-1] + return s + + +def last_split3(a, b): + s = split3(a, b) + if s: + return s[-1] + return s + + +def str_format2(a, b): + return str(a).replace("%", str(b)) + + +def swapped_modulo(x, y): + return x % y + + +def swapped_exponentiate(x, y): + return x**y + + +def prepend_last1(a, b): + if not a: + return " " * b + while len(a) < b: + a = a[-1] + a + return a + + +def prepend_last2(a, b): + return append_first1(b, a) + + +def swapped_regex_findall(a, b): + return list(re.findall(b, a)) + + +def equals(x, y): + return int(y == x) + + +def less_than(x, y): + return int(y < x) + + +def ord_less_than1(n, s): + return [int(ord(x) < n) for x in s] + + +def ord_less_than2(s, n): + return [int(n < ord(x)) for x in s] + + +def greater_than(x, y): + return int(y > x) + + +def ord_greater_than1(n, s): + return [int(ord(x) > n) for x in s] + + +def ord_greater_than2(s, n): + return [int(n > ord(x)) for x in s] + + +def less_than_or_equal_to(x, y): + return int(y <= x) + + +def ord_less_than_or_equal_to1(n, s): + return [int(ord(x) <= n) for x in s] + + +def ord_less_than_or_equal_to2(s, n): + return [int(n <= ord(x)) for x in s] + + +def greater_than_or_equal_to(x, y): + return int(y >= x) + + +def ord_greater_than_or_equal_to1(n, s): + return [int(ord(x) >= n) for x in s] + + +def ord_greater_than_or_equal_to2(s, n): + return [int(n >= ord(x)) for x in s] + + +def logical_and(x, y): + return y and x + + +def logical_or(x, y): + return y or x + + +def logical_xor(x, y): + return int(bool(y) ^ bool(x)) + + +def logical_not(x): + return int(not x) + + +def pair(x, y): + return [y, x] + + +def is_divisible(x, y): + try: + return int(y % x == 0) + except: + return 0 + + +def length_divisible1(s, n): + return is_divisible(len(s), n) + + +def length_divisible2(n, s): + return length_divisible1(s, n) + + +def length_divisible3(a, b): + return is_divisible(len(a), len(b)) + + +def zero_enumerate(l): + return list(map(list, enumerate(l))) + + +def inclusive_zero_range(n): + if n >= 0: + return list(range(int(n) + 1)) + return [-i for i in range(abs(int(n)) + 1)] + + +def recursive_flatten(x): + if isinstance(x, list): + r = [] + for i in x: + a = recursive_flatten(i) + if isinstance(a, list): + r += a + else: + r += (a,) + return r + return x + + +def dyadic_gcd(a, b): + try: + return math.gcd(abs(int(a)), abs(int(b))) + except: + return 1 + + +def ordinal_gcd1(a, b): + return [dyadic_gcd(ord(c), b) for c in a] + + +def ordinal_gcd2(a, b): + return ordinal_gcd1(b, a) + + +def longest_common_substring(x, y): + a, b = substrings(x), substrings(y) + try: + return max([i for i in a if i in b], key=len) + except: + return "" + + +def num_head(x): + return int(str(x)[0]) + + +def head(x): + if not x: + return x + return x[0] + + +def num_tail(x): + return int(str(x)[-1]) + + +def tail(x): + if not x: + return x + return x[-1] + + +def num_ind1(x, y): + s = str(y)[~-int(x) % len(str(y))] + try: + return int(s) + except: + return s + + +def indexing_1(num, lst): + if not lst: + return lst + return lst[~-int(num) % len(lst)] + + +def swapped_ind1(lst, num): + if not lst: + return lst + return lst[~-int(num) % len(lst)] + + +def length_ind1(x, y): + return indexing_1(len(str(x)), y) + + +def vectorised_ind1(x, y): + r = [] + for i in x: + try: + r.append(indexing_1(i, y)) + except: + r.append(length_ind1(i, y)) + return r + + +def ljust1(x, n, y): + return str(y).ljust(abs(int(n)) or 1, (str(x) + " ")[0]) + + +def ljust2(n, x, y): + return str(y).ljust(abs(int(n)) or 1, (str(x) + " ")[0]) + + +def ljust3(x, y, z): + return str(z).ljust(len(y) or 1, (str(x) + " ")[0]) + + +def mode(it): + if not it: + return it + return max(it, key=it.count) + + +def num_mode(n): + return mode(digits(n)) + + +def negate(x): + return -x + + +def rle(s): + l = "" + r = [] + for c in s: + if c == l: + r[-1] += 1 + else: + r.append(1) + l = c + return r + + +def index_of(x, y): + if isinstance(y, str): + x = str(x) + if x in y: + return y.index(x) + return -1 + + +def swapped_index_of(x, y): + return index_of(y, x) + + +def num_index_of(x, y): + return index_of(x, digits(y)) + + +def vectorised_index_of(x, y): + r = [] + for i in x: + if isinstance(y, (str, list)): + r.append(index_of(i, y)) + else: + r.append(num_index_of(i, y)) + return r + + +def cartesian_product(x, y): + return list(map(list, itertools.product(y, x))) + + +def range_product1(n, y): + return cartesian_product(list(one_range(n)), y) + + +def range_product2(x, n): + return range_product1(n, x) + + +def range_product3(x, y): + return cartesian_product(list(one_range(x)), list(one_range(y))) + + +def first_char_not_present(s, avoid=()): + i = 0 + while 1: + if chr(i) in avoid: + continue + if chr(i) not in s: + return chr(i) + i += 1 + + +def recursive_replace(x, y, z): + while y in z: + z = z.replace(y, x) + return z + + +def string_repr(s): + r = repr(s) + if r[0] == '"': + return r + f = first_char_not_present(r, "\\'\"") + return ( + '"' + + recursive_replace(f, "\\\\", r[1:-1]) + .replace("\\'", "'") + .replace('"', '\\"') + .replace(f, "\\\\") + + '"' + ) + + +def list_repr(l): + x = [] + for i in l: + if isinstance(i, list): + x.append(list_repr(i)) + elif isinstance(i, str): + x.append(string_repr(i)) + else: + x.append(str(i)) + return "[" + ", ".join(x) + "]" + + +def sort(l): + return list(sorted(l)) + + +def digits_sort(n): + return eval("".join(str_sort(map(str, digits(n))))) + + +def str_sort(s): + return "".join(sort(s)) + + +def chunk1(x, y): + return split2(x, one_range(y)) + + +def chunk2(x, y): + return split2(len(x), y) + + +def zip_self(l): + return zip2(l, l) + + +def num_zip_self(n): + return zip_self(one_range(n)) + + +def triplicate(x): + return x, x, x + + +def assign(c, b, a): + if not a: + return a + if isinstance(a, list): + a[int(b) % len(a)] = c + return a + else: + a = list(a) + a[b % len(a)] = c + return "".join(map(str, a)) + + +def swapped_assign(c, a, b): + return assign(c, b, a) + + +def length_assign(c, b, a): + return assign(c, len(b), a) + + +def num_assign(c, b, a): + return assign(c, b, digits(a)) + + +def vectorised_assign(c, b, a): + for i in b: + if isinstance(i, (str, list)): + a = length_assign(c, i, a) + else: + a = assign(c, i, a) + return a + + +def to_binary(n): + if n < 0: + return "-" + to_binary(abs(n)) + return bin(int(n))[2:] + + +def ord_bin(s): + return [to_binary(ord(c)) for c in s] + + +def combinations1(n, x): + if n > len(x): + n = len(x) + if n < 1: + n = 1 + return list(map(list, itertools.combinations(x, n))) + + +def combinations2(x, n): + return combinations1(n, x) + + +def combinations3(x, y): + return combinations1(x, one_range(y)) + + +def set_union(x, y): + r = [] + for i in y: + if i not in r: + r.append(i) + for j in x: + if j not in r: + r.append(j) + return r + + +def from_list_of_digits(b, n): + return from_list_of_digits_2(n, int(b)) + + +def divmod2(x, y): + return list(divmod(y, x)) + + +def length_range(x): + return one_range(len(x)) + + +def exclusive_one_range(n): + return one_range(n)[:-1] + + +def prime_factor_exponents(n): + p = prime_factors(n) + r = [] + for i in range(n + 1): + if is_prime(i): + r.append(p.count(i)) + x = r[::-1] + for k, j in enumerate(x): + if j: + return x[k:][::-1] + return [] + + +def group_consecutive(l): + last = None + r = [] + for i in l: + if i != last: + r.append([i]) + else: + r[-1].append(i) + last = i + if isinstance(l, str): + return [*map("".join, r)] + return r + + +def consecutive_digits(n): + return group_consecutive(digits(n)) + + +def num_head_remove(x): + return int(str(x)[1:]) + + +def head_remove(x): + if not x: + return x + return x[1:] + + +def lcm(l): + l = [int(i) for i in l if isinstance(i, (int, float)) or str(i).isdigit()] + if not l: + return 0 + n = 1 + while 1: + if all(n % j == 0 for j in l): + return n + n += 1 + + +def digits_lcm(n): + return lcm([int(i) for i in str(n) if i in "0123456789"]) + + +def ords_lcm(s): + return lcm(list(map(ord, s))) + + +def median(lst): + l = [] + for i in lst: + if isinstance(i, (int, float)): + l.append(i) + else: + try: + l.append(int(i)) + except: + try: + l.append(float(i)) + except: + pass + if not l: + return [] + if len(l) % 2: + return sorted(l)[len(l) // 2] + s = sorted(l)[len(l) // 2 - 1 : len(l) // 2 + 1] + return mean(s) + + +def num_median(n): + return median(digits(n)) + + +def ord_median(s): + return median(list(map(ord, s))) + + +def round_decimal_places(a, b): + return round(b, int(a)) + + +def range_intersection1(a, b): + return [i for i in b if i in one_range(a)] + + +def range_intersection2(a, b): + return [i for i in one_range(b) if i in a] + + +def set_intersection(a, b): + return [i for i in b if i in a] + + +def permutations1(n, x): + if n > len(x): + n = len(x) + if n < 1: + n = 1 + return list(map(list, itertools.permutations(x, n))) + + +def permutations2(x, n): + return permutations1(n, x) + + +def permutations3(x, y): + return permutations1(x, one_range(y)) + + +def set_difference(x, y): + r = [] + for i in y: + if i not in r: + if i not in x: + r.append(i) + return r + + +def rjust1(x, n, y): + return str(y).rjust(abs(int(n)) or 1, (str(x) + " ")[0]) + + +def rjust2(n, x, y): + return str(y).rjust(abs(int(n)) or 1, (str(x) + " ")[0]) + + +def rjust3(x, y, z): + return str(z).rjust(len(y) or 1, (str(x) + " ")[0]) + + +def prefixes(l): + r = [] + for i in range(1, len(l) + 1): + r.append(l[:i]) + return r + + +def cumsum(l): + if any(not isinstance(i, (int, float)) for i in l): + if not all(isinstance(j, list) for j in l): + l = [*map(str, l)] + if not l: + return [] + r = [] + for i in range(1, len(l) + 1): + r.append(it_sum(l[:i])) + return r + + +def numcumsum(n): + return cumsum(digits(n)) + + +def num_tail_remove(x): + return int(str(x)[:-1]) + + +def tail_remove(x): + if not x: + return x + return x[:-1] + + +def chunk3(n, l): + x, y = len(l), abs(int(n)) + return list(filter(bool, [l[i : i + y] for i in range(0, (x // y + 1) * y, y)])) + + +def chunk4(l, n): + return chunk3(n, l) + + +def chunk5(x, y): + return chunk3(x, one_range(y)) + + +def chunk6(x, y): + return chunk3(len(x), y) + + +def length_range_no_pop(l): + return (l, one_range(len(l))) + + +def num_length_range(n): + return n, one_range(len(str(n))) + + +def length_range_0(l): + return (l, lowered_range(len(l))) + + +def num_length_range_0(n): + return n, lowered_range(len(str(n))) + + +def character_multiply1(s, n): + return "".join(c * n for c in s) + + +def character_multiply2(n, s): + return character_multiply1(s, n) + + +def regex_split(x, y): + return re.split(x, y) + + +def double(x): + return x * 2 + + +def exactly_not_equal(x, y): + return int(y != x) + + +def to_hex(n): + if n < 0: + return "-" + to_hex(abs(n)) + return hex(int(n))[2:] + + +def ord_hex(s): + return [to_hex(ord(c)) for c in s] + + +def reciprocal(n): + return 1 / n + + +def remove_non_alphabets(s): + return "".join(c for c in s if c.isalpha()) + + +def num_bifurcate(n): + return n, digit_reverse(n) + + +def bifurcate(x): + return x, reverse(x) + + +def fallback_lcm(a, b): + x, y = abs(int(a)), abs(int(b)) + return (x * y) // dyadic_gcd(x, y) + + +def dyadic_lcm(a, b): + try: + return math.lcm(abs(int(a)), abs(int(b))) + except: + try: + return fallback_lcm(a, b) + except: + return 1 + + +def ordinal_lcm1(a, b): + return [dyadic_lcm(ord(c), b) for c in a] + + +def ordinal_lcm2(a, b): + return ordinal_lcm1(b, a) + + +def ordinal_lcm3(a, b): + return [dyadic_lcm(ord(x), ord(y)) for x, y in zip(a, b)] + + +def num_mirror(n): + r = str(n) + str(n)[::-1] + try: + return eval(r) + except: + return r + + +def mirror(x): + return x + x[::-1] + + +def str_transliterate(a, b, c): + r = "" + d = dict(zip(map(str, b), map(str, a))) + for x in str(c): + r += str(d.get(x, x)) + return r + + +def list_transliterate(a, b, c): + r = [] + d = dict(zip(b, a)) + for x in c: + r.append(d.get(x, x)) + return r + + +def str_transliterate_overload_1(a, b, c): + r = "" + d = dict(zip(str(b), map(str, a))) + for x in str(c): + r += str(d.get(x, x)) + return r + + +def list_transliterate_overload_1(a, b, c): + r = [] + d = dict(zip(str(b), a)) + for x in c: + r.append(d.get(x, x)) + return r + + +def str_transliterate_overload_2(a, b, c): + r = "" + d = dict(zip(map(str, b), str(a))) + for x in str(c): + r += str(d.get(x, x)) + return r + + +def list_transliterate_overload_2(a, b, c): + r = [] + d = dict(zip(b, str(a))) + for x in c: + r.append(d.get(x, x)) + return r + + +def str_transliterate_overload_3(a, b, c): + r = "" + d = dict(zip(str(b), str(a))) + for x in str(c): + r += str(d.get(x, x)) + return r + + +def list_transliterate_overload_3(a, b, c): + r = [] + d = dict(zip(str(b), str(a))) + for x in c: + r.append(d.get(x, x)) + return r + + +def combinations_with_replacement1(n, x): + if n > len(x): + n = len(x) + if n < 1: + n = 1 + return list(map(list, itertools.combinations_with_replacement(x, n))) + + +def combinations_with_replacement2(x, n): + return combinations_with_replacement1(n, x) + + +def combinations_with_replacement3(x, y): + return combinations_with_replacement1(x, one_range(y)) + + +def combinations_with_replacement4(x, y): + return combinations_with_replacement1(len(x), y) + + +def square(n): + return n**2 + + +def chunk_wrap_2(s): + return chunk3(2, s) + + +def cube(n): + return n**3 + + +def chunk_wrap_3(s): + return chunk3(3, s) + + +def fourth(n): + return n**4 + + +def chunk_wrap_4(s): + return chunk3(4, s) + + +def fifth(n): + return n**5 + + +def chunk_wrap_5(s): + return chunk3(5, s) + + +def halve(n): + if n % 2 == 0: + return n // 2 + return n / 2 + + +def chunk_halve(s): + return split1(s, 2) + + +def deltas(lst): + l = [] + for i in lst: + if isinstance(i, (int, float)): + l.append(i) + else: + try: + l.append(int(i)) + except: + try: + l.append(float(i)) + except: + pass + if not l: + return [] + r = [] + for x, y in zip(l, l[1:]): + r.append(y - x) + return r + + +def digit_deltas(n): + return deltas(digits(n)) + + +def ord_deltas(s): + return deltas(list(map(ord, s))) + + +def digits_wrap(n): + return [digits(n)] + + +def list_wrap(s): + return [[*s]] + + +def transpose(lst): + l = [] + for i in lst: + if isinstance(i, (list, str)): + l.append(list(i)) + elif isinstance(i, (int, float)): + l.append(digits(i)) + return list(map(list, zip(*l))) + + +def rotate_left(n, l): + if not l: + return l + rot = int(n) % len(l) + return l[rot:] + l[:rot] + + +def rotate_right(n, l): + if not l: + return l + rot = int(n) % len(l) + return l[-rot:] + l[:-rot] + + +def swapped_rotate_left(l, n): + return rotate_left(n, l) + + +def swapped_rotate_right(l, n): + return rotate_right(n, l) + + +def len_rotate_left(x, y): + return rotate_left(len(x), y) + + +def len_rotate_right(x, y): + return rotate_right(len(x), y) + + +def num_rotate_left(n, x): + r = rotate_left(n, str(x)) + try: + return eval(r) + except: + return r + + +def num_rotate_right(n, x): + r = rotate_right(n, str(x)) + try: + return eval(r) + except: + return r + + +def rotate_left_once(l): + return rotate_left(1, l) + + +def rotate_right_once(l): + return rotate_right(1, l) + + +def num_rotate_left_once(l): + return num_rotate_left(1, l) + + +def num_rotate_right_once(l): + return num_rotate_right(1, l) + + +def left_bit_shift(x, y): + if x < 0: + return right_bit_shift(-x, y) + return int(y) << int(x) + + +def right_bit_shift(x, y): + if x < 0: + return left_bit_shift(-x, y) + return int(y) >> int(x) + + +def uninterleave2(n, l): + if not n: + return l + return [l[i::n] if i < len(l) else l * 0 for i in range(abs(int(n)))] + + +def num_uninterleave2(x, y): + return uninterleave2(x, digits(y)) + + +def swapped_uninterleave(l, n): + return uninterleave2(n, l) + + +def len_uninterleave(x, y): + return uninterleave2(len(x), y) + + +def num_to_alphabet(n): + return chr(64 + (int(n) % 26)) + + +def alphabet_to_num(s): + return [ + ord(c) - 64 if "A" <= c <= "Z" else (ord(c) - 96 if "a" <= c <= "z" else 0) + for c in s + ] + + +def nPr(r, n): + n, r = int(n), int(r) + f = math.factorial + return f(n) // f(n - r) + + +def string_contains(x, y): + if isinstance(x, list): + return [string_contains(i, y) for i in x] + return int(str(x) in str(y)) + + +def list_contains(x, y): + if isinstance(x, list): + return [list_contains(i, y) for i in x] + return int(x in y) + + +def list_remove_at_index(n, l): + if not l: + return l + x = l.copy() + x.pop(int(n) % len(x)) + return x + + +def str_remove_at_index(n, s): + return "".join(list_remove_at_index(n, [*str(s)])) + + +def swapped_list_remove_at_index(l, n): + return list_remove_at_index(n, l) + + +def swapped_str_remove_at_index(s, n): + return str_remove_at_index(n, s) + + +def unique_prime_factors(n): + return uniquify_lst(prime_factors(n)) + + +def palindromise(l): + return l + l[:-1][::-1] + + +def num_palindromise(n): + s = palindromise(str(n)) + try: + return eval(s) + except: + return s + + +def recurse_integer_partitions(n, m=1): + for i in range(m, n // 2 + 1): + for part in recurse_integer_partitions(n - i, i): + yield part + [i] + yield [n] + + +def integer_partitions(n): + n = int(n) + l = [*recurse_integer_partitions(abs(n))] + if n < 0: + return [[-i for i in sl] for sl in l] + return l + + +def newline_join(iterable): + if not isinstance(iterable, list): + return str(iterable) + return "\n".join(map(empty_join, iterable)) + + +def space_join(iterable): + if not isinstance(iterable, list): + return str(iterable) + return " ".join(map(empty_join, iterable)) + + +def prepend(x, l): + return [x] + l + + +def swapped_prepend(l, x): + return prepend(x, l) + + +def prepend2(x, y): + return [x] + _digits(y) + + +def transpose_with_filler(f, l): + matrix = [[*x] if isinstance(x, (list, str)) else digits(x) for x in l] + transposed = itertools.zip_longest(*matrix, fillvalue=f) + return list(map(list, transposed)) + + +def swapped_transpose_with_filler(l, f): + return transpose_with_filler(f, l) + + +def digits_wrap_2(x, y): + return y, digits_wrap(x) + + +def list_wrap_2(x, y): + return y, list_wrap(x) + + +def pop_(*_): + return () + + +def boolify(x): + return int(bool(x)) + + +def counts(l): + r = [] + for i in uniquify_lst(l): + r.append([i, l.count(i)]) + return r + + +def num_counts(n): + return counts(digits(n)) + + +def parity(n): + return n % 2 + + +def second_half(s): + return chunk_halve(s)[-1] + + +def num_prefixes(n): + return prefixes(digits(n)) + + +def increment_twice(n): + return n + 2 + + +def grade_up(l): + return [*map(lambda x: x[0], sorted(enumerate(l[:]), key=lambda x: x[-1]))] + + +def head_slice(n, l): + return l[:n] + + +def num_head_slice(x, y): + s = head_slice(x, str(y)) + try: + return eval(s) + except: + return s + + +def swapped_head_slice(l, n): + return head_slice(n, l) + + +def len_head_slice(x, y): + return head_slice(len(x), y) + + +def tail_slice(n, l): + return l[-n:] + + +def num_tail_slice(x, y): + s = tail_slice(x, str(y)) + try: + return eval(s) + except: + return s + + +def swapped_tail_slice(l, n): + return tail_slice(n, l) + + +def len_tail_slice(x, y): + return tail_slice(len(x), y) + + +def powerset(l): + r = [l * 0] + p = [[]] + for i in l: + n = [x + [i] for x in p] + p += [s[:] for s in n] + for j in n: + r.append(j if not isinstance(l, str) else "".join(j)) + return r + + +def num_powerset(n): + return powerset(one_range(n)) + + +def randint(n): + if n == 0: + return 0 + return random.choice(one_range(n)) + + +def randchoice(l): + if not l: + return l + return random.choice(l) + + +def square_root(i): + n = abs(i) + x = math.sqrt(n) + try: + y = math.isqrt(n) + if x == y: + return y + return x + except: + return x + + +def every_second_item(s): + return s[::2] + + +def sign(n): + if n < 0: + return -1 + elif n > 0: + return 1 + else: + return 0 + + +def sentence_case(s): + r = "" + b = True + for c in s: + if b: + r += c.upper() + else: + r += c.lower() + if c in "?!.": + b = True + elif c == " " and b == True: + pass + else: + b = False + return r + + +def sum_each(l): + r = [] + for i in l: + if isinstance(i, (list, str)): + r.append(it_sum(i)) + else: + r.append(digit_sum(i)) + return r + + +def all_equal(l): + return int(len(uniquify_lst(l)) <= 1) + + +def num_all_equal(n): + return all_equal(str(n)) + + +def symmetric_set_difference(x, y): + r = uniquify_lst([i for i in y if i not in x] + [j for j in x if j not in y]) + if (type(x), type(y)) == (str, str): + return "".join(r) + return r + + +def range_ssd1(x, y): + return symmetric_set_difference(digits(x), digits(y)) + + +def range_ssd2(n, x): + if isinstance(x, str): + return symmetric_set_difference(str(n), x) + return symmetric_set_difference(digits(n), x) + + +def range_ssd3(x, n): + if isinstance(x, str): + return symmetric_set_difference(x, str(n)) + return symmetric_set_difference(x, digits(n)) + + +def equals_one(x): + return int(x == 1) + + +def enclose(l): + return l + l[:1] + + +def num_enclose(n): + s = enclose(str(n)) + try: + return eval(s) + except: + return s + + +def add_digits1(l, x): + return _digits(x) + l + + +def add_digits2(x, l): + return l + _digits(x) + + +def add_digits3(x, y): + return _digits(y) + _digits(x) + + +def corresponding_filter(x, y): + r = [] + for i, j in zip(y, x): + if j: + r.append(i) + if isinstance(y, str): + return "".join(r) + return r + + +def corresponding_digit_filter_1(x, y): + return corresponding_filter(digits(x), digits(y)) + + +def corresponding_digit_filter_2(n, l): + return corresponding_filter(digits(n), l) + + +def corresponding_digit_filter_3(l, n): + return corresponding_filter(l, digits(n)) + + +def list_sort_uniquify(l): + return sort(uniquify_lst(l)) + + +def str_sort_uniquify(s): + return str_sort(uniquify_str(s)) + + +def num_sort_uniquify(n): + return list_sort_uniquify(digits(n)) + + +def to_roman_numerals(num): + ret = "" + if num < 0: + num = -num + ret += "-" + symbols = { + "M": 1000, + "CM": 900, + "D": 500, + "CD": 400, + "C": 100, + "XC": 90, + "L": 50, + "XL": 40, + "X": 10, + "IX": 9, + "V": 5, + "IV": 4, + "I": 1, + } + for s, n in symbols.items(): + while num >= n: + ret += s + num -= n + return ret + + +def from_roman_numerals(s): + ret = 0 + i = 0 + while i < len(s): + c = s[i] + if c == "M": + ret += 1000 + elif c == "D": + ret += 500 + elif c == "L": + ret += 50 + elif c == "V": + ret += 5 + elif c == "C": + i += 1 + if s[i] == "M": + ret += 900 + else: + ret += 100 + i -= 1 + elif c == "X": + i += 1 + if s[i] == "C": + ret += 90 + else: + ret += 10 + i -= 1 + elif c == "I": + i += 1 + if s[i] == "X": + ret += 9 + else: + ret += 1 + i -= 1 + i += 1 + return ret + + +def length_of_each(l): + r = [] + for i in l: + if isinstance(i, (int, float)): + r.append(len(str(i))) + else: + r.append(len(i)) + return r + + +def complement(n): + return 1 - n + + +def is_vowel(s): + return [int(c.lower() in "aeiou") for c in s] + + +def islower(s): + if not s: + return 1 + return int(s.islower()) + + +def cmp(x, y): + return sign(y - x) + + +def zfill1(n, s): + if n < 0: + return zfill1(abs(n), s[::-1])[::-1] + return s.zfill(n) + + +def zfill2(s, n): + return zfill1(n, s) + + +def surround(x, y): + return x + y + x + + +def digits_repeat1(n, x): + return _digits(x) * int(n) + + +def digits_repeat2(x, n): + return digits_repeat1(n, x) + + +def length_repeat1(x, y): + if isinstance(y, (int, float)): + y = str(y) + return x * len(y) + + +def length_repeat2(x, y): + if isinstance(x, (int, float)): + y = str(x) + return _digits(y) * len(x) + + +def shuffle(l): + return random.sample(l, len(l)) + + +def str_shuffle(s): + return "".join(shuffle(s)) + + +def range_shuffle(n): + return shuffle(one_range(n)) + + +def spaces(n): + return int(n) * " " + + +def suffixes(l): + r = [] + for i in range(1, len(l) + 1): + r.append(l[-i:]) + return r + + +def triple_swap(a, b, c): + return a, c, b + + +def cartesian_power(n, l): + return list(map(list, itertools.product(*[l] * abs(int(n))))) + + +def swapped_cartesian_power(l, n): + return cartesian_power(n, l) + + +def range_cartesian_power(x, y): + return cartesian_power(x, one_range(y)) + + +def head_remove_2(n, l): + return l[n:] + + +def num_head_remove_2(x, y): + s = head_remove_2(x, str(y)) + try: + return eval(s) + except: + return s + + +def swapped_head_remove_2(l, n): + return head_remove_2(n, l) + + +def len_head_remove_2(x, y): + return head_remove_2(len(x), y) + + +def tail_remove_2(n, l): + return l[:-n] + + +def num_tail_remove_2(x, y): + s = tail_remove_2(x, str(y)) + try: + return eval(s) + except: + return s + + +def swapped_tail_remove_2(l, n): + return tail_remove_2(n, l) + + +def len_tail_remove_2(x, y): + return tail_remove_2(len(x), y) + + +def reverse_each(l): + r = [] + for i in l: + if isinstance(i, (str, list)): + r.append(i[::-1]) + else: + s = str(i)[::-1] + try: + r.append(eval(s)) + except: + r.append(s) + return r + + +def listify(x): + if isinstance(x, (list, str)): + return list(copy.deepcopy(x)) + return one_range(x) + + +def replace_with_nothing(x, y): + return y.replace(x, "") + + +def replace_with_nothing2(x, y): + return x.replace(y, "") + + +def factorial(n): + if n < 1: + return 1 + return math.factorial(int(n)) + + +def all_slices(s): + if not s: + return [[]] + r = [] + for i in one_range(len(s)): + for x in all_slices(s[i:]): + r.append([s[:i]] + x) + return r + + +def dump(x): + return tuple(x) + + +def num_dump(n): + return dump(digits(n)) + + +def centre_list(x): + l = [*map(str, x)] + if not l: + return "" + max_len = safe_max_len(l) + return newline_join([*map(lambda s, m=max_len: s.center(m), l)]) + + +@convert_all_to_string +def brackets_are_balanced(s): + brackets = dict(chunk_wrap_2("()[]{}<>")) + l = [] + for c in s: + if c in brackets.keys(): + l.append(brackets[c]) + elif c in brackets.values(): + if not l: + return 0 + if l[-1] == c: + l = tail_remove(l) + else: + return 0 + return logical_not(len(l)) + + +@try_int_conversion +def nth_fibonacci_number(n): + if n <= 0: + return 0 + a = 0 + b = 1 + while n > 1: + a, b = b, a + b + n -= 1 + return b + + +@try_float_conversion +def cosine(n): + return math.cos(n) + + +@try_float_conversion +def sine(n): + return math.sin(n) + + +@try_float_conversion +def tangent(n): + return math.tan(n) + + +@try_float_conversion +def arc_cosine(n): + return math.acos(n) + + +@try_float_conversion +def arc_sine(n): + return math.asin(n) + + +@try_float_conversion +def arc_tangent(n): + return math.atan(n) + + +@try_float_conversion +def degrees(n): + return math.degrees(n) + + +@try_float_conversion +def radians(n): + return math.radians(n) + + +@try_float_conversion +def exponent(n): + return math.exp(n) + + +@try_int_conversion +def nth_prime(n): + if n < 0: + n = abs(n) + i = 2 + while n: + i += 1 + if is_prime(i): + n -= 1 + return i + + +def main_diagonal(lst): + l = [*map(_digits, lst)] + if not l: + return [] + r = [] + for i in range(min(len(l), min(map(len, l)))): + r.append(l[i][i]) + return r + + +def anti_diagonal(lst): + l = [*map(_digits, lst)] + if not l: + return [] + r = [] + m = min(len(l), min(map(len, l))) + for i in range(m): + r.append(l[i][m - i - 1]) + return r + + +def dot_product(x, y): + r = [] + for i, j in zip(x, y): + try: + r.append(i * j) + except: + pass + return it_sum(r) + + +def all_diagonals(lst): + l = [*map(_digits, lst)] + if not l: + return [] + r = [[] for _ in range(len(l) + min(map(len, l)) - 1)] + for i, x in enumerate(l): + for j in range(min(map(len, l))): + r[(j - i) % len(r)].append(x[j]) + return r + + +def all_anti_diagonals(lst): + l = [*map(_digits, lst)] + if not l: + return [] + r = [[] for _ in range(len(l) + min(map(len, l)) - 1)] + for i, x in enumerate(l): + for j in range(min(map(len, l))): + r[((-i) - j + min(len(l), min(map(len, l))) - 1) % len(r)].append(x[j]) + return r + + +def longest(l): + if not l: + return [] + return max(l, key=lambda x: len(_digits(x))) + + +def shortest(l): + if not l: + return [] + return min(l, key=lambda x: len(_digits(x))) + + +def dyadic_maximum(x, y): + return max(y, x) + + +def dyadic_minimum(x, y): + return min(y, x) + + +def string_dyadic_maximum(x, y): + return x if str(x) > str(y) else y + + +def string_dyadic_minimum(x, y): + return x if str(x) < str(y) else y + + +@try_int_conversion +def bitwise_and(x, y): + return y & x + + +@try_int_conversion +def bitwise_or(x, y): + return y | x + + +@try_int_conversion +def bitwise_xor(x, y): + return y ^ x + + +@try_int_conversion +def bitwise_not(x): + return ~x + + +def depth(lst, curr=0): + if isinstance(lst, list): + if not lst: + return curr + 1 + return max(depth(i, curr + 1) for i in lst) + return curr + + +def type_of(x): + if isinstance(x, int): + return 0 + if isinstance(x, float): + return 1 + if isinstance(x, str): + return 2 + if isinstance(x, list): + return 3 + return -1 + + +@try_float_conversion +def hypotenuse(a, b): + return math.sqrt(a**2 + b**2) + + +def extend_truncate(x, y): + x = abs(int(x)) + if x == 0: + return y * 0 + if not y: + return y + i = 0 + l = len(y) + while x > len(y): + y += y[(i % l) : (i % l) + 1] + i += 1 + while x < len(y): + y = y[:-1] + return y + + +def swapped_extend_truncate(y, x): + return extend_truncate(x, y) + + +def length_extend_truncate(x, y): + return extend_truncate(len(x), y) + + +def num_extend_truncate(x, y): + r = extend_truncate(x, str(y)) + try: + return eval(r) + except: + return r + + +@try_float_conversion +def insignificant(x): + return int(abs(x) <= 1) + + +def left_trim(x, l): + r = l * 0 + for i, j in enumerate(l): + if j != x: + r = l[i:] + break + return r + + +def right_trim(x, l): + return left_trim(x, l[::-1])[::-1] + + +def trim(x, l): + return right_trim(x, left_trim(x, l)) + + +def swapped_left_trim(l, x): + return left_trim(x, l) + + +def swapped_right_trim(l, x): + return right_trim(x, l) + + +def swapped_trim(l, x): + return trim(x, l) + + +def str_left_trim(x, y): + return str(y).lstrip(str(x)) + + +def str_right_trim(x, y): + return str(y).rstrip(str(x)) + + +def str_trim(x, y): + return str(y).strip(str(x)) + + +def vectorised_left_trim(x, l): + r = l * 0 + for i, j in enumerate(l): + if j not in x: + r = l[i:] + break + return r + + +def vectorised_right_trim(x, l): + return vectorised_left_trim(x, l[::-1])[::-1] + + +def vectorised_trim(x, l): + return vectorised_right_trim(x, vectorised_left_trim(x, l)) + + +def connected_uniquify(l): + return [x[0] for x in group_consecutive(l)] + + +def str_connected_uniquify(s): + return "".join(connected_uniquify(s)) + + +def num_connected_uniquify(n): + return eval(str_connected_uniquify(str(n))) + + +def str_starts_with(x, y): + return int(str(y).startswith(str(x))) + + +def str_ends_with(x, y): + return int(str(y).endswith(str(x))) + + +def canvas_draw(dirs, text): + l = [] + for i in dirs: + try: + j = int(i) + if 0 <= j <= 7: + l.append(j) + except: + pass + canvas.canvas.draw(text, length_extend_truncate(text, l or [2])) + return str(canvas.canvas) + + +def digits_canvas_draw(n, s): + return canvas_draw(digits(n), s) + + +def swapped_canvas_draw(text, dirs): + return canvas_draw(dirs, text) + + +def swapped_digits_canvas_draw(s, n): + return digits_canvas_draw(n, s) + + +def blank_canvas_draw(dirs, text): + l = [] + for i in dirs: + try: + j = int(i) + if 0 <= j <= 7: + l.append(j) + except: + pass + temp_canvas = canvas.Canvas() + temp_canvas.draw(text, length_extend_truncate(text, l or [2])) + return str(temp_canvas) + + +def blank_digits_canvas_draw(n, s): + return blank_canvas_draw(digits(n), s) + + +def blank_swapped_canvas_draw(text, dirs): + return blank_canvas_draw(dirs, text) + + +def blank_swapped_digits_canvas_draw(s, n): + return blank_digits_canvas_draw(n, s) + + +def clear_canvas(): + canvas.canvas.clear() + return () + + +def multidimensional_index(x, l): + for i, j in enumerate(l): + if j == x: + return [i] + elif isinstance(j, list): + r = multidimensional_index(x, j) + if r: + return [i] + r + return [] + + +def swapped_multidimensional_index(l, x): + return multidimensional_index(x, l) + + +def vectorised_multidimensional_index(x, l): + if not isinstance(x, list): + return multidimensional_index(x, l) + return [*map(lambda i, y=l: vectorised_multidimensional_index(i, y), x)] + + +def absolute_difference(a, b): + return abs(b - a) + + +@try_float_conversion +def logarithm(a, b): + return math.log(b, a) + + +@try_float_conversion +def log10(a): + return math.log10(a) + + +@try_float_conversion +def ln(a): + return math.log(a) + + +@try_float_conversion +def log2(a): + return math.log2(a) + + +def split_on(x, l): + if isinstance(l, str): + x = str(x) + r = [l * 0] + for i in l: + if i == x: + r.append(l * 0) + else: + r[-1] += [i] if isinstance(l, list) else i + return r + + +def num_split_on(x, y): + return split_on(x, _digits(y)) + + +def swapped_split_on(l, x): + return split_on(x, l) + + +def perfect_nth(n, a): + if isinstance(a, float): + if not str(a).endswith(".0"): + return 0 + a = int(a) + n = int(n) + if n <= 0: + return 0 + if n == 1: + return 1 + l = [i**n for i in inclusive_zero_range(abs(a))] + return int(a in l) + + +@try_number_conversion +def perfect_square(a): + return perfect_nth(2, a) + + +@try_number_conversion +def perfect_cube(a): + return perfect_nth(3, a) + + +@try_number_conversion +def perfect_fourth(a): + return perfect_nth(4, a) + + +@try_number_conversion +def perfect_fifth(a): + return perfect_nth(5, a) diff --git a/src/build/lib/thunno2/interpreter.py b/src/build/lib/thunno2/interpreter.py new file mode 100644 index 0000000..3e8f1f5 --- /dev/null +++ b/src/build/lib/thunno2/interpreter.py @@ -0,0 +1,806 @@ +from thunno2 import dictionary +from thunno2.commands import * +from thunno2.lexer import tokenise +import string +import copy +import sys + +"""The main interpreter. To run a Thunno 2 program, use the run function.""" + +"""Creative Commons Legal Code + +CC0 1.0 Universal + + CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE + LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN + ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS + INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES + REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS + PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM + THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED + HEREUNDER. + +Statement of Purpose + +The laws of most jurisdictions throughout the world automatically confer +exclusive Copyright and Related Rights (defined below) upon the creator +and subsequent owner(s) (each and all, an "owner") of an original work of +authorship and/or a database (each, a "Work"). + +Certain owners wish to permanently relinquish those rights to a Work for +the purpose of contributing to a commons of creative, cultural and +scientific works ("Commons") that the public can reliably and without fear +of later claims of infringement build upon, modify, incorporate in other +works, reuse and redistribute as freely as possible in any form whatsoever +and for any purposes, including without limitation commercial purposes. +These owners may contribute to the Commons to promote the ideal of a free +culture and the further production of creative, cultural and scientific +works, or to gain reputation or greater distribution for their Work in +part through the use and efforts of others. + +For these and/or other purposes and motivations, and without any +expectation of additional consideration or compensation, the person +associating CC0 with a Work (the "Affirmer"), to the extent that he or she +is an owner of Copyright and Related Rights in the Work, voluntarily +elects to apply CC0 to the Work and publicly distribute the Work under its +terms, with knowledge of his or her Copyright and Related Rights in the +Work and the meaning and intended legal effect of CC0 on those rights. + +1. Copyright and Related Rights. A Work made available under CC0 may be +protected by copyright and related or neighboring rights ("Copyright and +Related Rights"). Copyright and Related Rights include, but are not +limited to, the following: + + i. the right to reproduce, adapt, distribute, perform, display, + communicate, and translate a Work; + ii. moral rights retained by the original author(s) and/or performer(s); +iii. publicity and privacy rights pertaining to a person's image or + likeness depicted in a Work; + iv. rights protecting against unfair competition in regards to a Work, + subject to the limitations in paragraph 4(a), below; + v. rights protecting the extraction, dissemination, use and reuse of data + in a Work; + vi. database rights (such as those arising under Directive 96/9/EC of the + European Parliament and of the Council of 11 March 1996 on the legal + protection of databases, and under any national implementation + thereof, including any amended or successor version of such + directive); and +vii. other similar, equivalent or corresponding rights throughout the + world based on applicable law or treaty, and any national + implementations thereof. + +2. Waiver. To the greatest extent permitted by, but not in contravention +of, applicable law, Affirmer hereby overtly, fully, permanently, +irrevocably and unconditionally waives, abandons, and surrenders all of +Affirmer's Copyright and Related Rights and associated claims and causes +of action, whether now known or unknown (including existing as well as +future claims and causes of action), in the Work (i) in all territories +worldwide, (ii) for the maximum duration provided by applicable law or +treaty (including future time extensions), (iii) in any current or future +medium and for any number of copies, and (iv) for any purpose whatsoever, +including without limitation commercial, advertising or promotional +purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each +member of the public at large and to the detriment of Affirmer's heirs and +successors, fully intending that such Waiver shall not be subject to +revocation, rescission, cancellation, termination, or any other legal or +equitable action to disrupt the quiet enjoyment of the Work by the public +as contemplated by Affirmer's express Statement of Purpose. + +3. Public License Fallback. Should any part of the Waiver for any reason +be judged legally invalid or ineffective under applicable law, then the +Waiver shall be preserved to the maximum extent permitted taking into +account Affirmer's express Statement of Purpose. In addition, to the +extent the Waiver is so judged Affirmer hereby grants to each affected +person a royalty-free, non transferable, non sublicensable, non exclusive, +irrevocable and unconditional license to exercise Affirmer's Copyright and +Related Rights in the Work (i) in all territories worldwide, (ii) for the +maximum duration provided by applicable law or treaty (including future +time extensions), (iii) in any current or future medium and for any number +of copies, and (iv) for any purpose whatsoever, including without +limitation commercial, advertising or promotional purposes (the +"License"). The License shall be deemed effective as of the date CC0 was +applied by Affirmer to the Work. Should any part of the License for any +reason be judged legally invalid or ineffective under applicable law, such +partial invalidity or ineffectiveness shall not invalidate the remainder +of the License, and in such case Affirmer hereby affirms that he or she +will not (i) exercise any of his or her remaining Copyright and Related +Rights in the Work or (ii) assert any associated claims and causes of +action with respect to the Work, in either case contrary to Affirmer's +express Statement of Purpose. + +4. Limitations and Disclaimers. + + a. No trademark or patent rights held by Affirmer are waived, abandoned, + surrendered, licensed or otherwise affected by this document. + b. Affirmer offers the Work as-is and makes no representations or + warranties of any kind concerning the Work, express, implied, + statutory or otherwise, including without limitation warranties of + title, merchantability, fitness for a particular purpose, non + infringement, or the absence of latent or other defects, accuracy, or + the present or absence of errors, whether or not discoverable, all to + the greatest extent permissible under applicable law. + c. Affirmer disclaims responsibility for clearing rights of other persons + that may apply to the Work or any use thereof, including without + limitation any person's Copyright and Related Rights in the Work. + Further, Affirmer disclaims responsibility for obtaining any necessary + consents, permissions or other rights required for any use of the + Work. + d. Affirmer understands and acknowledges that Creative Commons is not a + party to this document and has no duty or obligation with respect to + this CC0 or use of the Work. +""" + +vars_dict = { + "x": 1, # x defaults to 1 + "y": 2, # y defaults to 2 + "ga": [], # global array defaults to [] +} + +"""RUN FUNCTION""" + + +def run(code, *, context=None, iteration_index=None): + if context is None: + n = 0 + else: + n = context + ctx.context = context + # while ctx.index < len(code): + for chars, desc, info in code: + if desc == "command" or desc == "digraph": + if info != Void: + values = info() + for value in values: + ctx.stack.push(value) + elif desc in ( + "number", + "string", + "one character", + "two characters", + "three characters", + "list", + ): + ctx.stack.push(info) + elif desc == "lowercase alphabetic compression": + base255_number = decompress(info, "“") + decompressed_string = to_custom_base_string( + " " + string.ascii_lowercase, base255_number + ) + ctx.stack.push(decompressed_string) + elif desc == "title case alphabetic compression": + base255_number = decompress(info, "”") + decompressed_string = to_custom_base_string( + " " + string.ascii_lowercase, base255_number + ) + ctx.stack.push(decompressed_string.title()) + elif desc == "lowercase dictionary compression": + lst = [] + i = 0 + while i < len(info): + c = info[i] + if c in dictionary.dictionary_codepage: + try: + i += 1 + lst.append(dictionary.dictionary_decompress_string(c + info[i])) + except: + pass + elif c == "\\": + try: + i += 1 + lst.append(info[i]) + except: + lst.append("\\") + else: + lst.append(c) + i += 1 + ctx.stack.push("".join(lst)) + elif desc == "title case dictionary compression": + lst = [] + i = 0 + while i < len(info): + c = info[i] + if c in dictionary.dictionary_codepage: + try: + i += 1 + lst.append( + dictionary.dictionary_decompress_string(c + info[i]).title() + ) + except: + pass + elif c == "\\": + try: + i += 1 + lst.append(info[i]) + except: + lst.append("\\") + else: + lst.append(c) + i += 1 + ctx.stack.push("".join(lst)) + elif desc == "one word dictionary compression": + ctx.stack.push(dictionary.dictionary_decompress_string(info).title()) + elif desc == "two words dictionary compression": + ctx.stack.push( + dictionary.dictionary_decompress_string(info[:2]).title() + + dictionary.dictionary_decompress_string(info[2:]).title() + ) + elif desc == "compressed number" or desc == "small compressed number": + base255_number = decompress(info, "»") + ctx.stack.push(base255_number) + elif desc == "compressed list": + base255_number = decompress(info, "¿") + decompressed_string = to_custom_base_string("0123456789-.,", base255_number) + try: + if decompressed_string[:1] == ",": + decompressed_string = "0" + decompressed_string + if decompressed_string[-1:] == ",": + decompressed_string += "0" + if decompressed_string[:1] == ".": + decompressed_string = ".5" + decompressed_string[1:] + if decompressed_string[-1:] == ".": + decompressed_string += "5" + decompressed_string = decompressed_string.replace(",,", ",0,").replace( + ",.,", ",.5," + ) + e = eval(decompressed_string) + if isinstance(e, tuple): + ctx.stack.push(list(e)) + else: + ctx.stack.push(e) + except: + ctx.stack.push(decompressed_string) + elif desc == "variable get": + ctx.stack.push(vars_dict.get(info, 0)) + elif desc == "variable set": + a = next(ctx.stack.rmv(1)) + vars_dict[info] = a + elif desc == "single function map": + a = next(ctx.stack.rmv(1)) + func = info + if func != Void: + x = listify(a) + r = [] + old_stack = Stack(copy.deepcopy(list(ctx.stack).copy())) + for i in x: + ctx.stack = Stack(copy.deepcopy(list(old_stack).copy())) + ctx.stack.push(i) + for j in func(): + r.append(j) + ctx.stack.push(r) + elif desc == "outer product": + a, b = ctx.stack.rmv(2) + func = info + if func != Void: + x = listify(a) + r = [] + old_stack = Stack(copy.deepcopy(list(ctx.stack).copy())) + if isinstance(a, list): + if isinstance(b, list): + for j in b: + r.append([]) + for i in a: + ctx.stack = Stack( + [i, j] + copy.deepcopy(list(old_stack).copy()) + ) + for k in func(): + r[-1].append(k) + else: + for i in a: + ctx.stack = Stack( + [i, b] + copy.deepcopy(list(old_stack).copy()) + ) + for k in func(): + r.append(k) + else: + if isinstance(b, list): + for i in b: + ctx.stack = Stack( + [a, i] + copy.deepcopy(list(old_stack).copy()) + ) + for k in func(): + r.append(k) + else: + ctx.stack.push(b) + ctx.stack.push(a) + k = func() + if k: + r = k[-1] + ctx.stack.push(r) + elif desc == "single function filter": + a = next(ctx.stack.rmv(1)) + func = info + if func != Void: + x = listify(a) + r = [] + old_stack = Stack(copy.deepcopy(list(ctx.stack).copy())) + for i in x: + ctx.stack = Stack(copy.deepcopy(list(old_stack).copy())) + ctx.stack.push(i) + f = func() + if not f: + continue + if f[-1]: + r.append(i) + ctx.stack.push(r) + elif desc == "single function sort by": + a = next(ctx.stack.rmv(1)) + func = info + if func != Void: + x = listify(a) + sort_by = [] + old_stack = Stack(copy.deepcopy(list(ctx.stack).copy())) + for i in x: + ctx.stack = Stack(copy.deepcopy(list(old_stack).copy())) + ctx.stack.push(i) + f = func() + if not f: + sort_by.append((i, i)) + else: + sort_by.append((i, f[-1])) + try: + sorted_list = sorted(sort_by, key=lambda t: t[-1]) + ctx.stack.push([p for p, q in sorted_list]) + except: + ctx.stack.push(x) + elif desc == "single function group by": + a = next(ctx.stack.rmv(1)) + func = info + if func != Void: + x = listify(a) + group_by = [] + old_stack = Stack(copy.deepcopy(list(ctx.stack).copy())) + for i in x: + ctx.stack = Stack(copy.deepcopy(list(old_stack).copy())) + ctx.stack.push(i) + f = func() + if not f: + group_by.append((i, i)) + else: + group_by.append((i, f[-1])) + try: + d = [] + for val, key in group_by: + for k, (i, j) in enumerate(d): + if key == i: + d[k][1].append(val) + break + else: + d.append((key, [val])) + ctx.stack.push([q for p, q in d]) + except: + ctx.stack.push(x) + elif desc == "context variable": + ctx.stack.push(n) + elif desc == "iteration index": + ctx.stack.push(iteration_index) + elif desc == "get x": + ctx.stack.push(vars_dict.get("x", 1)) + elif desc == "get y": + ctx.stack.push(vars_dict.get("y", 2)) + elif desc == "set x": + a = next(ctx.stack.rmv(1)) + vars_dict["x"] = a + elif desc == "set y": + a = next(ctx.stack.rmv(1)) + vars_dict["y"] = a + elif desc == "set x without popping": + a = (ctx.stack.copy() + ctx.other_il + [0])[0] + vars_dict["x"] = a + elif desc == "set y without popping": + a = (ctx.stack.copy() + ctx.other_il + [0])[0] + vars_dict["y"] = a + elif desc == "apply to x": + old_stack = copy.deepcopy(ctx.stack) + ctx.stack.push(vars_dict.get("x", 1)) + for k in info(): + ctx.stack.push(k) + vars_dict["x"] = next(ctx.stack.rmv(1)) + ctx.stack = copy.deepcopy(old_stack) + elif desc == "apply to y": + old_stack = copy.deepcopy(ctx.stack) + ctx.stack.push(vars_dict.get("y", 2)) + for k in info(): + ctx.stack.push(k) + vars_dict["y"] = next(ctx.stack.rmv(1)) + ctx.stack = copy.deepcopy(old_stack) + elif desc == "get global array": + ctx.stack.push(vars_dict.get("ga", [])) + elif desc == "add to global array": + a = next(ctx.stack.rmv(1)) + ga = vars_dict.get("ga", []) + if not isinstance(ga, list): + vars_dict["ga"] = [ga, a] + vars_dict["ga"] = ga + [a] + elif desc == "stack": + ctx.stack.push(list(ctx.stack).copy()) + elif desc == "constant": + ctx.stack.push(info) + elif desc == "callable constant": + ctx.stack.push(info()) + elif desc == "codepage compression": + ctx.stack.push(info) + elif desc == "quit": + raise TerminateProgramException() # This will hopefully get caught and ignored + elif desc == "next input": + if ctx.other_il: + ctx.stack.push(ctx.other_il[0]) + ctx.other_il = ctx.other_il[1:] + [ctx.other_il[0]] + elif desc == "input list": + ctx.stack.push(ctx.og_input_list) + elif desc == "first input": + try: + ctx.stack.push(ctx.og_input_list[0]) + except: + ctx.stack.push(ctx.og_input_list) + elif desc == "second input": + try: + ctx.stack.push(ctx.og_input_list[1]) + except: + ctx.stack.push(ctx.og_input_list) + elif desc == "third input": + try: + ctx.stack.push(ctx.og_input_list[2]) + except: + ctx.stack.push(ctx.og_input_list) + elif desc == "third last input": + try: + ctx.stack.push(ctx.og_input_list[-3]) + except: + ctx.stack.push(ctx.og_input_list) + elif desc == "second last input": + try: + ctx.stack.push(ctx.og_input_list[-2]) + except: + ctx.stack.push(ctx.og_input_list) + elif desc == "last input": + try: + ctx.stack.push(ctx.og_input_list[-1]) + except: + ctx.stack.push(ctx.og_input_list) + elif desc == "print": + print(next(ctx.stack.rmv(1))) + ctx.implicit_print = False + elif desc == "print without newline": + print(next(ctx.stack.rmv(1)), end="") + ctx.implicit_print = False + elif desc == "print without popping": + print((ctx.stack.copy() + ctx.other_il + [0])[0]) + ctx.implicit_print = False + elif desc == "print each": + for i in listify(next(ctx.stack.rmv(1))): + print(i) + ctx.implicit_print = False + elif desc == "map": + a = next(ctx.stack.rmv(1)) + x = listify(a) + r = [] + old_stack = Stack(copy.deepcopy(list(ctx.stack).copy())) + for i, j in enumerate(x): + ctx.stack = Stack([j] + copy.deepcopy(old_stack)) + run(info, context=j, iteration_index=i) + r.append(next(ctx.stack.rmv(1))) + ctx.stack.push(r) + elif desc == "filter": + a = next(ctx.stack.rmv(1)) + x = listify(a) + r = [] + old_stack = Stack(copy.deepcopy(list(ctx.stack).copy())) + for i, j in enumerate(x): + ctx.stack = Stack([j] + copy.deepcopy(old_stack)) + run(info, context=j, iteration_index=i) + z = next(ctx.stack.rmv(1)) + if z: + r.append(j) + ctx.stack.push(r) + elif desc == "sort by": + a = next(ctx.stack.rmv(1)) + x = listify(a) + r = [] + old_stack = Stack(copy.deepcopy(list(ctx.stack).copy())) + for i, j in enumerate(x): + ctx.stack = Stack([j] + copy.deepcopy(old_stack)) + run(info, context=j, iteration_index=i) + z = next(ctx.stack.rmv(1)) + r.append((j, z)) + try: + sorted_list = sorted(r, key=lambda t: t[-1]) + ctx.stack.push([p for p, q in sorted_list]) + except: + ctx.stack.push(x) + elif desc == "group by": + a = next(ctx.stack.rmv(1)) + x = listify(a) + r = [] + old_stack = Stack(copy.deepcopy(list(ctx.stack).copy())) + for i, j in enumerate(x): + ctx.stack = Stack([j] + copy.deepcopy(old_stack)) + run(info, context=j, iteration_index=i) + z = next(ctx.stack.rmv(1)) + r.append((j, z)) + try: + d = [] + for val, key in r: + for k, (i, j) in enumerate(d): + if key == i: + d[k][1].append(val) + break + else: + d.append((key, [val])) + ctx.stack.push([q for p, q in d]) + except: + ctx.stack.push(x) + elif desc == "fixed point": + r = [Void] + old_stack = Stack(copy.deepcopy(list(ctx.stack).copy())) + i = 0 + while True: + ctx.stack = Stack(copy.deepcopy(old_stack)) + run(info, context=r[-1], iteration_index=i) + k = (ctx.stack + ctx.other_il + [0])[0] + r.append(k) + if r[-1] == r[-2]: + break + i += 1 + ctx.stack.push(r[1:]) + elif desc == "first n integers": + a = next(ctx.stack.rmv(1)) + try: + x = int(a) + except: + x = 1 + old_stack = Stack(copy.deepcopy(list(ctx.stack).copy())) + i = 1 + r = [] + while len(r) < x: + ctx.stack = Stack(copy.deepcopy(old_stack)) + ctx.stack.push(i) + run(info, context=i, iteration_index=i - 1) + k = next(ctx.stack.rmv(1)) + if k: + r.append(i) + i += 1 + ctx.stack.push(r) + elif desc == "cumulative reduce by": + a = next(ctx.stack.rmv(1)) + x = listify(a) + old_stack = Stack(copy.deepcopy(list(ctx.stack).copy())) + if x: + r = [x.pop(0)] + for i, j in enumerate(x): + ctx.stack = Stack(copy.deepcopy(old_stack)) + ctx.stack.push(r[-1]) + ctx.stack.push(j) + run(info, context=j, iteration_index=i) + r.append(next(ctx.stack.rmv(1))) + ctx.stack.push(r) + else: + ctx.stack.push([]) + elif desc == "single function reduce by": + a = next(ctx.stack.rmv(1)) + x = listify(a) + old_stack = Stack(copy.deepcopy(list(ctx.stack).copy())) + func = info + if func != Void: + if x: + r = [x.pop(0)] + for i, j in enumerate(x): + ctx.stack = Stack(copy.deepcopy(old_stack)) + ctx.stack.push(r[-1]) + ctx.stack.push(j) + for k in func(): + r.append(k) + ctx.stack.push(r[-1]) + else: + ctx.stack.push([]) + elif desc == "single function right reduce by": + a = next(ctx.stack.rmv(1)) + x = listify(a)[::-1] + old_stack = Stack(copy.deepcopy(list(ctx.stack).copy())) + func = info + if func != Void: + if x: + r = [x.pop(0)] + for i, j in enumerate(x): + ctx.stack = Stack(copy.deepcopy(old_stack)) + ctx.stack.push(r[-1]) + ctx.stack.push(j) + for k in func(): + r.append(k) + ctx.stack.push(r[-1]) + else: + ctx.stack.push([]) + elif desc == "single function right cumulative reduce by": + a = next(ctx.stack.rmv(1)) + x = listify(a)[::-1] + old_stack = Stack(copy.deepcopy(list(ctx.stack).copy())) + func = info + if func != Void: + if x: + r = [x.pop(0)] + for i, j in enumerate(x): + ctx.stack = Stack(copy.deepcopy(old_stack)) + ctx.stack.push(r[-1]) + ctx.stack.push(j) + for k in func(): + r.append(k) + ctx.stack.push(r) + else: + ctx.stack.push([]) + elif desc == "right reduce by": + a = next(ctx.stack.rmv(1)) + x = listify(a)[::-1] + old_stack = Stack(copy.deepcopy(list(ctx.stack).copy())) + if x: + r = [x.pop(0)] + for i, j in enumerate(x): + ctx.stack = Stack(copy.deepcopy(old_stack)) + ctx.stack.push(r[-1]) + ctx.stack.push(j) + run(info, context=j, iteration_index=i) + r.append(next(ctx.stack.rmv(1))) + ctx.stack.push(r[-1]) + else: + ctx.stack.push([]) + elif desc == "for loop": + a = next(ctx.stack.rmv(1)) + x = listify(a) + for i, j in enumerate(x): + if not isinstance(a, (int, float)): + ctx.stack.push(j) + run(info, context=j, iteration_index=i) + elif desc == "while loop": + cond, body = info + i = 0 + while True: + old_stack = Stack(copy.deepcopy(list(ctx.stack).copy())) + run(cond, context=0, iteration_index=i) + z = next(ctx.stack.rmv(1)) + ctx.stack = Stack(copy.deepcopy(old_stack)) + if not z: + break + run(body, context=0, iteration_index=i) + i += 1 + elif desc == "forever loop": + i = 0 + while True: + run(info, context=0, iteration_index=i) + i += 1 + elif desc == "if statement": + if_true, if_false = info + a = next(ctx.stack.rmv(1)) + if a: + run(if_true, context=0, iteration_index=1) + else: + run(if_false, context=0, iteration_index=0) + elif desc == "execute without popping": + if info != Void: + values = info(pop=False) + for value in values: + ctx.stack.push(value) + elif desc == "pair apply": + a = next(ctx.stack.rmv(1)) + old_stack = Stack(copy.deepcopy(list(ctx.stack).copy())) + r = [] + f1, f2 = info + ctx.stack.push(a) + k = f1() + if k: + r.append(k[-1]) + ctx.stack = Stack(copy.deepcopy(old_stack)) + k = f2() + if k: + r.append(k[-1]) + ctx.stack = Stack(copy.deepcopy(old_stack)) + ctx.stack.push(r) + elif desc == "recursive environment": + a = next(ctx.stack.rmv(1)) + if isinstance(a, list): + x = copy.deepcopy(a) + else: + x = [a] + for i in x: + print(i) + old_stack = Stack(copy.deepcopy(list(ctx.stack).copy())) + k = 0 + while True: + ctx.stack = Stack(copy.deepcopy(list(old_stack).copy())) + for j in x: + ctx.stack.push(j) + run(info, context=([0] + x)[-1], iteration_index=k) + y = next(ctx.stack.rmv(1)) + print(y) + x.append(y) + k += 1 + elif desc == "apply to every nth item": + a = next(ctx.stack.rmv(1)) + try: + a = int(a) + except: + try: + a = len(a) + except: + a = 2 + b = listify(next(ctx.stack.rmv(1))) + old_stack = Stack(copy.deepcopy(list(ctx.stack).copy())) + r = [] + for i, j in enumerate(b): + if i % a == 0: + ctx.stack = Stack(copy.deepcopy(list(old_stack).copy())) + ctx.stack.push(j) + for k in info(): + r.append(k) + else: + r.append(j) + ctx.stack.push(r) + elif desc == "rotate stack left": + ctx.stack = Stack(rotate_left_once(ctx.stack)) + elif desc == "rotate stack right": + ctx.stack = Stack(rotate_right_once(ctx.stack)) + elif desc == "reverse stack": + ctx.stack = Stack(ctx.stack[::-1]) + elif desc == "adjacent group by": + a = next(ctx.stack.rmv(1)) + x = listify(a) + r = [] + old_stack = Stack(copy.deepcopy(list(ctx.stack).copy())) + for i, j in enumerate(x): + ctx.stack = Stack([j] + copy.deepcopy(old_stack)) + run(info, context=j, iteration_index=i) + z = next(ctx.stack.rmv(1)) + r.append((j, z)) + try: + d = [] + last = None + for val, key in r: + if key == last: + d[-1].append(val) + else: + d.append([val]) + last = key + ctx.stack.push(d) + except: + ctx.stack.push(x) + elif desc == "single function adjacent group by": + a = next(ctx.stack.rmv(1)) + func = info + if func != Void: + x = listify(a) + group_by = [] + old_stack = Stack(copy.deepcopy(list(ctx.stack).copy())) + for i in x: + ctx.stack = Stack(copy.deepcopy(list(old_stack).copy())) + ctx.stack.push(i) + f = func() + if not f: + group_by.append((i, i)) + else: + group_by.append((i, f[-1])) + try: + d = [] + last = None + for val, key in group_by: + if key == last: + d[-1].append(val) + else: + d.append([val]) + last = key + ctx.stack.push(d) + except: + ctx.stack.push(x) + else: + if ctx.warnings: + print("TRACEBACK: [UNRECOGNISED TOKEN]", file=sys.stderr) + print(f"Got {chars!r} (tokenised to {desc!r})") + return 0 + + +def test(cod, inp=(), stk=(), warn=True): + ctx.stack = Stack(stk) + ctx.og_input_list = list(inp) + ctx.other_il = list(inp) + ctx.warnings = warn + tokenised = tokenise(cod)[1] + run(tokenised, context=0, iteration_index=0) + print(ctx.stack) + if ctx.implicit_print: + print(ctx.stack[0]) diff --git a/src/build/lib/thunno2/lexer.py b/src/build/lib/thunno2/lexer.py new file mode 100644 index 0000000..5a139ef --- /dev/null +++ b/src/build/lib/thunno2/lexer.py @@ -0,0 +1,654 @@ +from thunno2.commands import commands, DIGRAPHS, get_a_function, Void +from thunno2.constants import CONSTANTS +from thunno2.codepage import codepage_index +from thunno2.dictionary import dictionary_codepage + +"""Splits Thunno 2 code into tokens to make it easier for the interpreter""" + +"""Creative Commons Legal Code + +CC0 1.0 Universal + + CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE + LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN + ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS + INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES + REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS + PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM + THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED + HEREUNDER. + +Statement of Purpose + +The laws of most jurisdictions throughout the world automatically confer +exclusive Copyright and Related Rights (defined below) upon the creator +and subsequent owner(s) (each and all, an "owner") of an original work of +authorship and/or a database (each, a "Work"). + +Certain owners wish to permanently relinquish those rights to a Work for +the purpose of contributing to a commons of creative, cultural and +scientific works ("Commons") that the public can reliably and without fear +of later claims of infringement build upon, modify, incorporate in other +works, reuse and redistribute as freely as possible in any form whatsoever +and for any purposes, including without limitation commercial purposes. +These owners may contribute to the Commons to promote the ideal of a free +culture and the further production of creative, cultural and scientific +works, or to gain reputation or greater distribution for their Work in +part through the use and efforts of others. + +For these and/or other purposes and motivations, and without any +expectation of additional consideration or compensation, the person +associating CC0 with a Work (the "Affirmer"), to the extent that he or she +is an owner of Copyright and Related Rights in the Work, voluntarily +elects to apply CC0 to the Work and publicly distribute the Work under its +terms, with knowledge of his or her Copyright and Related Rights in the +Work and the meaning and intended legal effect of CC0 on those rights. + +1. Copyright and Related Rights. A Work made available under CC0 may be +protected by copyright and related or neighboring rights ("Copyright and +Related Rights"). Copyright and Related Rights include, but are not +limited to, the following: + + i. the right to reproduce, adapt, distribute, perform, display, + communicate, and translate a Work; + ii. moral rights retained by the original author(s) and/or performer(s); +iii. publicity and privacy rights pertaining to a person's image or + likeness depicted in a Work; + iv. rights protecting against unfair competition in regards to a Work, + subject to the limitations in paragraph 4(a), below; + v. rights protecting the extraction, dissemination, use and reuse of data + in a Work; + vi. database rights (such as those arising under Directive 96/9/EC of the + European Parliament and of the Council of 11 March 1996 on the legal + protection of databases, and under any national implementation + thereof, including any amended or successor version of such + directive); and +vii. other similar, equivalent or corresponding rights throughout the + world based on applicable law or treaty, and any national + implementations thereof. + +2. Waiver. To the greatest extent permitted by, but not in contravention +of, applicable law, Affirmer hereby overtly, fully, permanently, +irrevocably and unconditionally waives, abandons, and surrenders all of +Affirmer's Copyright and Related Rights and associated claims and causes +of action, whether now known or unknown (including existing as well as +future claims and causes of action), in the Work (i) in all territories +worldwide, (ii) for the maximum duration provided by applicable law or +treaty (including future time extensions), (iii) in any current or future +medium and for any number of copies, and (iv) for any purpose whatsoever, +including without limitation commercial, advertising or promotional +purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each +member of the public at large and to the detriment of Affirmer's heirs and +successors, fully intending that such Waiver shall not be subject to +revocation, rescission, cancellation, termination, or any other legal or +equitable action to disrupt the quiet enjoyment of the Work by the public +as contemplated by Affirmer's express Statement of Purpose. + +3. Public License Fallback. Should any part of the Waiver for any reason +be judged legally invalid or ineffective under applicable law, then the +Waiver shall be preserved to the maximum extent permitted taking into +account Affirmer's express Statement of Purpose. In addition, to the +extent the Waiver is so judged Affirmer hereby grants to each affected +person a royalty-free, non transferable, non sublicensable, non exclusive, +irrevocable and unconditional license to exercise Affirmer's Copyright and +Related Rights in the Work (i) in all territories worldwide, (ii) for the +maximum duration provided by applicable law or treaty (including future +time extensions), (iii) in any current or future medium and for any number +of copies, and (iv) for any purpose whatsoever, including without +limitation commercial, advertising or promotional purposes (the +"License"). The License shall be deemed effective as of the date CC0 was +applied by Affirmer to the Work. Should any part of the License for any +reason be judged legally invalid or ineffective under applicable law, such +partial invalidity or ineffectiveness shall not invalidate the remainder +of the License, and in such case Affirmer hereby affirms that he or she +will not (i) exercise any of his or her remaining Copyright and Related +Rights in the Work or (ii) assert any associated claims and causes of +action with respect to the Work, in either case contrary to Affirmer's +express Statement of Purpose. + +4. Limitations and Disclaimers. + + a. No trademark or patent rights held by Affirmer are waived, abandoned, + surrendered, licensed or otherwise affected by this document. + b. Affirmer offers the Work as-is and makes no representations or + warranties of any kind concerning the Work, express, implied, + statutory or otherwise, including without limitation warranties of + title, merchantability, fitness for a particular purpose, non + infringement, or the absence of latent or other defects, accuracy, or + the present or absence of errors, whether or not discoverable, all to + the greatest extent permissible under applicable law. + c. Affirmer disclaims responsibility for clearing rights of other persons + that may apply to the Work or any use thereof, including without + limitation any person's Copyright and Related Rights in the Work. + Further, Affirmer disclaims responsibility for obtaining any necessary + consents, permissions or other rights required for any use of the + Work. + d. Affirmer understands and acknowledges that Creative Commons is not a + party to this document and has no duty or obligation with respect to + this CC0 or use of the Work. +""" + + +def tokenise(code, expected_end=""): + index = 0 + ret = [] + while index < len(code): + char = code[index] + if char in commands: + ret.append((char, "command", commands[char])) + elif char in DIGRAPHS: + index += 1 + try: + x = code[index] + y = char + x + if y == "µµ": + i, r = tokenise(code[index + 1 :], expected_end=";") + index += i + ret.append((y, "recursive environment", r)) + elif y == "µ£": + ret.append((y, "print each", 0)) + elif y == "µƲ": + index += 1 + cmd = code[index] + if cmd in DIGRAPHS: + index += 1 + cmd += code[index] + func = get_a_function(cmd) + ret.append((y + cmd, "single function reduce by", func)) + elif y == "µɼ": + index += 1 + cmd = code[index] + if cmd in DIGRAPHS: + index += 1 + cmd += code[index] + func = get_a_function(cmd) + ret.append((y + cmd, "single function right reduce by", func)) + elif y == "µƇ": + index += 1 + cmd = code[index] + if cmd in DIGRAPHS: + index += 1 + cmd += code[index] + func = get_a_function(cmd) + ret.append( + (y + cmd, "single function right cumulative reduce by", func) + ) + elif y == "µʋ": + i, r = tokenise(code[index + 1 :], expected_end=";") + index += i + ret.append((y, "right reduce by", r)) + elif y == "µ€": + index += 1 + cmd = code[index] + if cmd in DIGRAPHS: + index += 1 + cmd += code[index] + func = get_a_function(cmd) + ret.append((y + cmd, "apply to every nth item", func)) + elif y == "µ«": + ret.append((y, "rotate stack left", 0)) + elif y == "µ»": + ret.append((y, "rotate stack right", 0)) + elif y == "µ!": + ret.append((y, "reverse stack", 0)) + elif y == "µÑ": + i, r = tokenise(code[index + 1 :], expected_end=";") + index += i + ret.append((y, "adjacent group by", r)) + elif y == "µñ": + index += 1 + cmd = code[index] + if cmd in DIGRAPHS: + index += 1 + cmd += code[index] + func = get_a_function(cmd) + ret.append((y + cmd, "single function adjacent group by", func)) + else: + ret.append((y, "digraph", get_a_function(y))) + except: + pass + elif char in "0123456789.": + s = char + index += 1 + try: + while code[index] in "0123456789.": + s += code[index] + index += 1 + except: + pass + index -= 1 + try: + while s[0] == "0": + ret.append(("0", "number", 0)) + try: + s = s[1:] + except: + break + if s == ".": + ret.append((".", "number", 0.5)) + else: + x = eval(s) + if s.endswith("."): + x += 0.5 + ret.append((s, "number", x)) + except: + pass + elif char == '"': + s = char + index += 1 + try: + while (code[index] != '"') or (code[index - 1] == "\\"): + s += code[index] + index += 1 + s += code[index] + except: + s += '"' + try: + ret.append((s, "string", eval(s).replace("¶", "\n"))) + except: + ret.append((s, "string", s[1:-1].replace("¶", "\n"))) + elif char == "'": + index += 1 + try: + x = code[index] + ret.append(("'" + x, "one character", x)) + except: + ret.append(("'", "one character", "")) + elif char == "`": + index += 2 + x = code[index - 1 : index + 1] + if ( + (len(x) != 2) + or (x[0] not in dictionary_codepage) + or (x[1] not in dictionary_codepage) + ): + ret.append(("`" + x, "two characters", x)) + else: + ret.append(("`" + x, "one word dictionary compression", x)) + elif char == "ʋ": + index += 3 + x = code[index - 2 : index + 1] + try: + nxt = code[index + 1] + except: + nxt = "" + if (len(x) != 3) or ( + (x[0] not in dictionary_codepage) + or (x[1] not in dictionary_codepage) + or (x[2] not in dictionary_codepage) + or (nxt not in dictionary_codepage) + ): + ret.append(("ʋ" + x, "three characters", x)) + else: + index += 1 + ret.append(("ʋ" + x + nxt, "two words dictionary compression", x + nxt)) + elif char == "[": + s = char + index += 1 + try: + in_string = "" + nests = 1 + while nests: + c = code[index] + s += c + if in_string == "" and c in ('"', "'"): + in_string = c + elif in_string != "" and c == in_string: + if code[index - 1] != "\\": + in_string = "" + if in_string == "": + if c == "[": + nests += 1 + elif c == "]": + nests -= 1 + index += 1 + except: + s += "]" + try: + ret.append((s, "list", eval(s))) + except: + ret.append((s, "list", s)) + elif char == "]": + ret.append(("]", "list", [])) + elif char == "#": + index += 1 + try: + if code[index] == " ": + while code[index] not in "¶\n": + index += 1 + elif code[index] == "{": + while code[index] != "#" or code[index - 1] != "}": + index += 1 + except: + pass + elif char == "“": + compressed_string = "" + index += 1 + try: + while code[index] != char: + compressed_string += code[index] + index += 1 + except: + pass + ret.append( + ( + char + compressed_string + char, + "lowercase alphabetic compression", + compressed_string, + ) + ) + elif char == "”": + compressed_string = "" + index += 1 + try: + while code[index] != char: + compressed_string += code[index] + index += 1 + except: + pass + ret.append( + ( + char + compressed_string + char, + "title case alphabetic compression", + compressed_string, + ) + ) + elif char == "‘": + compressed_string = "" + index += 1 + try: + while code[index] != char: + compressed_string += code[index] + index += 1 + except: + pass + ret.append( + ( + char + compressed_string + char, + "lowercase dictionary compression", + compressed_string, + ) + ) + elif char == "’": + compressed_string = "" + index += 1 + try: + while code[index] != char: + compressed_string += code[index] + index += 1 + except: + pass + ret.append( + ( + char + compressed_string + char, + "title case dictionary compression", + compressed_string, + ) + ) + elif char == "»": + compressed_string = "" + index += 1 + try: + while code[index] != char: + compressed_string += code[index] + index += 1 + except: + pass + ret.append( + ( + char + compressed_string + char, + "compressed number", + compressed_string, + ) + ) + elif char == "«": + compressed_string = code[index + 1 : index + 3] + index += 2 + ret.append( + (char + compressed_string, "small compressed number", compressed_string) + ) + elif char == "¿": + compressed_string = "" + index += 1 + try: + while code[index] != char: + compressed_string += code[index] + index += 1 + except: + pass + ret.append( + (char + compressed_string + char, "compressed list", compressed_string) + ) + elif char == "¡": + index += 1 + try: + var = code[index] + except: + var = "" + ret.append((char + var, "variable get", var)) + elif char == "!": + index += 1 + try: + var = code[index] + except: + var = "" + ret.append((char + var, "variable set", var)) + elif char == "€": + index += 1 + cmd = code[index] + if cmd in DIGRAPHS: + index += 1 + cmd += code[index] + func = get_a_function(cmd) + ret.append((char + cmd, "single function map", func)) + elif char == "ȷ": + index += 1 + cmd = code[index] + if cmd in DIGRAPHS: + index += 1 + cmd += code[index] + func = get_a_function(cmd) + ret.append((char + cmd, "outer product", func)) + elif char == "œ": + index += 1 + cmd = code[index] + if cmd in DIGRAPHS: + index += 1 + cmd += code[index] + func = get_a_function(cmd) + ret.append((char + cmd, "single function filter", func)) + elif char == "þ": + index += 1 + cmd = code[index] + if cmd in DIGRAPHS: + index += 1 + cmd += code[index] + func = get_a_function(cmd) + ret.append((char + cmd, "single function sort by", func)) + elif char == "ñ": + index += 1 + cmd = code[index] + if cmd in DIGRAPHS: + index += 1 + cmd += code[index] + func = get_a_function(cmd) + ret.append((char + cmd, "single function group by", func)) + elif char == "n": + ret.append((char, "context variable", 0)) + elif char == "ṅ": + ret.append((char, "iteration index", 0)) + elif char == "x": + ret.append((char, "get x", 0)) + elif char == "y": + ret.append((char, "get y", 0)) + elif char == "X": + ret.append((char, "set x", 0)) + elif char == "Y": + ret.append((char, "set y", 0)) + elif char == "Ẋ": + ret.append((char, "set x without popping", 0)) + elif char == "Ẏ": + ret.append((char, "set y without popping", 0)) + elif char == "ẋ": + index += 1 + cmd = code[index] + if cmd in DIGRAPHS: + index += 1 + cmd += code[index] + func = get_a_function(cmd) + ret.append((char, "apply to x", func)) + elif char == "ẏ": + index += 1 + cmd = code[index] + if cmd in DIGRAPHS: + index += 1 + cmd += code[index] + func = get_a_function(cmd) + ret.append((char, "apply to y", func)) + elif char == "Ȥ": + ret.append((char, "get global array", 0)) + elif char == "ȥ": + ret.append((char, "add to global array", 0)) + elif char == "K": + ret.append((char, "stack", 0)) + elif char == "k": + index += 1 + try: + if code[index] in CONSTANTS: + x = code[index] + c = CONSTANTS[x] + if type(c) == type(lambda: 0): + ret.append((char + x, "callable constant", c)) + else: + ret.append((char + x, "constant", c)) + except: + pass + elif char == "ṇ": + index += 1 + try: + x = code[index] + ret.append( + (char + x, "codepage compression", next(codepage_index(x)) + 101) + ) + except: + pass + elif char == "q": + ret.append((char, "quit", 0)) + elif char == "$": + ret.append((char, "next input", 0)) + elif char == "¤": + ret.append((char, "input list", 0)) + elif char == "°": + ret.append((char, "first input", 0)) + elif char == "¹": + ret.append((char, "second input", 0)) + elif char == "⁶": + ret.append((char, "third input", 0)) + elif char == "⁷": + ret.append((char, "third last input", 0)) + elif char == "⁸": + ret.append((char, "second last input", 0)) + elif char == "⁹": + ret.append((char, "last input", 0)) + elif char == "£": + ret.append((char, "print", 0)) + elif char == "¢": + ret.append((char, "print without newline", 0)) + elif char == "ß": + ret.append((char, "print without popping", 0)) + elif char == "ı": + i, r = tokenise(code[index + 1 :], expected_end=";") + index += i + ret.append((char, "map", r)) + elif char == "æ": + i, r = tokenise(code[index + 1 :], expected_end=";") + index += i + ret.append((char, "filter", r)) + elif char == "Þ": + i, r = tokenise(code[index + 1 :], expected_end=";") + index += i + ret.append((char, "sort by", r)) + elif char == "Ñ": + i, r = tokenise(code[index + 1 :], expected_end=";") + index += i + ret.append((char, "group by", r)) + elif char == "¥": + i, r = tokenise(code[index + 1 :], expected_end=";") + index += i + ret.append((char, "fixed point", r)) + elif char == "Ƙ": + i, r = tokenise(code[index + 1 :], expected_end=";") + index += i + ret.append((char, "first n integers", r)) + elif char == "Ʋ": + i, r = tokenise(code[index + 1 :], expected_end=";") + index += i + ret.append((char, "cumulative reduce by", r)) + elif char == "{": + i, r = tokenise(code[index + 1 :], expected_end="}") + index += i + ret.append((char, "for loop", r)) + elif char == "(": + i, r1 = tokenise(code[index + 1 :], expected_end=";)") + index += i + 1 + r2 = [] + try: + if code[index] == ";": + i, r2 = tokenise(code[index + 1 :], expected_end=")") + index += i + except: + pass + ret.append((char, "while loop", (r1, r2))) + elif char == "⁽": + i, r = tokenise(code[index + 1 :], expected_end="⁾") + index += i + ret.append((char, "forever loop", r)) + elif char == "?": + i, r1 = tokenise(code[index + 1 :], expected_end=":;") + index += i + 1 + r2 = [] + try: + if code[index] == ":": + i, r2 = tokenise(code[index + 1 :], expected_end=";") + index += i + except: + pass + ret.append((char, "if statement", (r1, r2))) + elif char == "Ɓ": + index += 1 + cmd = code[index] + if cmd in DIGRAPHS: + index += 1 + cmd += code[index] + func = get_a_function(cmd) + ret.append((char + cmd, "execute without popping", func)) + elif char == "ç": + try: + index += 1 + cmd1 = code[index] + if cmd1 in DIGRAPHS: + index += 1 + cmd1 += code[index] + func1 = get_a_function(cmd1) + except: + func1, cmd1 = Void, "" + try: + index += 1 + cmd2 = code[index] + if cmd2 in DIGRAPHS: + index += 1 + cmd2 += code[index] + func2 = get_a_function(cmd2) + except: + func2, cmd2 = Void, "" + ret.append((char + cmd1 + cmd2, "pair apply", (func1, func2))) + elif char in expected_end: + return index, ret + elif char == ":": + ret.append((":", "command", commands["="])) + return index + 1, ret + elif char == "}": + ret.append(("}", "command", commands["¬"])) + return index + 1, ret + index += 1 + return index + 1, ret diff --git a/src/build/lib/thunno2/run.py b/src/build/lib/thunno2/run.py new file mode 100644 index 0000000..9731b34 --- /dev/null +++ b/src/build/lib/thunno2/run.py @@ -0,0 +1,107 @@ +from thunno2 import lexer, version, flags, tokens, autoexplanation, codepage +import sys, time + + +def from_terminal(): + print("Thunno", version.THUNNO_VERSION, "interpreter\n") + print("\nFlags:") + flags_list = input() + code = "" + print("\nHeader:") + inp = input() + while inp: + code += inp + "\n" + inp = input() + print("\nCode:") + inp = input() + while inp: + code += inp + "\n" + inp = input() + print("\nFooter:") + inp = input() + while inp: + code += inp + "\n" + inp = input() + inputs = "" + print("\nInput:") + inp = input() + while inp: + inputs += inp + "\n" + inp = input() + if "U" in flags_list: + code = codepage.utf8_to_thunno2(code) + if "." in "".join(flags_list): + start_time = time.time() + if "v" in flags_list: + transpiled = tokens.transpile(code) + print("\nTranspiled:") + print(transpiled) + print() + _, tokenised = lexer.tokenise(transpiled) + else: + _, tokenised = lexer.tokenise(code) + if "." in "".join(flags_list): + lexed_time = time.time() + if "e" in flags_list: + print( + "\nExplanation:\n\n" + + autoexplanation.auto_explain(tokenised, tkn=False) + + "\n" + ) + print("\nOutput:") + flags.run(flags_list, tokenised, inputs) + if "." in "".join(flags_list): + end_time = time.time() + times = [ + (lexed_time - start_time) * 1000, + (end_time - lexed_time) * 1000, + (end_time - start_time) * 1000, + ] + print("\nTimings:") + print(f"Lexer: {times[0]:.3f}ms") + print(f"Program: {times[1]:.3f}ms") + print(f"Total: {times[2]:.3f}ms\n") + + +def from_cmdline(): + args = sys.argv[1:] + if not args: + from_terminal() + return None + filename = args[0] + flags_list = args[1:] + sys.stderr.write("Thunno, v" + version.THUNNO_VERSION + "\n") + try: + with open(filename) as f: + code = f.read() + if "U" in "".join(flags_list): + code = codepage.utf8_to_thunno2(code) + if "." in "".join(flags_list): + start_time = time.time() + if "v" in "".join(flags_list): + transpiled = tokens.transpile(code) + print("Transpiled:", transpiled, file=sys.stderr) + _, tokenised = lexer.tokenise(transpiled) + else: + _, tokenised = lexer.tokenise(code) + if "." in "".join(flags_list): + lexed_time = time.time() + if "e" in "".join(flags_list): + sys.stderr.write( + "\nExplanation:\n\n" + + autoexplanation.auto_explain(tokenised, tkn=False) + + "\n" + ) + flags.run("".join(flags_list), tokenised, sys.stdin.read()) + if "." in "".join(flags_list): + end_time = time.time() + times = [ + (lexed_time - start_time) * 1000, + (end_time - lexed_time) * 1000, + (end_time - start_time) * 1000, + ] + sys.stderr.write( + f"\nTimings:\nLexer: {times[0]:.3f}ms\nProgram: {times[1]:.3f}ms\nTotal: {times[2]:.3f}ms\n" + ) + except Exception as E: + sys.stderr.write("An error occurred: " + repr(E)) diff --git a/src/build/lib/thunno2/tests.py b/src/build/lib/thunno2/tests.py new file mode 100644 index 0000000..fee3b93 --- /dev/null +++ b/src/build/lib/thunno2/tests.py @@ -0,0 +1,3418 @@ +from thunno2.commands import * + +"""Here we test every command implemented in the commands dictionary""" + +"""Creative Commons Legal Code + +CC0 1.0 Universal + + CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE + LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN + ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS + INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES + REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS + PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM + THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED + HEREUNDER. + +Statement of Purpose + +The laws of most jurisdictions throughout the world automatically confer +exclusive Copyright and Related Rights (defined below) upon the creator +and subsequent owner(s) (each and all, an "owner") of an original work of +authorship and/or a database (each, a "Work"). + +Certain owners wish to permanently relinquish those rights to a Work for +the purpose of contributing to a commons of creative, cultural and +scientific works ("Commons") that the public can reliably and without fear +of later claims of infringement build upon, modify, incorporate in other +works, reuse and redistribute as freely as possible in any form whatsoever +and for any purposes, including without limitation commercial purposes. +These owners may contribute to the Commons to promote the ideal of a free +culture and the further production of creative, cultural and scientific +works, or to gain reputation or greater distribution for their Work in +part through the use and efforts of others. + +For these and/or other purposes and motivations, and without any +expectation of additional consideration or compensation, the person +associating CC0 with a Work (the "Affirmer"), to the extent that he or she +is an owner of Copyright and Related Rights in the Work, voluntarily +elects to apply CC0 to the Work and publicly distribute the Work under its +terms, with knowledge of his or her Copyright and Related Rights in the +Work and the meaning and intended legal effect of CC0 on those rights. + +1. Copyright and Related Rights. A Work made available under CC0 may be +protected by copyright and related or neighboring rights ("Copyright and +Related Rights"). Copyright and Related Rights include, but are not +limited to, the following: + + i. the right to reproduce, adapt, distribute, perform, display, + communicate, and translate a Work; + ii. moral rights retained by the original author(s) and/or performer(s); +iii. publicity and privacy rights pertaining to a person's image or + likeness depicted in a Work; + iv. rights protecting against unfair competition in regards to a Work, + subject to the limitations in paragraph 4(a), below; + v. rights protecting the extraction, dissemination, use and reuse of data + in a Work; + vi. database rights (such as those arising under Directive 96/9/EC of the + European Parliament and of the Council of 11 March 1996 on the legal + protection of databases, and under any national implementation + thereof, including any amended or successor version of such + directive); and +vii. other similar, equivalent or corresponding rights throughout the + world based on applicable law or treaty, and any national + implementations thereof. + +2. Waiver. To the greatest extent permitted by, but not in contravention +of, applicable law, Affirmer hereby overtly, fully, permanently, +irrevocably and unconditionally waives, abandons, and surrenders all of +Affirmer's Copyright and Related Rights and associated claims and causes +of action, whether now known or unknown (including existing as well as +future claims and causes of action), in the Work (i) in all territories +worldwide, (ii) for the maximum duration provided by applicable law or +treaty (including future time extensions), (iii) in any current or future +medium and for any number of copies, and (iv) for any purpose whatsoever, +including without limitation commercial, advertising or promotional +purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each +member of the public at large and to the detriment of Affirmer's heirs and +successors, fully intending that such Waiver shall not be subject to +revocation, rescission, cancellation, termination, or any other legal or +equitable action to disrupt the quiet enjoyment of the Work by the public +as contemplated by Affirmer's express Statement of Purpose. + +3. Public License Fallback. Should any part of the Waiver for any reason +be judged legally invalid or ineffective under applicable law, then the +Waiver shall be preserved to the maximum extent permitted taking into +account Affirmer's express Statement of Purpose. In addition, to the +extent the Waiver is so judged Affirmer hereby grants to each affected +person a royalty-free, non transferable, non sublicensable, non exclusive, +irrevocable and unconditional license to exercise Affirmer's Copyright and +Related Rights in the Work (i) in all territories worldwide, (ii) for the +maximum duration provided by applicable law or treaty (including future +time extensions), (iii) in any current or future medium and for any number +of copies, and (iv) for any purpose whatsoever, including without +limitation commercial, advertising or promotional purposes (the +"License"). The License shall be deemed effective as of the date CC0 was +applied by Affirmer to the Work. Should any part of the License for any +reason be judged legally invalid or ineffective under applicable law, such +partial invalidity or ineffectiveness shall not invalidate the remainder +of the License, and in such case Affirmer hereby affirms that he or she +will not (i) exercise any of his or her remaining Copyright and Related +Rights in the Work or (ii) assert any associated claims and causes of +action with respect to the Work, in either case contrary to Affirmer's +express Statement of Purpose. + +4. Limitations and Disclaimers. + + a. No trademark or patent rights held by Affirmer are waived, abandoned, + surrendered, licensed or otherwise affected by this document. + b. Affirmer offers the Work as-is and makes no representations or + warranties of any kind concerning the Work, express, implied, + statutory or otherwise, including without limitation warranties of + title, merchantability, fitness for a particular purpose, non + infringement, or the absence of latent or other defects, accuracy, or + the present or absence of errors, whether or not discoverable, all to + the greatest extent permissible under applicable law. + c. Affirmer disclaims responsibility for clearing rights of other persons + that may apply to the Work or any use thereof, including without + limitation any person's Copyright and Related Rights in the Work. + Further, Affirmer disclaims responsibility for obtaining any necessary + consents, permissions or other rights required for any use of the + Work. + d. Affirmer understands and acknowledges that Creative Commons is not a + party to this document and has no duty or obligation with respect to + this CC0 or use of the Work. +""" + +tests_counter = 0 +tested_commands = [] + +UNTESTABLE = [ + "ɼ", + "øv", + "øV", + "ø^", + "µr", + "ÆC", + "ÆD", + "ÆE", + "ÆL", + "ÆN", + "ÆR", + "ÆS", + "ÆT", + "Æc", + "Æl", + "Æs", + "Æt", + "Æḷ", +] + + +def call(cmd, *stk): + ctx.stack = Stack(stk) + ctx.warnings = True + tested_commands.append(cmd) + return get_a_function(cmd)() + + +def assert_eq(a, *b): + global tests_counter + tests_counter += 1 + # Because 1 == True + # but '1' != 'True' + # (we don't want booleans) + # ↓↓ + assert a == b and repr(a) == repr(b), f"\n\nTest {tests_counter}\n{a!r} != {b!r}" + + +# A + +assert_eq(call("A", -1), 1) +assert_eq(call("A", 1.23), 1.23) +assert_eq(call("A", [-1, 2.3, [-4.56]]), [1, 2.3, [4.56]]) +assert_eq(call("A", [[[[[[-123.456]]]]]]), [[[[[[123.456]]]]]]) + +assert_eq(call("A", "abc"), 1) +assert_eq(call("A", "123"), 0) +assert_eq(call("A", ""), 0) +assert_eq(call("A", ["a", ["b", ["1", ["2"]]]]), [1, [1, [0, [0]]]]) + +assert_eq(call("A", ["abc", 123, "123", -0.123]), [1, 123, 0, 0.123]) + +# B + +assert_eq(call("B", 2, 12), [1, 1, 0, 0]) +assert_eq(call("B", [100, 1000], 12345), [[1, 23, 45], [12, 345]]) +assert_eq( + call("B", [0, 1, 2], [5, 10, 15]), + [[5], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1]], +) + +assert_eq(call("B", "12", 12), "2211") +assert_eq(call("B", ["ab", "cde", "fghi"], [12, 34, 56]), ["bbaa", "dced", "ihf"]) + +assert_eq(call("B", 2, "abcdefghijkl"), [1, 1, 0, 0]) +assert_eq(call("B", [0, 1, 2, 3], "zyxwv"), ["5", "00000", [1, 0, 1], [1, 2]]) + +assert_eq(call("B", "56", "abcdefghijkl"), "6655") +assert_eq(call("B", ["ab", "cde", "fghi"], "acegikmoqsuwy"), ["bbab", "ddd", "ig"]) + +# C + +assert_eq(call("C", 65), "A") +assert_eq(call("C", [104, 101, 108, 108, 111]), ["h", "e", "l", "l", "o"]) +assert_eq(call("C", [97, [66, [99, [68, [101]]]]]), ["a", ["B", ["c", ["D", ["e"]]]]]) + +assert_eq(call("C", "hello"), [104, 101, 108, 108, 111]) +assert_eq( + call("C", ["abc", ["def", ["ghi"]]]), + [[97, 98, 99], [[100, 101, 102], [[103, 104, 105]]]], +) + +assert_eq( + call("C", ["a", [97], "b", [98], "c", [99]]), + [[97], ["a"], [98], ["b"], [99], ["c"]], +) + +# D + +assert_eq(call("D", 10), 10, 10) +assert_eq(call("D", "abc"), "abc", "abc") +assert_eq(call("D", [1, 2, 3]), [1, 2, 3], [1, 2, 3]) + +# E + +assert_eq(call("E", 12), 1) +assert_eq(call("E", [1, 2, 3, 4, 5]), [0, 1, 0, 1, 0]) + +assert_eq(call("E", "[*range(5)]"), [0, 1, 2, 3, 4]) +assert_eq(call("E", ["abc", "[1, 2, 3]"]), [0, [1, 2, 3]]) + +assert_eq(call("E", ["12", 12, "34", 34]), [12, 1, 34, 1]) + +# F + +assert_eq(call("F", 24), [1, 2, 3, 4, 6, 8, 12, 24]) +assert_eq( + call("F", [5, 10, 15, 20]), + [[1, 5], [1, 2, 5, 10], [1, 3, 5, 15], [1, 2, 4, 5, 10, 20]], +) + +assert_eq( + call("F", "abcde"), + [ + "a", + "ab", + "abc", + "abcd", + "abcde", + "b", + "bc", + "bcd", + "bcde", + "c", + "cd", + "cde", + "d", + "de", + "e", + ], +) +assert_eq( + call("F", ["abc", "def", "ghi"]), + [ + ["a", "ab", "abc", "b", "bc", "c"], + ["d", "de", "def", "e", "ef", "f"], + ["g", "gh", "ghi", "h", "hi", "i"], + ], +) + +assert_eq(call("F", [10, "abc"]), [[1, 2, 5, 10], ["a", "ab", "abc", "b", "bc", "c"]]) + +# G + +assert_eq(call("G", 123), 3) +assert_eq(call("G", -6.54), 6) + +assert_eq(call("G", "abc"), "c") +assert_eq(call("G", ""), "") + +assert_eq(call("G", [1, 2, 3]), 3) +assert_eq(call("G", ["a", 2, "c"]), ["a", 2, "c"]) + +# H + +assert_eq(call("H", 81), 129) +assert_eq(call("H", "A0"), 160) + +assert_eq(call("H", [12, "34", 56]), [18, 52, 86]) +assert_eq( + call("H", [1234, [5678, ["9ABC", ["DEF0"]]]]), [4660, [22136, [39612, [57072]]]] +) + +# I + +assert_eq(call("I", 10, 5), [5, 6, 7, 8, 9, 10]) +assert_eq(call("I", -3, 3), [3, 2, 1, 0, -1, -2, -3]) + +assert_eq(call("I", 2, [0, 2, 4, 6, 8, 10]), [0, 4, 8]) +assert_eq(call("I", [0, 2, 4, 6, 8, 10], 9), [0]) + +assert_eq(call("I", 1, "abc"), "abc") +assert_eq(call("I", "abc", 2), "ac") + +assert_eq(call("I", "abc", "def"), "daebfc") +assert_eq(call("I", "abcxyz", "def"), "daebfcxyz") + +assert_eq(call("I", [1, 2, 3], [4, 5, 6]), [4, 1, 5, 2, 6, 3]) +assert_eq(call("I", [1], [2, 3, 4, 5, 6]), [2, 1, 3, 4, 5, 6]) + +# J + +assert_eq(call("J", 10), "10") + +assert_eq(call("J", "abc"), "abc") + +assert_eq(call("J", [1, 2, 3]), "123") +assert_eq(call("J", ["a", 2, "c"]), "a2c") +assert_eq(call("J", [[1, 2, 3], ["a", "b", "c"]]), "123abc") + +# L + +assert_eq(call("L", 10), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) +assert_eq(call("L", -5), [0, -1, -2, -3, -4]) +assert_eq( + call("L", [-3, -2, -1, 0, 1, 2, 3]), + [[0, -1, -2], [0, -1], [0], [], [0], [0, 1], [0, 1, 2]], +) + +assert_eq(call("L", "ABCDE"), "abcde") +assert_eq(call("L", ["aBc", "DeF", "gHi", "JkL"]), ["abc", "def", "ghi", "jkl"]) + +assert_eq( + call("L", [5, "abc", 10, "DEF"]), + [[0, 1, 2, 3, 4], "abc", [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], "def"], +) + +# M + +assert_eq(call("M", 123), 1) +assert_eq(call("M", -6.54), 4) + +assert_eq(call("M", "abc"), "a") +assert_eq(call("M", ""), "") + +assert_eq(call("M", [1, 2, 3]), 1) +assert_eq(call("M", ["a", 2, "c"]), ["a", 2, "c"]) + +# N + +assert_eq(call("N", 1.23), 1) +assert_eq(call("N", 123), 123) +assert_eq(call("N", [1.23, -4.56, 789.0]), [1, -4, 789]) + +assert_eq(call("N", "123"), 123) +assert_eq(call("N", "abc"), "abc") +assert_eq(call("N", ["123", "456", "abc"]), [123, 456, "abc"]) + +assert_eq(call("N", [1.23, "456", 7.89, "abc"]), [1, 456, 7, "abc"]) + +# O + +assert_eq(call("O", 10), 1024) +assert_eq(call("O", [-1, 0, 1, 2]), [0.5, 1, 2, 4]) + +assert_eq(call("O", "abc def ghi jkl"), ["abc", "def", "ghi", "jkl"]) +assert_eq( + call("O", ["abc def", "ghi jkl", "mno pqr"]), + [["abc", "def"], ["ghi", "jkl"], ["mno", "pqr"]], +) + +assert_eq(call("O", ["abc def ghi", 5, 7]), [["abc", "def", "ghi"], 32, 128]) + +# P + +assert_eq(call("P", 7), 1) +assert_eq(call("P", 10), 0) +assert_eq(call("P", [-3, -2, -1, 0, 1, 2, 3, 4]), [0, 0, 0, 0, 0, 1, 1, 0]) + +assert_eq(call("P", "Abc"), "aBC") +assert_eq(call("P", "DeF?!gHi"), "dEf?!GhI") +assert_eq(call("P", ["abc", "DEF", "ghi"]), ["ABC", "def", "GHI"]) + +assert_eq(call("P", [2.34, "", -1.23, "XyZ"]), [1, "", 0, "xYz"]) + +# Q + +assert_eq(call("Q", 1, 2), 1) +assert_eq(call("Q", 2, 2), 0) +assert_eq(call("Q", [1, 2, 3], [1, 3, 5]), [0, 1, 1]) + +assert_eq(call("Q", "abc", 2), 1) +assert_eq(call("Q", ["abc", "def", "ghi"], 2), [1, 1, 1]) + +assert_eq(call("Q", "abc", "abc"), 0) +assert_eq(call("Q", "abc", "def"), 1) +assert_eq(call("Q", ["abc", "def", "ghi"], ["abc", "xyz", "ghi"]), [0, 1, 0]) + +# R + +assert_eq(call("R", 5), [1, 2, 3, 4, 5]) +assert_eq(call("R", 1.23), [1]) +assert_eq(call("R", -5), [-1, -2, -3, -4, -5]) +assert_eq(call("R", [-2, -1, 0, 1, 2]), [[-1, -2], [-1], [], [1], [1, 2]]) + +assert_eq(call("R", "abcde"), "ABCDE") +assert_eq(call("R", ["aBc", "DeF", "gHi", "JkL"]), ["ABC", "DEF", "GHI", "JKL"]) + +assert_eq( + call("R", [5, "abc", 10, "DEF"]), + [[1, 2, 3, 4, 5], "ABC", [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], "DEF"], +) + +# S + +assert_eq(call("S", 123), 6) +assert_eq(call("S", -4.56), 15) + +assert_eq(call("S", [1, 2, 3]), 6) +assert_eq(call("S", [4, 5, 6]), 15) + +assert_eq(call("S", "abc"), "abc") +assert_eq(call("S", ["abc", 123, 456]), "abc123456") + +# T + +assert_eq(call("T"), 10) + +# U + +assert_eq(call("U", 123), 123) +assert_eq(call("U", -1.2123), -1.23) + +assert_eq(call("U", "abcdcba"), "abcd") +assert_eq(call("U", "zyxzyxzyxw"), "zyxw") + +assert_eq(call("U", [1, 2, 3, 2, 1]), [1, 2, 3]) +assert_eq(call("U", [123, "abc", 123, "abc"]), [123, "abc"]) +assert_eq(call("U", []), []) + +# V + +assert_eq(call("V", 123.456), 123) +assert_eq(call("V", -1.23), -1) +assert_eq(call("V", 456.789), 457) + +assert_eq(call("V", "Abc, Def?"), "Nop, Qrs?") +assert_eq(call("V", "..."), "...") + +assert_eq(call("V", ["abc", 1.0, "", "def", 0]), [0, 1, 3]) + +# W + +assert_eq(call("W", 1), [1]) +assert_eq(call("W", "abc"), ["abc"]) +assert_eq(call("W", [1, "a"]), [[1, "a"]]) + +# Z + +assert_eq(call("Z", 3, 5), [[5, 1], [5, 2], [5, 3]]) +assert_eq(call("Z", -3.45, 0.2), [[0.2, -1], [0.2, -2], [0.2, -3]]) + +assert_eq(call("Z", "abc", 5), [[1, "a"], [2, "b"], [3, "c"]]) +assert_eq(call("Z", "xyz", -2.34), [[-1, "x"], [-2, "y"]]) + +assert_eq(call("Z", [7, 8, 9], 5), [[1, 7], [2, 8], [3, 9]]) +assert_eq(call("Z", ["abc", "def", "ghi"], -2.34), [[-1, "abc"], [-2, "def"]]) + +assert_eq(call("Z", 5, "abc"), [["a", 1], ["b", 2], ["c", 3]]) +assert_eq(call("Z", -2.34, "xyz"), [["x", -1], ["y", -2]]) + +assert_eq(call("Z", 5, [7, 8, 9]), [[7, 1], [8, 2], [9, 3]]) +assert_eq(call("Z", -2.34, ["abc", "def", "ghi"]), [["abc", -1], ["def", -2]]) + +assert_eq(call("Z", "abc", "def"), [["d", "a"], ["e", "b"], ["f", "c"]]) +assert_eq(call("Z", "abc", [1, 2, 3, 4]), [[1, "a"], [2, "b"], [3, "c"]]) + +assert_eq( + call("Z", [9, 8, 7, 6], ["abc", "def", "ghi"]), [["abc", 9], ["def", 8], ["ghi", 7]] +) +assert_eq(call("Z", [1, 2, 3, 4], "abc"), [["a", 1], ["b", 2], ["c", 3]]) + +# a + +assert_eq(call("a", 2, 1), [1, 2]) +assert_eq(call("a", "abc", "def"), ["d", "e", "f", "abc"]) + +assert_eq(call("a", 5, [1, 2, 3, 4]), [1, 2, 3, 4, 5]) +assert_eq(call("a", "ghi", ["abc", "def"]), ["abc", "def", "ghi"]) + +# b + +assert_eq(call("b", 2, "1100"), 12) +assert_eq(call("b", [0, 1, 2], ["5", "0000000000", "1111"]), ["5", 10, 15]) + +assert_eq(call("b", "12", "2211"), 12) +assert_eq(call("b", ["ab", "cde", "fghi"], ["bbaa", "dced", "ihf"]), [12, 34, 56]) + +# c + +assert_eq(call("c", 5, 10), 252) +assert_eq(call("c", 10, 20), 184756) + +assert_eq(call("c", "abc", "abcbabcbabcba"), 3) +assert_eq(call("c", [123, 321], "1232123212321"), [3, 3]) + +assert_eq(call("c", 1, [1, 2, 3, 2, 1, 2, 3]), 2) +assert_eq(call("c", [1, "a"], [1, "a", 1, "b", 1, "c"]), [3, 1]) + +# d + +assert_eq(call("d", 123), [1, 2, 3]) +assert_eq(call("d", [-1.23, 1.23]), [[1, 2, 3], [1, 2, 3]]) + +assert_eq(call("d", "abc"), ["a", "b", "c"]) +assert_eq( + call("d", ["abc", "def", "ghi"]), + [["a", "b", "c"], ["d", "e", "f"], ["g", "h", "i"]], +) + +assert_eq( + call("d", [123, "abc", 456, "def"]), + [[1, 2, 3], ["a", "b", "c"], [4, 5, 6], ["d", "e", "f"]], +) + +# e + +assert_eq(call("e", 5), 100000) +assert_eq(call("e", [1, 2, 3, 4, 5]), [10, 100, 1000, 10000, 100000]) + +assert_eq(call("e", "abc,def,ghi"), ["abc", "def", "ghi"]) +assert_eq(call("e", ["abc,def", "123,456"]), [["abc", "def"], ["123", "456"]]) + +assert_eq( + call("e", ["123,456", -2, "abc,def", 2]), + [["123", "456"], 0.01, ["abc", "def"], 100], +) + +# f + +assert_eq(call("f", 100), [2, 2, 5, 5]) +assert_eq(call("f", 30), [2, 3, 5]) +assert_eq(call("f", [20, 25, 30, 35]), [[2, 2, 5], [5, 5], [2, 3, 5], [5, 7]]) + +assert_eq(call("f", "AbCd EfGh"), [1, 0, 1, 0, -1, 1, 0, 1, 0]) +assert_eq(call("f", ["Abc", "dEf", "!?."]), [[1, 0, 0], [0, 1, 0], [-1, -1, -1]]) + +assert_eq(call("f", [123, "aBc"]), [[3, 41], [0, 1, 0]]) + +# g + +assert_eq(call("g", 369), 3) + +assert_eq(call("g", "!@£$"), 1) + +assert_eq(call("g", [10, 15, 20, "abc"]), 5) + +# h + +assert_eq(call("h", 123), 1) + +assert_eq(call("h", "abc"), "a") + +assert_eq(call("h", [1, 2, 3]), 1) +assert_eq(call("h", []), []) + +# i + +assert_eq(call("i", 5, 1234567), 6) + +assert_eq(call("i", [1, 2, 3], 2), 3) +assert_eq( + call("i", [2, 4, 6], ["abc", "def", "ghi", "jkl", "mno"]), ["ghi", "mno", "def"] +) + +assert_eq(call("i", 10, "abcd"), "c") + +assert_eq(call("i", "abcde", "abc"), "c") + +# j + +assert_eq(call("j", "abc", [1, 2, 3, 4, 5]), "1abc2abc3abc4abc5") + +assert_eq(call("j", 0, "abc"), "a0b0c") + +assert_eq(call("j", "xyz", 123), "1xyz2xyz3") + +# l + +assert_eq(call("l", 123), 3) +assert_eq(call("l", 1.234), 5) + +assert_eq(call("l", "abcd"), 4) +assert_eq(call("l", ""), 0) + +assert_eq(call("l", [1, 2, 3]), 3) +assert_eq(call("l", [["a"]]), 1) + +# m + +assert_eq(call("m", -1.23), 2.0) + +assert_eq(call("m", "abc"), 98.0) + +assert_eq(call("m", [1, 2, 3, 4]), 2.5) +assert_eq(call("m", []), 0) + +# o + +assert_eq(call("o", 234, 12345), 15) +assert_eq(call("o", 0.12, -123.45), -123.45) + +assert_eq(call("o", "a", "abcbabcba"), "bcbbcb") +assert_eq(call("o", 0, "abcb0bcba"), "abcbbcba") + +assert_eq(call("o", 2, [1, 2, 3, 2, 1]), [1, 3, 1]) +assert_eq(call("o", ["abc", "def", "ghi"], "abc"), ["def", "ghi"]) + +# p + +assert_eq(call("p", 1234), 24) +assert_eq(call("p", -13.579), 945) + +assert_eq(call("p", "abc"), 941094) + +assert_eq(call("p", [1, 2, "abc", 3]), 6) + +# r + +assert_eq(call("r", 1.23), 32.1) +assert_eq(call("r", -456), "654-") +assert_eq(call("r", 3210), 123) + +assert_eq(call("r", "abcd"), "dcba") +assert_eq(call("r", ""), "") + +assert_eq(call("r", [1, 2, 3, 4]), [4, 3, 2, 1]) +assert_eq(call("r", [123, "abc", 456, "def"]), ["def", 456, "abc", 123]) + +# s + +assert_eq(call("s", 1, 2), 1, 2) +assert_eq(call("s", "abc", "def"), "abc", "def") +assert_eq(call("s", [1, 2, 3], 4), [1, 2, 3], 4) + +# t + +assert_eq(call("t", 123), 3) + +assert_eq(call("t", "abc"), "c") + +assert_eq(call("t", [1, 2, 3]), 3) +assert_eq(call("t", []), []) + +# u + +assert_eq(call("u"), -1) + +# v + +assert_eq(call("v", 123, 456, 1234567890), "1231237890") +assert_eq(call("v", 123, "abc", "abcdefghi"), "123defghi") +assert_eq(call("v", "", "a", "abcbabcba"), "bcbbcb") + +assert_eq(call("v", 0, 1, [1, 2, 1, 2, 1]), [0, 2, 0, 2, 0]) +assert_eq(call("v", 123, "abc", [1, 2, 1, 2, 1]), [1, 2, 1, 2, 1]) + +# w + +assert_eq(call("w", 5), 120) +assert_eq(call("w", [-1, 0, 1, 2, 3]), [1, 1, 1, 2, 6]) + +assert_eq(call("w", "a\t b\r\n c"), "abc") +assert_eq(call("w", ["a b \n c", "d\t e\nf"]), ["abc", "def"]) + +assert_eq(call("w", [10, "a b \n c \t d"]), [3628800, "abcd"]) + +# z + +assert_eq(call("z", 12345), [[1, 3, 5], [2, 4]]) +assert_eq(call("z", -6.789), [[6, 8], [7, 9]]) + +assert_eq(call("z", "abcdef"), ["ace", "bdf"]) +assert_eq(call("z", "xyz"), ["xz", "y"]) + +assert_eq(call("z", [1, 2, 3, 4]), [[1, 3], [2, 4]]) +assert_eq(call("z", []), [[], []]) + +# Ȧ + +assert_eq(call("Ȧ", 0.0), 0) +assert_eq(call("Ȧ", -1), 1) + +assert_eq(call("Ȧ", "abcd1234"), 1) +assert_eq(call("Ȧ", "xyz?"), 0) + +assert_eq(call("Ȧ", [0.0, "", "abc"]), 1) +assert_eq(call("Ȧ", ["", 0, []]), 0) + +# Ḃ + +assert_eq(call("Ḃ", 1010), 10) +assert_eq(call("Ḃ", [11001, 10101, 10011]), [25, 21, 19]) + +assert_eq(call("Ḃ", "11111"), 31) +assert_eq(call("Ḃ", ["1", 10, "11", 100, "101"]), [1, 2, 3, 4, 5]) + +# Ċ + +assert_eq(call("Ċ", 200), "Ṁ") +assert_eq(call("Ċ", [500, 1000, 1500]), ["ṡ", "ċ", "ṇ"]) + +assert_eq(call("Ċ", "abcd"), [97, 98, 99, 100]) +assert_eq(call("Ċ", ["abcd", "ĖḞĠḢ"]), [[97, 98, 99, 100], [194, 195, 196, 197]]) + +assert_eq(call("Ċ", [1, "2", 3, "4"]), ["¢", [50], "¤", [52]]) + +# Ḋ + +assert_eq(call("Ḋ", 3, 6), 1) +assert_eq(call("Ḋ", 2, 5), 0) +assert_eq(call("Ḋ", [1, 2, 3, 4, 5], 10), [1, 1, 0, 0, 1]) + +assert_eq(call("Ḋ", "abc", 12), 1) +assert_eq(call("Ḋ", 5, "abcdefgh"), 0) +assert_eq(call("Ḋ", "abc", "abcdef"), 1) + +# Ė + +assert_eq(call("Ė", 10), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) +assert_eq(call("Ė", -5), [0, -1, -2, -3, -4, -5]) + +assert_eq(call("Ė", "abcd"), [[0, "a"], [1, "b"], [2, "c"], [3, "d"]]) +assert_eq(call("Ė", ""), []) + +assert_eq(call("Ė", [123, 456, 789]), [[0, 123], [1, 456], [2, 789]]) +assert_eq(call("Ė", ["abc", "def", "ghi"]), [[0, "abc"], [1, "def"], [2, "ghi"]]) + +# Ḟ + +assert_eq(call("Ḟ", 1234), 1234) +assert_eq(call("Ḟ", "abcd"), "abcd") + +assert_eq(call("Ḟ", [1, 2, 3, 4, 5]), [1, 2, 3, 4, 5]) +assert_eq( + call("Ḟ", [["abc", "def"], [1, 2, 3], ["ghi", "jkl"], [4, 5, 6]]), + ["abc", "def", 1, 2, 3, "ghi", "jkl", 4, 5, 6], +) + +assert_eq(call("Ḟ", [0, [1, [2, [3, [4, [5]]]]], 6]), [0, 1, 2, 3, 4, 5, 6]) + +# Ġ + +assert_eq(call("Ġ", 12, 21), 3) +assert_eq(call("Ġ", [10, 12, 14, 16, 18, 20], 8), [2, 4, 2, 8, 2, 4]) + +assert_eq(call("Ġ", "ABC", 20), [5, 2, 1]) + +# Ḣ + +assert_eq(call("Ḣ", 123), 23, 1) + +assert_eq(call("Ḣ", "abc"), "bc", "a") + +assert_eq(call("Ḣ", [1, 2, 3]), [2, 3], 1) +assert_eq(call("Ḣ", []), []) + +# İ + +assert_eq(call("İ", 5, 1234567), 5) + +assert_eq(call("İ", [1, 2, 3], 2), 2) +assert_eq( + call("İ", [2, 4, 6], ["abc", "def", "ghi", "jkl", "mno"]), ["def", "jkl", "abc"] +) + +assert_eq(call("İ", 10, "abcd"), "b") + +assert_eq(call("İ", "abcde", "abc"), "b") + +# Ŀ + +assert_eq(call("Ŀ", 5, "a", "abc"), "abcaa") +assert_eq( + call("Ŀ", [-3, -2, -1, 0, 1, 2, 3], "def", "x"), + ["xdd", "xd", "x", "x", "x", "xd", "xdd"], +) +assert_eq( + call("Ŀ", [5, 6, 7, 8], ["abc", "def", "ghi", ""], "xyz"), + ["xyzaa", "xyzddd", "xyzgggg", "xyz "], +) + +# Ṁ + +assert_eq(call("Ṁ", 123.1231), 1) +assert_eq(call("Ṁ", 456), 4) + +assert_eq(call("Ṁ", "cbbaaa"), "a") +assert_eq(call("Ṁ", ""), "") + +assert_eq(call("Ṁ", [4, 7, 5, 5, 1, 3, 8, 6, 2, 1, 3, 8, 3, 2, 9]), 3) + +# Ṅ + +assert_eq(call("Ṅ", 123), -123) +assert_eq(call("Ṅ", [-3, -2, -1, 0, 1, 2, 3]), [3, 2, 1, 0, -1, -2, -3]) +assert_eq( + call("Ṅ", [-1.23, [2.34, [-3.45, [4.56, [-5.67, [6.78, [-7.89]]]]]]]), + [1.23, [-2.34, [3.45, [-4.56, [5.67, [-6.78, [7.89]]]]]]], +) + +assert_eq(call("Ṅ", "abbcccbba"), [1, 2, 3, 2, 1]) +assert_eq(call("Ṅ", ["aab", "aba", "baa"]), [[2, 1], [1, 1, 1], [1, 2]]) + +# Ȯ + +assert_eq(call("Ȯ", 2, 123), 1) +assert_eq(call("Ȯ", 4, 123), -1) + +assert_eq(call("Ȯ", "abc", "cbabcba"), 2) +assert_eq(call("Ȯ", 8, [4, 7, 5, 5, 1, 3, 8, 6, 2, 1, 3, 8, 3, 2, 9]), 6) + +# Ṗ + +assert_eq( + call("Ṗ", 5, 3), + [ + [1, 1], + [1, 2], + [1, 3], + [1, 4], + [1, 5], + [2, 1], + [2, 2], + [2, 3], + [2, 4], + [2, 5], + [3, 1], + [3, 2], + [3, 3], + [3, 4], + [3, 5], + ], +) +assert_eq( + call("Ṗ", "def", "abc"), + [ + ["a", "d"], + ["a", "e"], + ["a", "f"], + ["b", "d"], + ["b", "e"], + ["b", "f"], + ["c", "d"], + ["c", "e"], + ["c", "f"], + ], +) +assert_eq( + call("Ṗ", 3, ["abc", "def", "ghi"]), + [ + ["abc", 1], + ["abc", 2], + ["abc", 3], + ["def", 1], + ["def", 2], + ["def", 3], + ["ghi", 1], + ["ghi", 2], + ["ghi", 3], + ], +) + +# Ṙ + +assert_eq(call("Ṙ", 123), "123") +assert_eq(call("Ṙ", "abc"), '"abc"') +assert_eq(call("Ṙ", '"abc"'), '"\\"abc\\""') +assert_eq(call("Ṙ", [123, ['"abc"', "'abc'"]]), '[123, ["\\"abc\\"", "\'abc\'"]]') + +# Ṡ + +assert_eq(call("Ṡ", 456.321), 123456) + +assert_eq(call("Ṡ", "Thunno 2 is the best!"), " !2Tbeehhinnossttu") +assert_eq( + call("Ṡ", [4, 7, 5, 5, 1, 3, 8, 6, 2, 1, 3, 8, 3, 2, 9]), + [1, 1, 2, 2, 3, 3, 3, 4, 5, 5, 6, 7, 8, 8, 9], +) + +# Ṫ + +assert_eq(call("Ṫ", 123), 12, 3) + +assert_eq(call("Ṫ", "abc"), "ab", "c") + +assert_eq(call("Ṫ", [1, 2, 3]), [1, 2], 3) +assert_eq(call("Ṫ", []), []) + +# Ẇ + +assert_eq(call("Ẇ", 3, 10), [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]) + +assert_eq(call("Ẇ", "abcbabcbabcba", 5), ["abc", "bab", "cba", "bc", "ba"]) +assert_eq(call("Ẇ", 5, "abc"), ["a", "b", "c"]) + +assert_eq( + call("Ẇ", [4, 7, 5, 5, 1, 3, 8, 6, 2, 1, 3, 8, 3, 2, 9], 6), + [[4, 7, 5], [5, 1, 3], [8, 6, 2], [1, 3], [8, 3], [2, 9]], +) + +# Ż + +assert_eq(call("Ż", 13579), 13579, [0, 1, 2, 3, 4]) +assert_eq(call("Ż", "abc"), "abc", [0, 1, 2]) +assert_eq( + call("Ż", ["x", "y", "z", 1, 2, 3]), ["x", "y", "z", 1, 2, 3], [0, 1, 2, 3, 4, 5] +) + +# , + +assert_eq(call(",", 1, 2), [2, 1]) +assert_eq(call(",", "abc", "def"), ["def", "abc"]) + +# ⁺ + +assert_eq(call("⁺", 123), 124) +assert_eq(call("⁺", [10, 20, 30, 40, 50]), [11, 21, 31, 41, 51]) + +assert_eq(call("⁺", "abc"), "bcd") +assert_eq(call("⁺", "123ABC"), "234BCD") + +# ⁻ + +assert_eq(call("⁻", 124), 123) +assert_eq(call("⁻", [11, 21, 31, 41, 51]), [10, 20, 30, 40, 50]) + +assert_eq(call("⁻", "bcd"), "abc") +assert_eq(call("⁻", "234BCD"), "123ABC") + +# ⁼ + +assert_eq(call("⁼", 1, 2), 0) +assert_eq(call("⁼", 2, 2), 1) +assert_eq(call("⁼", [1, 2, 3], [1, 3, 5]), 0) + +assert_eq(call("⁼", "abc", 2), 0) +assert_eq(call("⁼", ["abc", "def", "ghi"], 2), 0) + +assert_eq(call("⁼", "abc", "abc"), 1) +assert_eq(call("⁼", "abc", "def"), 0) +assert_eq(call("⁼", ["abc", "def", "ghi"], ["abc", "xyz", "ghi"]), 0) +assert_eq(call("⁼", ["abc", "def"], ["abc", "def"]), 1) + +# + + +assert_eq(call("+", 1, 2), 3) +assert_eq(call("+", [1, 2, 3, 4], 5), [6, 7, 8, 9]) +assert_eq(call("+", [1, 2, 3], [4, 5, 6]), [5, 7, 9]) + +assert_eq(call("+", "abc", 123), "123abc") +assert_eq(call("+", "def", "abc"), "abcdef") +assert_eq(call("+", [12, 34, 56, 78], "xyz"), ["xyz12", "xyz34", "xyz56", "xyz78"]) +assert_eq(call("+", ["abc", "xyz"], ["def", "uvw"]), ["defabc", "uvwxyz"]) + +# - + +assert_eq(call("-", 5, 3), -2) +assert_eq(call("-", [3, 4, 5], 10), [7, 6, 5]) +assert_eq(call("-", [1, 2, 3], [4, 5, 6]), [3, 3, 3]) + +assert_eq(call("-", 2, "abcde"), "abc") +assert_eq(call("-", [3, 4, 5], "abcde"), ["ab", "a", ""]) +assert_eq(call("-", "abcde", 2), "cde") +assert_eq(call("-", "abcde", [3, 4, 5]), ["de", "e", ""]) + +assert_eq(call("-", ["ab", "bc"], "abcbabc"), ["cbc", "aba"]) + +# × + +assert_eq(call("×", 2.5, 2), 5.0) +assert_eq(call("×", [1, 2, 3, 4, 5], 3), [3, 6, 9, 12, 15]) + +assert_eq(call("×", 3, "abc"), "abcabcabc") +assert_eq( + call("×", ["abc", "def", "ghi"], [2, 3, 4]), ["abcabc", "defdefdef", "ghighighighi"] +) + +assert_eq(call("×", "ab", "cd"), ["ca", "cb", "da", "db"]) +assert_eq( + call("×", [1, "ab", 2, "cd"], "ef"), + ["ef", ["ea", "eb", "fa", "fb"], "efef", ["ec", "ed", "fc", "fd"]], +) + +# / + +assert_eq(call("/", 2, 1), 0.5) +assert_eq(call("/", [1, 2, 5, 10], 10), [10.0, 5.0, 2.0, 1.0]) + +assert_eq(call("/", 2, "abcde"), ["abc", "de"]) +assert_eq( + call("/", [-1, 0, 1, 2, 3], "abcdefghij"), + [ + "abcdefghij", + "abcdefghij", + ["abcdefghij"], + ["abcde", "fghij"], + ["abcd", "efg", "hij"], + ], +) + +assert_eq(call("/", "b", "abcbabcba"), ["a", "c", "a", "c", "a"]) +assert_eq( + call("/", ["a", "ab", "abc"], "abcbabcba"), + [["", "bcb", "bcb", ""], ["", "cb", "cba"], ["", "b", "ba"]], +) + +# * + +assert_eq(call("*", 3, 5), 125) +assert_eq(call("*", [0.25, 0.5, 1, 2], 16), [2.0, 4.0, 16, 256]) + +assert_eq(call("*", 5, "abc"), "abcaa") +assert_eq(call("*", ["abc", "defghi", ""], 4), ["abca", "defghi", " "]) + +assert_eq(call("*", "\\d+", "123abcd7890"), ["123", "7890"]) + +assert_eq(call("*", [], []), []) + +# % + +assert_eq(call("%", 3, 10), 1) +assert_eq(call("%", [1, 2, 3, 4, 5], 13), [0, 1, 1, 1, 3]) + +assert_eq(call("%", 123, "abc%def"), "abc123def") +assert_eq( + call("%", "abc", ["123%456", "%%%", "ab%c"]), ["123abc456", "abcabcabc", "ababcc"] +) + +# ÷ + +assert_eq(call("÷", 2, 5), 2) +assert_eq( + call("÷", [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 97), + [97, 48, 32, 24, 19, 16, 13, 12, 10, 9], +) + +assert_eq(call("÷", 2, "abcde"), "abc") +assert_eq( + call("÷", [-1, 0, 1, 2, 3], "abcdefghij"), ["a", "a", "abcdefghij", "abcde", "abcd"] +) + +assert_eq(call("÷", "b", "abcbabcba"), "a") +assert_eq(call("÷", ["a", "ab", "abc"], "abcbabcba"), ["", "", ""]) + +# _ + +assert_eq(call("_", 5, 3), 2) +assert_eq(call("_", [3, 4, 5], 10), [-7, -6, -5]) +assert_eq(call("_", [1, 2, 3], [4, 5, 6]), [-3, -3, -3]) + +assert_eq(call("_", 2, "abcde"), "cde") +assert_eq(call("_", [3, 4, 5], "abcde"), ["de", "e", ""]) +assert_eq(call("_", "abcde", 2), "abc") +assert_eq(call("_", "abcde", [3, 4, 5]), ["ab", "a", ""]) + +assert_eq(call("_", ["ab", "bc"], "abcbabc"), ["ab", "bc"]) + +# \ + +assert_eq(call("\\", 2, 1), 2.0) +assert_eq(call("\\", [1, 2, 5, 10], 10), [0.1, 0.2, 0.5, 1.0]) + +assert_eq(call("\\", 2, "abcde"), ["abc", "de"]) +assert_eq( + call("\\", [-1, 0, 1, 2, 3], "abcdefghij"), + [ + "abcdefghij", + "abcdefghij", + ["abcdefghij"], + ["abcde", "fghij"], + ["abcd", "efg", "hij"], + ], +) + +assert_eq(call("\\", "b", "abcbabcba"), ["b"]) +assert_eq(call("\\", ["a", "ab", "abc"], "abcbabcba"), [["a"], ["ab"], ["abc"]]) + +# @ + +assert_eq(call("@", 3, 5), 243) +assert_eq( + call("@", [0.25, 0.5, 1, 2], 16), + [2.3283064365386963e-10, 1.52587890625e-05, 1, 65536], +) + +assert_eq(call("@", 5, "abc"), "abcaa") +assert_eq(call("@", ["abc", "defghi", ""], 4), ["cabc", "defghi", " "]) + +assert_eq(call("@", "\\d+", "123abcd7890"), []) + +# Œ + +assert_eq(call("Œ", 3, 10), 3) +assert_eq(call("Œ", [1, 2, 3, 4, 5], 13), [1, 2, 3, 4, 5]) + +assert_eq(call("Œ", 123, "abc%def"), "abc123def") +assert_eq(call("Œ", "abc", ["123%456", "%%%", "ab%c"]), ["abc", "abc", "abc"]) + +# ¦ + +assert_eq(call("¦", 2, 5), 0) +assert_eq( + call("¦", [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 97), [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +) + +assert_eq(call("¦", 2, "abcde"), "de") +assert_eq( + call("¦", [-1, 0, 1, 2, 3], "abcdefghij"), ["j", "j", "abcdefghij", "fghij", "hij"] +) + +assert_eq(call("¦", "b", "abcbabcba"), "a") +assert_eq(call("¦", ["a", "ab", "abc"], "abcbabcba"), ["", "cba", "ba"]) + +# = + +assert_eq(call("=", 1, 2), 0) +assert_eq(call("=", 2, 2), 1) +assert_eq(call("=", [1, 2, 3], [1, 3, 5]), [1, 0, 0]) + +assert_eq(call("=", "abc", 2), 0) +assert_eq(call("=", ["abc", "def", "ghi"], 2), [0, 0, 0]) + +assert_eq(call("=", "abc", "abc"), 1) +assert_eq(call("=", "abc", "def"), 0) +assert_eq(call("=", ["abc", "def", "ghi"], ["abc", "xyz", "ghi"]), [1, 0, 1]) + +# < + +assert_eq(call("<", 1, 2), 0) +assert_eq(call("<", 2, 2), 0) +assert_eq(call("<", 3, 2), 1) + +assert_eq(call("<", 98, "abc"), [1, 0, 0]) +assert_eq( + call("<", [67, 68, 69], "ABCDE"), + [[1, 1, 0, 0, 0], [1, 1, 1, 0, 0], [1, 1, 1, 1, 0]], +) + +assert_eq(call("<", "abc", "def"), 0) +assert_eq(call("<", ["xyz", "abc"], "def"), [1, 0]) + +# > + +assert_eq(call(">", 1, 2), 1) +assert_eq(call(">", 2, 2), 0) +assert_eq(call(">", 3, 2), 0) + +assert_eq(call(">", 98, "abc"), [0, 0, 1]) +assert_eq( + call(">", [67, 68, 69], "ABCDE"), + [[0, 0, 0, 1, 1], [0, 0, 0, 0, 1], [0, 0, 0, 0, 0]], +) + +assert_eq(call(">", "abc", "def"), 1) +assert_eq(call(">", ["xyz", "abc"], "def"), [0, 1]) + +# © + +assert_eq(call("©", 1, 2), 0) +assert_eq(call("©", 2, 2), 1) +assert_eq(call("©", 3, 2), 1) + +assert_eq(call("©", 98, "abc"), [1, 1, 0]) +assert_eq( + call("©", [67, 68, 69], "ABCDE"), + [[1, 1, 1, 0, 0], [1, 1, 1, 1, 0], [1, 1, 1, 1, 1]], +) + +assert_eq(call("©", "abc", "def"), 0) +assert_eq(call("©", ["xyz", "abc"], "def"), [1, 0]) + +# ® + +assert_eq(call("®", 1, 2), 1) +assert_eq(call("®", 2, 2), 1) +assert_eq(call("®", 3, 2), 0) + +assert_eq(call("®", 98, "abc"), [0, 1, 1]) +assert_eq( + call("®", [67, 68, 69], "ABCDE"), + [[0, 0, 1, 1, 1], [0, 0, 0, 1, 1], [0, 0, 0, 0, 1]], +) + +assert_eq(call("®", "abc", "def"), 1) +assert_eq(call("®", ["xyz", "abc"], "def"), [0, 1]) + +# & + +assert_eq(call("&", 123, 456), 123) +assert_eq(call("&", 123, 0), 0) + +assert_eq(call("&", -123, "abc"), -123) +assert_eq(call("&", "xyz", 0), 0) + +assert_eq(call("&", [-1, 0, 1], ["abc", "def", ""]), [-1, 0, ""]) + +# | + +assert_eq(call("|", 123, 456), 456) +assert_eq(call("|", 123, 0), 123) + +assert_eq(call("|", -123, "abc"), "abc") +assert_eq(call("|", "xyz", 0), "xyz") + +assert_eq(call("|", [-1, 0, 1], ["abc", "def", ""]), ["abc", "def", 1]) + +# ^ + +assert_eq(call("^", 12345), [1, 3, 5], [2, 4]) +assert_eq(call("^", -6.789), [6, 8], [7, 9]) + +assert_eq(call("^", "abcdef"), "ace", "bdf") +assert_eq(call("^", "xyz"), "xz", "y") + +assert_eq(call("^", [1, 2, 3, 4]), [1, 3], [2, 4]) +assert_eq(call("^", []), [], []) + +# ~ + +assert_eq(call("~", 123), 0) +assert_eq(call("~", 0), 1) + +assert_eq(call("~", "abc"), 0) +assert_eq(call("~", ""), 1) + +assert_eq(call("~", [-1, 0, 1, 2, "", "a"]), [0, 1, 0, 0, 1, 0]) + +# ð + +assert_eq(call("ð"), " ") + +# Ð + +assert_eq(call("Ð", 10), 10, 10, 10) +assert_eq(call("Ð", "abc"), "abc", "abc", "abc") +assert_eq(call("Ð", [1, 2, 3]), [1, 2, 3], [1, 2, 3], [1, 2, 3]) + +# ȧ + +assert_eq(call("ȧ", 5, 2, [1, 2, 3, 4, 5]), [1, 2, 5, 4, 5]) +assert_eq(call("ȧ", "x", "abc", 11), "abx") + +assert_eq(call("ȧ", "abc", "def", "ghijkl"), "ghiabckl") +assert_eq(call("ȧ", 123, 4, 56789), [5, 6, 7, 8, 123]) + +# ḃ + +assert_eq(call("ḃ", 10), "1010") +assert_eq( + call("ḃ", [50, 60, 70, 80, 90]), + ["110010", "111100", "1000110", "1010000", "1011010"], +) + +assert_eq(call("ḃ", "abcde"), ["1100001", "1100010", "1100011", "1100100", "1100101"]) +assert_eq( + call("ḃ", [-1, "abc", -2, "def", -3]), + [ + "-1", + ["1100001", "1100010", "1100011"], + "-10", + ["1100100", "1100101", "1100110"], + "-11", + ], +) + +# ċ + +assert_eq( + call("ċ", 3, 5), + [ + [1, 2, 3], + [1, 2, 4], + [1, 2, 5], + [1, 3, 4], + [1, 3, 5], + [1, 4, 5], + [2, 3, 4], + [2, 3, 5], + [2, 4, 5], + [3, 4, 5], + ], +) +assert_eq(call("ċ", "xyz", 2), [["x", "y"], ["x", "z"], ["y", "z"]]) +assert_eq(call("ċ", 10, [1, 2, 3]), [[1, 2, 3]]) + +assert_eq(call("ċ", "abcde", "cdefg"), ["c", "d", "e", "f", "g", "a", "b"]) +assert_eq(call("ċ", [3, 4, 5], [1, 2, 3]), [1, 2, 3, 4, 5]) + +# ḋ + +assert_eq(call("ḋ", 15, 99), [6, 9]) + +assert_eq(call("ḋ", 5, [1, 2, 3]), 38) +assert_eq(call("ḋ", [10, 20, 30], -2), 30) + +# ė + +assert_eq(call("ė", 5), [1, 2, 3, 4]) +assert_eq(call("ė", "abc"), [1, 2, 3]) +assert_eq(call("ė", []), []) + +# ḟ + +assert_eq(call("ḟ", 60), [2, 1, 1]) +assert_eq( + call("ḟ", [10, 11, 12, 13, 14]), + [[1, 0, 1], [0, 0, 0, 0, 1], [2, 1], [0, 0, 0, 0, 0, 1], [1, 0, 0, 1]], +) + +assert_eq(call("ḟ", "abc def ghi jkl"), "Abc Def Ghi Jkl") + +# ġ + +assert_eq(call("ġ", 1122231), [[1, 1], [2, 2, 2], [3], [1]]) +assert_eq(call("ġ", "aabbbca"), ["aa", "bbb", "c", "a"]) +assert_eq(call("ġ", [1, 2, 3]), [[1], [2], [3]]) + +# ḣ + +assert_eq(call("ḣ", 123), 23) + +assert_eq(call("ḣ", "abc"), "bc") + +assert_eq(call("ḣ", [1, 2, 3]), [2, 3]) +assert_eq(call("ḣ", []), []) + +# ŀ + +assert_eq(call("ŀ", 369), 18) + +assert_eq(call("ŀ", "!@"), 2112) + +assert_eq(call("ŀ", [10, 15, 20, "abc"]), 60) + +# ṁ + +assert_eq(call("ṁ", 1470369258), 4.5) +assert_eq(call("ṁ", "abc"), 98) +assert_eq(call("ṁ", [1, 4, 3, 2]), 2.5) + +# ȯ + +assert_eq(call("ȯ", 2, 1.2345), 1.23) + +assert_eq(call("ȯ", 5, [-1, 1, 3, 5, 7]), [1, 3, 5]) +assert_eq(call("ȯ", [10, 9, 8, 7], 6), []) + +assert_eq(call("ȯ", "abcde", "gfedc"), ["e", "d", "c"]) + +# ṗ + +assert_eq( + call("ṗ", 2, 5), + [ + [1, 2], + [1, 3], + [1, 4], + [1, 5], + [2, 1], + [2, 3], + [2, 4], + [2, 5], + [3, 1], + [3, 2], + [3, 4], + [3, 5], + [4, 1], + [4, 2], + [4, 3], + [4, 5], + [5, 1], + [5, 2], + [5, 3], + [5, 4], + ], +) +assert_eq( + call("ṗ", "xyz", 2), + [["x", "y"], ["x", "z"], ["y", "x"], ["y", "z"], ["z", "x"], ["z", "y"]], +) +assert_eq( + call("ṗ", 10, [1, 2, 3]), + [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]], +) + +assert_eq(call("ṗ", "abcde", "cdefg"), ["f", "g"]) +assert_eq(call("ṗ", [3, 4, 5], [1, 2, 3]), [1, 2]) + +# ṙ + +assert_eq(call("ṙ", 5, "a", "abc"), "aaabc") +assert_eq( + call("ṙ", [-3, -2, -1, 0, 1, 2, 3], "def", "x"), + ["ddx", "dx", "x", "x", "x", "dx", "ddx"], +) +assert_eq( + call("ṙ", [5, 6, 7, 8], ["abc", "def", "ghi", ""], "xyz"), + ["aaxyz", "dddxyz", "ggggxyz", " xyz"], +) + +# ṡ + +assert_eq(call("ṡ", 135420), [1, 4, 9, 13, 15, 15]) + +assert_eq(call("ṡ", "abcd"), ["a", "ab", "abc", "abcd"]) + +assert_eq( + call("ṡ", [1, 4, 7, 0, 3, 6, 9, 2, 5, 8]), [1, 5, 12, 12, 15, 21, 30, 32, 37, 45] +) +assert_eq( + call("ṡ", [1, 4, 7, 0, 3, 6, 9, 2, 5, "8"]), + [ + "1", + "14", + "147", + "1470", + "14703", + "147036", + "1470369", + "14703692", + "147036925", + "1470369258", + ], +) + +# ṫ + +assert_eq(call("ṫ", 123), 12) + +assert_eq(call("ṫ", "abc"), "ab") + +assert_eq(call("ṫ", [1, 2, 3]), [1, 2]) +assert_eq(call("ṫ", []), []) + +# ẇ + +assert_eq(call("ẇ", 3, 10), [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]) + +assert_eq(call("ẇ", "abcbabcbabcba", 5), ["abcba", "bcbab", "cba"]) +assert_eq(call("ẇ", 5, "abc"), ["abc"]) + +assert_eq( + call("ẇ", [4, 7, 5, 5, 1, 3, 8, 6, 2, 1, 3, 8, 3, 2, 9], 6), + [[4, 7, 5, 5, 1, 3], [8, 6, 2, 1, 3, 8], [3, 2, 9]], +) + +# ż + +assert_eq(call("ż", 13579), 13579, [1, 2, 3, 4, 5]) +assert_eq(call("ż", "abc"), "abc", [1, 2, 3]) +assert_eq( + call("ż", ["x", "y", "z", 1, 2, 3]), ["x", "y", "z", 1, 2, 3], [1, 2, 3, 4, 5, 6] +) + +# Ạ + +assert_eq(call("Ạ"), "abcdefghijklmnopqrstuvwxyz") + +# Ḅ + +assert_eq(call("Ḅ", 2, 14), "1110") +assert_eq(call("Ḅ", [5, 10, 15, 20], [28, 29, 30, 31]), ["103", "29", "20", "1B"]) + +assert_eq(call("Ḅ", 3, "abcd"), "aaabbbcccddd") +assert_eq(call("Ḅ", ["abc", "xyz"], 2), ["aabbcc", "xxyyzz"]) + +assert_eq(call("Ḅ", "\\d+", "abc123def456ghi"), ["abc", "def", "ghi"]) + +# Ḍ + +assert_eq(call("Ḍ", 5), 10) +assert_eq(call("Ḍ", "abc"), "abcabc") +assert_eq(call("Ḍ", [123, "abc", 456, "def"]), [246, "abcabc", 912, "defdef"]) + +# Ẹ + +assert_eq(call("Ẹ", 1234), 1, 2, 3, 4) +assert_eq(call("Ẹ", -789.123), 7, 8, 9, 1, 2, 3) + +assert_eq(call("Ẹ", "abcde"), "a", "b", "c", "d", "e") +assert_eq(call("Ẹ", "")) + +assert_eq(call("Ẹ", [1, 2, 3, 4, 5]), 1, 2, 3, 4, 5) + +# Ḥ + +assert_eq(call("Ḥ", 10), "a") +assert_eq(call("Ḥ", [50, 60, 70, 80, 90]), ["32", "3c", "46", "50", "5a"]) + +assert_eq(call("Ḥ", "abcde"), ["61", "62", "63", "64", "65"]) +assert_eq( + call("Ḥ", [-1, "abc", -2, "def", -3]), + ["-1", ["61", "62", "63"], "-2", ["64", "65", "66"], "-3"], +) + +# Ị + +assert_eq(call("Ị", 5), 0.2) +assert_eq(call("Ị", [-2, -1, 1, 2]), [-0.5, -1.0, 1.0, 0.5]) + +assert_eq(call("Ị", "Hello, World!"), "HelloWorld") + +# Ḳ + +assert_eq(call("Ḳ", 1.23), 1.23, 32.1) +assert_eq(call("Ḳ", -456), -456, "654-") + +assert_eq(call("Ḳ", "abcd"), "abcd", "dcba") +assert_eq(call("Ḳ", ""), "", "") + +assert_eq(call("Ḳ", [1, 2, 3, 4]), [1, 2, 3, 4], [4, 3, 2, 1]) +assert_eq( + call("Ḳ", [123, "abc", 456, "def"]), + [123, "abc", 456, "def"], + ["def", 456, "abc", 123], +) + +# Ḷ + +assert_eq(call("Ḷ", 12, 21), 84) +assert_eq(call("Ḷ", 30, [18, 19, 20, 21, 22]), [90, 570, 60, 210, 330]) + +assert_eq( + call("Ḷ", "abc", [10, 11, 12]), + [[970, 490, 990], [1067, 1078, 99], [1164, 588, 396]], +) + +# Ṃ + +assert_eq(call("Ṃ", 1.23), "1.2332.1") +assert_eq(call("Ṃ", -456), "-456654-") +assert_eq(call("Ṃ", 1234), 12344321) + +assert_eq(call("Ṃ", "abcd"), "abcddcba") +assert_eq(call("Ṃ", ""), "") + +assert_eq(call("Ṃ", [1, 2, 3, 4]), [1, 2, 3, 4, 4, 3, 2, 1]) +assert_eq( + call("Ṃ", [123, "abc", 456, "def"]), + [123, "abc", 456, "def", "def", 456, "abc", 123], +) + +# Ṇ + +assert_eq( + call( + "Ṇ", "ZYXWVUTSRQPONMLKJIHGFEDCBA", "ABCDEFGHIJKLMNOPQRSTUVWXYZ", "HELLO, WORLD!" + ), + "SVOOL, DLIOW!", +) +assert_eq(call("Ṇ", "wxyz", 4321, "abcd1234"), "abcdzyxw") +assert_eq( + call("Ṇ", "abc", 123, ["1", "9", "4", "7", "8", "5", "6", "2", "3"]), + ["a", "9", "4", "7", "8", "5", "6", "b", "c"], +) +assert_eq(call("Ṇ", 456, [1, "y", 3], "123xyz"), "426x5z") + +# Ọ + +assert_eq(call("Ọ", 123, 456), 123) +assert_eq(call("Ọ", -1.23, -4.56), -4.56) + +assert_eq(call("Ọ", "abcd", "efgh"), "abcd") +assert_eq(call("Ọ", "abc", "aac"), "aac") + +assert_eq(call("Ọ", "abc", 123), 123) +assert_eq(call("Ọ", 123, ""), "") + +assert_eq( + call("Ọ", [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]), + [1, 2, 3, 4, 5, 5, 4, 3, 2, 1], +) + +# Ṛ + +assert_eq(call("Ṛ", 3, 2), [[1, 1], [1, 2], [2, 2]]) + +assert_eq( + call("Ṛ", "xyz", 2), + [["x", "x"], ["x", "y"], ["x", "z"], ["y", "y"], ["y", "z"], ["z", "z"]], +) + +assert_eq( + call("Ṛ", 10, [1, 2, 3]), + [ + [1, 1, 1], + [1, 1, 2], + [1, 1, 3], + [1, 2, 2], + [1, 2, 3], + [1, 3, 3], + [2, 2, 2], + [2, 2, 3], + [2, 3, 3], + [3, 3, 3], + ], +) + +# Ṣ + +assert_eq(call("Ṣ", 3.141592653589), [-2, 3, -3, 4, 4, -7, 4, -1, -2, 2, 3, 1]) + +assert_eq(call("Ṣ", "thunno"), [-12, 13, -7, 0, 1]) + +assert_eq( + call("Ṣ", [100, 50, 25, 12, 6, 3, 2, 1, 0]), [-50, -25, -13, -6, -3, -1, -1, -1] +) + +# Ṭ + +assert_eq(call("Ṭ", 123), [[1, 2, 3]]) +assert_eq(call("Ṭ", "abc"), [["a", "b", "c"]]) +assert_eq(call("Ṭ", []), []) + +assert_eq(call("Ṭ", [1, 2, 3, 4]), [[1, 2, 3, 4]]) +assert_eq(call("Ṭ", [123, 456, 789]), [[1, 4, 7], [2, 5, 8], [3, 6, 9]]) + +assert_eq( + call("Ṭ", ["abc", "defg", "hijkl"]), + [["a", "d", "h"], ["b", "e", "i"], ["c", "f", "j"]], +) +assert_eq(call("Ṭ", ["abc", "", "defg", "hijkl"]), []) + +assert_eq( + call("Ṭ", [[123, 456], ["abc", "def"], [[1, 2], [3, 4]]]), + [[123, "abc", [1, 2]], [456, "def", [3, 4]]], +) + +# Ụ + +assert_eq(call("Ụ", 123), 231) +assert_eq(call("Ụ", -4.56), "4.56-") + +assert_eq(call("Ụ", "abcd"), "bcda") +assert_eq(call("Ụ", ""), "") + +assert_eq(call("Ụ", [1, 2, 3, 4]), [2, 3, 4, 1]) +assert_eq(call("Ụ", []), []) + +# Ṿ + +assert_eq(call("Ṿ", 123), 312) +assert_eq(call("Ṿ", -4.56), 1.5) + +assert_eq(call("Ṿ", "abcd"), "dabc") +assert_eq(call("Ṿ", ""), "") + +assert_eq(call("Ṿ", [1, 2, 3, 4]), [4, 1, 2, 3]) +assert_eq(call("Ṿ", []), []) + +# Ẉ + +assert_eq(call("Ẉ", 3, 12345), [[1, 4], [2, 5], [3]]) + +assert_eq(call("Ẉ", 4, "abcdefghij"), ["aei", "bfj", "cg", "dh"]) +assert_eq(call("Ẉ", "xyz", -4), ["x", "y", "z", ""]) + +assert_eq(call("Ẉ", 0, [1, 2, 3]), [1, 2, 3]) +assert_eq(call("Ẉ", [], 3), [[], [], []]) + +# Ỵ + +assert_eq(call("Ỵ", 3, 100), 800) +assert_eq(call("Ỵ", -3, -100), -13) +assert_eq(call("Ỵ", 0, -1.23), -1) + +assert_eq(call("Ỵ", 5, "abc"), "cab") +assert_eq(call("Ỵ", "xyz", -2), "yzx") +assert_eq(call("Ỵ", "", 2), "") + +assert_eq(call("Ỵ", 3, [1, 2, 3, 4, 5]), [4, 5, 1, 2, 3]) +assert_eq(call("Ỵ", [1, 2, 3], 0), [1, 2, 3]) + +# Ẓ + +assert_eq(call("Ẓ", 3, 100), 12) +assert_eq(call("Ẓ", -3, -100), -800) +assert_eq(call("Ẓ", 0, -1.23), -1) + +assert_eq(call("Ẓ", 5, "abc"), "bca") +assert_eq(call("Ẓ", "xyz", -2), "zxy") +assert_eq(call("Ẓ", "", 2), "") + +assert_eq(call("Ẓ", 3, [1, 2, 3, 4, 5]), [3, 4, 5, 1, 2]) +assert_eq(call("Ẓ", [1, 2, 3], 0), [1, 2, 3]) + +# Ƈ + +assert_eq(call("Ƈ", 5, 10), 30240) +assert_eq(call("Ƈ", 10, 20), 670442572800) + +assert_eq(call("Ƈ", "abc", "abcbabcbabcba"), 1) +assert_eq(call("Ƈ", [123, 321, 132], "1232123212321"), [1, 1, 0]) + +assert_eq(call("Ƈ", 1, [1, 2, 3, 2, 1, 2, 3]), 1) +assert_eq(call("Ƈ", [1, 2, "a"], [1, "a", 1, "b", 1, "c"]), [1, 0, 1]) + +# Ɗ + +assert_eq(call("Ɗ", 2, 123), "12") +assert_eq(call("Ɗ", 10, -1.23), "1.23") + +assert_eq(call("Ɗ", 3, ""), "") +assert_eq(call("Ɗ", "abc", 2), "ab") +assert_eq(call("Ɗ", -2, "xyz"), "xz") + +assert_eq(call("Ɗ", [], 5), []) +assert_eq(call("Ɗ", 10, [1, 2, 3]), [1, 3]) +assert_eq( + call("Ɗ", ["abc", "def", "ghi", "jkl", "mno"], -10), ["def", "ghi", "jkl", "mno"] +) + +# Ƒ + +assert_eq(call("Ƒ", 100), [2, 5]) +assert_eq(call("Ƒ", 30), [2, 3, 5]) +assert_eq(call("Ƒ", -10), []) + +assert_eq( + call("Ƒ", "abcd"), ["a", "ab", "abc", "abcd", "b", "bc", "bcd", "c", "cd", "d"] +) +assert_eq(call("Ƒ", ""), []) +assert_eq(call("Ƒ", "xxx"), ["x", "xx", "xxx", "x", "xx", "x"]) + +assert_eq(call("Ƒ", [1, 2, 3]), [[1], [1, 2], [1, 2, 3], [2], [2, 3], [3]]) +assert_eq( + call("Ƒ", ["abc", "def", "ghi", "jkl", "mno"]), + [ + ["abc"], + ["abc", "def"], + ["abc", "def", "ghi"], + ["abc", "def", "ghi", "jkl"], + ["abc", "def", "ghi", "jkl", "mno"], + ["def"], + ["def", "ghi"], + ["def", "ghi", "jkl"], + ["def", "ghi", "jkl", "mno"], + ["ghi"], + ["ghi", "jkl"], + ["ghi", "jkl", "mno"], + ["jkl"], + ["jkl", "mno"], + ["mno"], + ], +) +assert_eq(call("Ƒ", []), []) + +# Ɠ + +assert_eq(call("Ɠ"), 16) + +# Ɱ + +assert_eq(call("Ɱ", 123), 12321) +assert_eq(call("Ɱ", -4.56), "-4.565.4-") + +assert_eq(call("Ɱ", "abcde"), "abcdedcba") +assert_eq(call("Ɱ", ""), "") + +assert_eq(call("Ɱ", [1, 2, 3]), [1, 2, 3, 2, 1]) +assert_eq( + call("Ɱ", [1, [2, [3, [4, "d"], "c"], "b"], "a"]), + [1, [2, [3, [4, "d"], "c"], "b"], "a", [2, [3, [4, "d"], "c"], "b"], 1], +) +assert_eq(call("Ɱ", []), []) + +# Ɲ + +assert_eq( + call("Ɲ", 5), + [[1, 1, 1, 1, 1], [2, 1, 1, 1], [3, 1, 1], [2, 2, 1], [4, 1], [3, 2], [5]], +) +assert_eq(call("Ɲ", -4.56), [[-1, -1, -1, -1], [-2, -1, -1], [-3, -1], [-2, -2], [-4]]) + +assert_eq(call("Ɲ", "abcd"), "abcd") + +assert_eq(call("Ɲ", [1, 2, 3, 4]), "1\n2\n3\n4") +assert_eq(call("Ɲ", ["abc", 123, "def", 456]), "abc\n123\ndef\n456") + +assert_eq(call("Ɲ", [[1, 2, 3], [4, 5, 6], [7, 8, 9]]), "123\n456\n789") +assert_eq( + call("Ɲ", ["abc", [123, 456], 789, ["def", "ghi"]]), "abc\n123456\n789\ndefghi" +) + +# Ƥ + +assert_eq(call("Ƥ", 2, 1), [2, 1]) +assert_eq(call("Ƥ", "abc", "def"), ["abc", "d", "e", "f"]) + +assert_eq(call("Ƥ", 5, [1, 2, 3, 4]), [5, 1, 2, 3, 4]) +assert_eq(call("Ƥ", "ghi", ["abc", "def"]), ["ghi", "abc", "def"]) +assert_eq(call("Ƥ", [], []), [[]]) + +# Ƭ + +assert_eq(call("Ƭ", 123, 456), 456, [[1, 2, 3]]) +assert_eq(call("Ƭ", "abc", "def"), "def", [["a", "b", "c"]]) + +assert_eq( + call("Ƭ", 0, [123, "abcde", [789, "xyz"]]), + [[1, "a", 789], [2, "b", "xyz"], [3, "c", 0], [0, "d", 0], [0, "e", 0]], +) +assert_eq( + call("Ƭ", "abc", [[], 123, "abcdefghij"]), + [ + ["abc", 1, "a"], + ["abc", 2, "b"], + ["abc", 3, "c"], + ["abc", "abc", "d"], + ["abc", "abc", "e"], + ["abc", "abc", "f"], + ["abc", "abc", "g"], + ["abc", "abc", "h"], + ["abc", "abc", "i"], + ["abc", "abc", "j"], + ], +) +assert_eq( + call("Ƭ", [[123, 456], ["abc", "def", "ghi"]], [[123, 456], ["abc", "def", "ghi"]]), + [[123, "abc"], [456, "def"], [[[123, 456], ["abc", "def", "ghi"]], "ghi"]], +) + +# ɓ + +assert_eq(call("ɓ", 123), 1) +assert_eq(call("ɓ", 0), 0) + +assert_eq(call("ɓ", "abc"), 1) +assert_eq(call("ɓ", ""), 0) + +assert_eq(call("ɓ", [-1, 0, 1, 2, "", "a"]), [1, 0, 1, 1, 0, 1]) +assert_eq(call("ɓ", []), []) + +# ƈ + +assert_eq( + call("ƈ", 1212323434545656767878989), + [[1, 2], [2, 3], [3, 3], [4, 3], [5, 3], [6, 3], [7, 3], [8, 3], [9, 2]], +) + +assert_eq( + call("ƈ", "the quick brown fox jumps over the lazy dog"), + [ + ["t", 2], + ["h", 2], + ["e", 3], + [" ", 8], + ["q", 1], + ["u", 2], + ["i", 1], + ["c", 1], + ["k", 1], + ["b", 1], + ["r", 2], + ["o", 4], + ["w", 1], + ["n", 1], + ["f", 1], + ["x", 1], + ["j", 1], + ["m", 1], + ["p", 1], + ["s", 1], + ["v", 1], + ["l", 1], + ["a", 1], + ["z", 1], + ["y", 1], + ["d", 1], + ["g", 1], + ], +) +assert_eq(call("ƈ", ""), []) + +assert_eq( + call( + "ƈ", + [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9, 7, 9, 3, 2, 3, 8, 4, 6, 2, 6, 4, 3, 3], + ), + [[3, 6], [1, 2], [4, 3], [5, 3], [9, 3], [2, 3], [6, 3], [8, 2], [7, 1]], +) +assert_eq(call("ƈ", []), []) + +# ɗ + +assert_eq(call("ɗ", 123), 1) +assert_eq(call("ɗ", -1.5), 0.5) +assert_eq(call("ɗ", [10, 11, 12, 13, 14]), [0, 1, 0, 1, 0]) + +assert_eq(call("ɗ", "abcdefghij"), "fghij") +assert_eq(call("ɗ", ""), "") + +assert_eq(call("ɗ", ["abcd", 1234, "efg", 567]), ["cd", 0, "g", 1]) + +# ƒ + +assert_eq( + call("ƒ", 3141592653589), + [ + [3], + [3, 1], + [3, 1, 4], + [3, 1, 4, 1], + [3, 1, 4, 1, 5], + [3, 1, 4, 1, 5, 9], + [3, 1, 4, 1, 5, 9, 2], + [3, 1, 4, 1, 5, 9, 2, 6], + [3, 1, 4, 1, 5, 9, 2, 6, 5], + [3, 1, 4, 1, 5, 9, 2, 6, 5, 3], + [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5], + [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8], + [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9], + ], +) +assert_eq(call("ƒ", 111), [[1], [1, 1], [1, 1, 1]]) + +assert_eq(call("ƒ", "abcde"), ["a", "ab", "abc", "abcd", "abcde"]) +assert_eq(call("ƒ", ""), []) + +assert_eq( + call("ƒ", [123, "abc", 456, "def", 789, "ghi"]), + [ + [123], + [123, "abc"], + [123, "abc", 456], + [123, "abc", 456, "def"], + [123, "abc", 456, "def", 789], + [123, "abc", 456, "def", 789, "ghi"], + ], +) +assert_eq(call("ƒ", []), []) + +# ɠ + +assert_eq(call("ɠ"), 256) + +# ɦ + +assert_eq(call("ɦ"), 100) + +# ƙ + +assert_eq(call("ƙ", 123), 125) +assert_eq(call("ƙ", -1.23), 0.77) + +assert_eq( + call("ƙ", "The quick brown fox jumps over the lazy dog"), + [ + 3, + 9, + 15, + 19, + 25, + 30, + 34, + 39, + 0, + 36, + 10, + 7, + 40, + 2, + 28, + 33, + 16, + 42, + 1, + 32, + 6, + 20, + 8, + 35, + 22, + 14, + 12, + 17, + 26, + 41, + 23, + 4, + 11, + 29, + 24, + 31, + 5, + 21, + 27, + 13, + 18, + 38, + 37, + ], +) +assert_eq(call("ƙ", ""), []) + +assert_eq( + call("ƙ", [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9]), + [1, 3, 6, 0, 9, 2, 4, 8, 10, 7, 11, 5, 12], +) +assert_eq(call("ƙ", []), []) + +# ɱ + +assert_eq(call("ɱ", 3, 3.14159), 3.1) + +assert_eq(call("ɱ", 5, "Hello, World!"), "Hello") +assert_eq(call("ɱ", -1, "abc"), "ab") + +assert_eq(call("ɱ", 4, [1, 2, 3]), [1, 2, 3]) +assert_eq(call("ɱ", -5, ["abc", "def", "ghi"]), []) + +# ɲ + +assert_eq(call("ɲ", 3, 3.14159), 159) + +assert_eq(call("ɲ", 5, "Hello, World!"), "orld!") +assert_eq(call("ɲ", -1, "abc"), "bc") + +assert_eq(call("ɲ", 4, [1, 2, 3]), [1, 2, 3]) +assert_eq(call("ɲ", -5, ["abc", "def", "ghi"]), []) + +# ƥ + +assert_eq(call("ƥ", 123)) +assert_eq(call("ƥ", "abc")) +assert_eq(call("ƥ", [1, [2, [3]]])) + +# ʠ + +assert_eq( + call("ʠ", 5), + [ + [], + [1], + [2], + [1, 2], + [3], + [1, 3], + [2, 3], + [1, 2, 3], + [4], + [1, 4], + [2, 4], + [1, 2, 4], + [3, 4], + [1, 3, 4], + [2, 3, 4], + [1, 2, 3, 4], + [5], + [1, 5], + [2, 5], + [1, 2, 5], + [3, 5], + [1, 3, 5], + [2, 3, 5], + [1, 2, 3, 5], + [4, 5], + [1, 4, 5], + [2, 4, 5], + [1, 2, 4, 5], + [3, 4, 5], + [1, 3, 4, 5], + [2, 3, 4, 5], + [1, 2, 3, 4, 5], + ], +) +assert_eq( + call("ʠ", -3.14), [[], [-1], [-2], [-1, -2], [-3], [-1, -3], [-2, -3], [-1, -2, -3]] +) + +assert_eq( + call("ʠ", "abcde"), + [ + "", + "a", + "b", + "ab", + "c", + "ac", + "bc", + "abc", + "d", + "ad", + "bd", + "abd", + "cd", + "acd", + "bcd", + "abcd", + "e", + "ae", + "be", + "abe", + "ce", + "ace", + "bce", + "abce", + "de", + "ade", + "bde", + "abde", + "cde", + "acde", + "bcde", + "abcde", + ], +) +assert_eq(call("ʠ", ""), [""]) + +assert_eq( + call("ʠ", [123, "abc", 456, "def"]), + [ + [], + [123], + ["abc"], + [123, "abc"], + [456], + [123, 456], + ["abc", 456], + [123, "abc", 456], + ["def"], + [123, "def"], + ["abc", "def"], + [123, "abc", "def"], + [456, "def"], + [123, 456, "def"], + ["abc", 456, "def"], + [123, "abc", 456, "def"], + ], +) +assert_eq(call("ʠ", []), [[]]) + +# ʂ + +assert_eq(call("ʂ", 123), 1) +assert_eq(call("ʂ", -1.23), -1) +assert_eq(call("ʂ", 0), 0) + +assert_eq( + call("ʂ", 'tHe QuIcK, bRoWn FoX. hE "jUmPeD" oVeR? tHe LaZy DoG! wHaT?!'), + 'The quick, brown fox. He "jumped" over? The lazy dog! What?!', +) +assert_eq(call("ʂ", "abcdef"), "Abcdef") + +assert_eq( + call("ʂ", [123, "abc", [4, 5, 6], [7, "eight", 9]]), [6, "abc", 15, "7eight9"] +) +assert_eq(call("ʂ", []), []) + +# ƭ + +assert_eq(call("ƭ", 100), 10) +assert_eq(call("ƭ", 10), 3.1622776601683795) +assert_eq( + call("ƭ", [-2, -1, 0, 1, 2]), [1.4142135623730951, 1, 0, 1, 1.4142135623730951] +) +assert_eq(call("ƭ", 6.25), 2.5) + +assert_eq(call("ƭ", "abcdef"), "ace") +assert_eq(call("ƭ", "xyz"), "xz") +assert_eq(call("ƭ", ""), "") + +# ¶ + +assert_eq(call("¶"), "\n") + +# Ç + +assert_eq(call("Ç"), "|") + +# ¬ + +assert_eq(call("¬", 123), 0) +assert_eq(call("¬", 0), 1) + +assert_eq(call("¬", "abc"), 0) +assert_eq(call("¬", ""), 1) + +assert_eq(call("¬", [-1, 0, 1, 2, "", "a"]), 0) +assert_eq(call("¬", []), 1) + +# § + +assert_eq(call("§", 123, 456), 456) +assert_eq(call("§", -1.23, -4.56), -1.23) + +assert_eq(call("§", "abcd", "efgh"), "efgh") +assert_eq(call("§", "abc", "aac"), "abc") + +assert_eq(call("§", "abc", 123), "abc") +assert_eq(call("§", 123, ""), 123) + +assert_eq( + call("§", [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]), + [10, 9, 8, 7, 6, 6, 7, 8, 9, 10], +) + +# Ä + +assert_eq(call("Ä", 10), "J") +assert_eq(call("Ä", [20, 8, 21, 14, 14, 15]), ["T", "H", "U", "N", "N", "O"]) + +assert_eq(call("Ä", "Abc"), [1, 2, 3]) +assert_eq(call("Ä", "Hello, World!"), [8, 5, 12, 12, 15, 0, 0, 23, 15, 18, 12, 4, 0]) +assert_eq( + call("Ä", ["Thunno 2", "is the", "best!"]), + [[20, 8, 21, 14, 14, 15, 0, 0], [9, 19, 0, 20, 8, 5], [2, 5, 19, 20, 0]], +) + +assert_eq(call("Ä", [123, "abc", -4.56, "?!."]), ["S", [1, 2, 3], "V", [0, 0, 0]]) + +# ½ + +assert_eq(call("½", 10), 5) +assert_eq(call("½", [-10, -5, 0, 5, 10]), [-5, -2.5, 0, 2.5, 5]) + +assert_eq(call("½", "abcdefg"), ["abcd", "efg"]) +assert_eq( + call("½", ["abc", 123, "defg", 4567, "hijkl", 89012]), + [["ab", "c"], 61.5, ["de", "fg"], 2283.5, ["hij", "kl"], 44506], +) + +# ² + +assert_eq(call("²", 5), 25) +assert_eq(call("²", [-3, -2, -1, 0, 1, 2, 3]), [9, 4, 1, 0, 1, 4, 9]) + +assert_eq(call("²", "abcdefghij"), ["ab", "cd", "ef", "gh", "ij"]) +assert_eq(call("²", "a"), ["a"]) + +assert_eq( + call("²", [12, "abcde", 34, "fghijklm"]), + [144, ["ab", "cd", "e"], 1156, ["fg", "hi", "jk", "lm"]], +) + +# ³ + +assert_eq(call("³", 5), 125) +assert_eq(call("³", [-3, -2, -1, 0, 1, 2, 3]), [-27, -8, -1, 0, 1, 8, 27]) + +assert_eq(call("³", "abcdefghij"), ["abc", "def", "ghi", "j"]) +assert_eq(call("³", "a"), ["a"]) + +assert_eq( + call("³", [12, "abcde", 34, "fghijklm"]), + [1728, ["abc", "de"], 39304, ["fgh", "ijk", "lm"]], +) + +# ⁴ + +assert_eq(call("⁴", 5), 625) +assert_eq(call("⁴", [-3, -2, -1, 0, 1, 2, 3]), [81, 16, 1, 0, 1, 16, 81]) + +assert_eq(call("⁴", "abcdefghij"), ["abcd", "efgh", "ij"]) +assert_eq(call("⁴", "a"), ["a"]) + +assert_eq( + call("⁴", [12, "abcde", 34, "fghijklm"]), + [20736, ["abcd", "e"], 1336336, ["fghi", "jklm"]], +) + +# ⁵ + +assert_eq(call("⁵", 5), 3125) +assert_eq(call("⁵", [-3, -2, -1, 0, 1, 2, 3]), [-243, -32, -1, 0, 1, 32, 243]) + +assert_eq(call("⁵", "abcdefghij"), ["abcde", "fghij"]) +assert_eq(call("⁵", "a"), ["a"]) + +assert_eq( + call("⁵", [12, "abcde", 34, "fghijklm"]), + [248832, ["abcde"], 45435424, ["fghij", "klm"]], +) + +# ạ + +assert_eq(call("ạ", 123), 0) +assert_eq(call("ạ", 111), 1) +assert_eq(call("ạ", -1.1), 0) + +assert_eq(call("ạ", "abc"), 0) +assert_eq(call("ạ", "aaa"), 1) +assert_eq(call("ạ", ""), 1) + +assert_eq(call("ạ", [1, 2, 3]), 0) +assert_eq(call("ạ", [1, 1, 1]), 1) +assert_eq(call("ạ", []), 1) + +# ḅ + +assert_eq(call("ḅ", 1), 1) +assert_eq(call("ḅ", -1.23), 0) +assert_eq(call("ḅ", [-2, -1, 0, 1, 2]), [0, 0, 0, 1, 0]) + +assert_eq(call("ḅ", "abc"), 0) +assert_eq(call("ḅ", ""), 0) + +assert_eq(call("ḅ", ["abc", 1, "", 123, "def", 1.0]), [0, 1, 0, 0, 0, 1]) + +# ḍ + +assert_eq(call("ḍ", 1234, 314159), [5, 9, 2]) +assert_eq(call("ḍ", 121, 234), [3, 4, 1]) + +assert_eq(call("ḍ", "abc123", 12345), "45abc") +assert_eq(call("ḍ", 3.14, "xyz"), "xyz3.14") + +assert_eq(call("ḍ", [123, "abc", 456, "def"], ["abc", "def", "ghi"]), ["ghi", 123, 456]) +assert_eq(call("ḍ", [1, 2, 3], 123), []) + +# ẹ + +assert_eq(call("ẹ", 123), 1231) +assert_eq(call("ẹ", -4.56), "-4.56-") + +assert_eq(call("ẹ", "abc"), "abca") +assert_eq(call("ẹ", "xxx"), "xxxx") +assert_eq(call("ẹ", ""), "") + +assert_eq(call("ẹ", [123, 456, 789]), [123, 456, 789, 123]) +assert_eq(call("ẹ", []), []) + +# ḥ + +assert_eq(call("ḥ", 123, 456), [4, 5, 6, 1, 2, 3]) + +assert_eq(call("ḥ", 123, "abc"), ["a", "b", "c", 1, 2, 3]) +assert_eq(call("ḥ", "def", "abc"), ["a", "b", "c", "d", "e", "f"]) + +assert_eq(call("ḥ", 123, [123, 456, 789]), [123, 456, 789, 1, 2, 3]) +assert_eq( + call("ḥ", ["abc", 123, "def", 456], "xyz"), ["x", "y", "z", "abc", 123, "def", 456] +) + +assert_eq(call("ḥ", [123], ["abc"]), ["abc", 123]) + +# ị + +assert_eq(call("ị", 10203040, 12345678), [1, 3, 5, 7]) +assert_eq(call("ị", 123, "abcdefghij"), "abc") + +assert_eq(call("ị", ["abc", 0, 123, [], "", [123, 456]], 1234567890), [1, 3, 6]) +assert_eq(call("ị", [], "abcdef"), "") +assert_eq(call("ị", [1, 2, 3, 4, 5], [6, 7, 8]), [6, 7, 8]) + +# ḳ + +assert_eq(call("ḳ", 3.141592653589), [1, 2, 3, 4, 5, 6, 8, 9]) +assert_eq(call("ḳ", 0), [0]) + +assert_eq(call("ḳ", "Hello, World!"), " !,HWdelor") +assert_eq(call("ḳ", "cba"), "abc") + +assert_eq( + call( + "ḳ", + [ + 123, + 456, + 789, + 12, + 345, + 678, + 901, + 234, + 567, + 890, + 123, + 456, + 789, + 12, + 345, + 678, + 901, + 234, + 567, + 890, + ], + ), + [12, 123, 234, 345, 456, 567, 678, 789, 890, 901], +) + +# ḷ + +assert_eq(call("ḷ", 123), -122) +assert_eq(call("ḷ", 0.25), 0.75) + +assert_eq(call("ḷ", "Hello, World!"), 0) +assert_eq(call("ḷ", "hello, world!"), 1) +assert_eq(call("ḷ", ""), 1) + +assert_eq( + call("ḷ", [1234, "xyz", [123, 456], 0, "", ["abc", "def", "ghi", "jkl", "mno"]]), + [4, 3, 2, 1, 0, 5], +) + +# ṃ + +assert_eq(call("ṃ", 1.23), 2) +assert_eq(call("ṃ", -12.34), -12) + +assert_eq(call("ṃ", "Hello, World!"), [0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0]) +assert_eq(call("ṃ", "aeiou"), [1, 1, 1, 1, 1]) + +assert_eq( + call("ṃ", [123, "abc", ["xyz", 1.23, "def", 456]]), + [321, "cba", [456, "def", 1.23, "xyz"]], +) + +# ọ + +assert_eq(call("ọ", 3, 123), [1, 2, 3, 1, 2, 3, 1, 2, 3]) +assert_eq(call("ọ", -1, 456), []) + +assert_eq( + call("ọ", 5, "abc"), + ["a", "b", "c", "a", "b", "c", "a", "b", "c", "a", "b", "c", "a", "b", "c"], +) +assert_eq(call("ọ", "xyz", 3), ["x", "y", "z", "x", "y", "z", "x", "y", "z"]) + +assert_eq(call("ọ", 2, [123, 456, 789]), [123, 456, 789, 123, 456, 789]) +assert_eq( + call("ọ", ["abc", 123, "def", 456], 5), + [ + "abc", + 123, + "def", + 456, + "abc", + 123, + "def", + 456, + "abc", + 123, + "def", + 456, + "abc", + 123, + "def", + 456, + "abc", + 123, + "def", + 456, + ], +) + +assert_eq(call("ọ", ["xyz", 123], "abc"), ["xyz", 123, "xyz", 123, "xyz", 123]) +assert_eq(call("ọ", [123, 456], ["abc", "def"]), ["abc", "def", "abc", "def"]) + +# ṛ + +assert_eq(call("ṛ", 5, 3), 2) +assert_eq(call("ṛ", 3, 5), 2) +assert_eq( + call("ṛ", 10, [-10, -5, 0, 5, 10, 15, 20, 25, 30]), + [20, 15, 10, 5, 0, 5, 10, 15, 20], +) + +assert_eq(call("ṛ", 8, "abcde"), "000abcde") +assert_eq(call("ṛ", "abcde", 3), "abcde") +assert_eq( + call("ṛ", "xyz", [-10, -5, 0, 5, 10]), + ["xyz0000000", "xyz00", "xyz", "00xyz", "0000000xyz"], +) + +assert_eq(call("ṛ", "abc", "defghi"), "abcdefghiabc") +assert_eq( + call("ṛ", ["123", "abc", "456", "def"], "xyz"), + ["123xyz123", "abcxyzabc", "456xyz456", "defxyzdef"], +) + +# ṣ + +assert_eq(call("ṣ", 5), " ") +assert_eq(call("ṣ", 3.14), " ") +assert_eq(call("ṣ", -2), "") + +assert_eq(call("ṣ", "abcdef"), ["f", "ef", "def", "cdef", "bcdef", "abcdef"]) +assert_eq( + call("ṣ", "Hello, World!"), + [ + "!", + "d!", + "ld!", + "rld!", + "orld!", + "World!", + " World!", + ", World!", + "o, World!", + "lo, World!", + "llo, World!", + "ello, World!", + "Hello, World!", + ], +) + +assert_eq( + call("ṣ", [1, 2, 3, 4, 5]), [[5], [4, 5], [3, 4, 5], [2, 3, 4, 5], [1, 2, 3, 4, 5]] +) +assert_eq(call("ṣ", []), []) + +# ṭ + +assert_eq(call("ṭ", 123, 456, 789), 123, 789, 456) +assert_eq(call("ṭ", "abc", "def", "ghi"), "abc", "ghi", "def") +assert_eq( + call("ṭ", [123, "abc", 456], ["def", 789, "ghi"], [123, "jkl", 456]), + [123, "abc", 456], + [123, "jkl", 456], + ["def", 789, "ghi"], +) + +# ẉ + +assert_eq( + call("ẉ", 3, 5), + [ + [1, 1, 1], + [1, 1, 2], + [1, 1, 3], + [1, 1, 4], + [1, 1, 5], + [1, 2, 1], + [1, 2, 2], + [1, 2, 3], + [1, 2, 4], + [1, 2, 5], + [1, 3, 1], + [1, 3, 2], + [1, 3, 3], + [1, 3, 4], + [1, 3, 5], + [1, 4, 1], + [1, 4, 2], + [1, 4, 3], + [1, 4, 4], + [1, 4, 5], + [1, 5, 1], + [1, 5, 2], + [1, 5, 3], + [1, 5, 4], + [1, 5, 5], + [2, 1, 1], + [2, 1, 2], + [2, 1, 3], + [2, 1, 4], + [2, 1, 5], + [2, 2, 1], + [2, 2, 2], + [2, 2, 3], + [2, 2, 4], + [2, 2, 5], + [2, 3, 1], + [2, 3, 2], + [2, 3, 3], + [2, 3, 4], + [2, 3, 5], + [2, 4, 1], + [2, 4, 2], + [2, 4, 3], + [2, 4, 4], + [2, 4, 5], + [2, 5, 1], + [2, 5, 2], + [2, 5, 3], + [2, 5, 4], + [2, 5, 5], + [3, 1, 1], + [3, 1, 2], + [3, 1, 3], + [3, 1, 4], + [3, 1, 5], + [3, 2, 1], + [3, 2, 2], + [3, 2, 3], + [3, 2, 4], + [3, 2, 5], + [3, 3, 1], + [3, 3, 2], + [3, 3, 3], + [3, 3, 4], + [3, 3, 5], + [3, 4, 1], + [3, 4, 2], + [3, 4, 3], + [3, 4, 4], + [3, 4, 5], + [3, 5, 1], + [3, 5, 2], + [3, 5, 3], + [3, 5, 4], + [3, 5, 5], + [4, 1, 1], + [4, 1, 2], + [4, 1, 3], + [4, 1, 4], + [4, 1, 5], + [4, 2, 1], + [4, 2, 2], + [4, 2, 3], + [4, 2, 4], + [4, 2, 5], + [4, 3, 1], + [4, 3, 2], + [4, 3, 3], + [4, 3, 4], + [4, 3, 5], + [4, 4, 1], + [4, 4, 2], + [4, 4, 3], + [4, 4, 4], + [4, 4, 5], + [4, 5, 1], + [4, 5, 2], + [4, 5, 3], + [4, 5, 4], + [4, 5, 5], + [5, 1, 1], + [5, 1, 2], + [5, 1, 3], + [5, 1, 4], + [5, 1, 5], + [5, 2, 1], + [5, 2, 2], + [5, 2, 3], + [5, 2, 4], + [5, 2, 5], + [5, 3, 1], + [5, 3, 2], + [5, 3, 3], + [5, 3, 4], + [5, 3, 5], + [5, 4, 1], + [5, 4, 2], + [5, 4, 3], + [5, 4, 4], + [5, 4, 5], + [5, 5, 1], + [5, 5, 2], + [5, 5, 3], + [5, 5, 4], + [5, 5, 5], + ], +) + +assert_eq( + call("ẉ", -3, "abc"), + [ + ["a", "a", "a"], + ["a", "a", "b"], + ["a", "a", "c"], + ["a", "b", "a"], + ["a", "b", "b"], + ["a", "b", "c"], + ["a", "c", "a"], + ["a", "c", "b"], + ["a", "c", "c"], + ["b", "a", "a"], + ["b", "a", "b"], + ["b", "a", "c"], + ["b", "b", "a"], + ["b", "b", "b"], + ["b", "b", "c"], + ["b", "c", "a"], + ["b", "c", "b"], + ["b", "c", "c"], + ["c", "a", "a"], + ["c", "a", "b"], + ["c", "a", "c"], + ["c", "b", "a"], + ["c", "b", "b"], + ["c", "b", "c"], + ["c", "c", "a"], + ["c", "c", "b"], + ["c", "c", "c"], + ], +) +assert_eq( + call("ẉ", "xyz", 2), + [ + ["x", "x"], + ["x", "y"], + ["x", "z"], + ["y", "x"], + ["y", "y"], + ["y", "z"], + ["z", "x"], + ["z", "y"], + ["z", "z"], + ], +) + +assert_eq( + call("ẉ", 2, ["abc", "def", "ghi"]), + [ + ["abc", "abc"], + ["abc", "def"], + ["abc", "ghi"], + ["def", "abc"], + ["def", "def"], + ["def", "ghi"], + ["ghi", "abc"], + ["ghi", "def"], + ["ghi", "ghi"], + ], +) +assert_eq(call("ẉ", [1, 2, 3, 4, 5], 0), [[]]) +assert_eq(call("ẉ", 5, []), []) + +# ỵ + +assert_eq(call("ỵ", 2, 12345), 345) +assert_eq(call("ỵ", 5, 3.14), "") + +assert_eq(call("ỵ", -3, "abcde"), "cde") +assert_eq(call("ỵ", "", 10), "") + +assert_eq(call("ỵ", 2, [123, 456, 789]), [789]) +assert_eq(call("ỵ", ["abc", "def", "ghi", "jkl", "mno"], 3), ["jkl", "mno"]) + +# ẓ + +assert_eq(call("ẓ", 2, 12345), 123) +assert_eq(call("ẓ", 5, 3.14), "") + +assert_eq(call("ẓ", -3, "abcde"), "abc") +assert_eq(call("ẓ", "", 10), "") + +assert_eq(call("ẓ", 2, [123, 456, 789]), [123]) +assert_eq(call("ẓ", ["abc", "def", "ghi", "jkl", "mno"], 3), ["abc", "def"]) + +# øB + +assert_eq(call("øB", "([{}])"), 1) +assert_eq(call("øB", "{]"), 0) +assert_eq(call("øB", ["(abc)", "{}[xyz]()", "{abc", ""]), [1, 1, 0, 1]) + +# øD + +assert_eq(call("øD", "Hello, World!"), "Ƙ¥, «ʋ!") +assert_eq(call("øD", "thunnobest"), "thunnoÇ&") +assert_eq(call("øD", "withree"), "wiċŀ") +assert_eq(call("øD", 123456), "123456") + +# ø< + +assert_eq(call("ø<", 123, 123456), 1) +assert_eq(call("ø<", -1, -1.23), 1) +assert_eq(call("ø<", 1, [123, -1, 456, 1, 1.23]), [1, 0, 0, 1, 1]) + +assert_eq(call("ø<", "abc", "abcdef"), 1) +assert_eq(call("ø<", "xyz", "abcdef"), 0) + +# ø> + +assert_eq(call("ø>", 456, 123456), 1) +assert_eq(call("ø>", -1, -1.23), 0) +assert_eq(call("ø>", 1, [321, -1, 456, 1, 1.23]), [1, 1, 0, 1, 0]) + +assert_eq(call("ø>", "def", "abcdef"), 1) +assert_eq(call("ø>", "xyz", "abcdef"), 0) + +# ØC + +assert_eq(call("ØC", 123), 123) +assert_eq(call("ØC", "abc"), "abc") + +assert_eq(call("ØC", [123, 4567, 8, 90]), "123 \n4567\n 8 \n 90 ") +assert_eq( + call("ØC", ["abc", 1234, "xy", 56789, "z"]), " abc \n 1234\n xy \n56789\n z " +) +assert_eq(call("ØC", []), "") + +# ØD + +assert_eq(call("ØD", 123), 0) +assert_eq(call("ØD", -4.56), 0) +assert_eq(call("ØD", "abc"), 0) + +assert_eq(call("ØD", [1, 2, 3]), 1) +assert_eq(call("ØD", [["abc", "def", "ghi"], 123, 456, 789]), 2) +assert_eq(call("ØD", [1, [2, [3, [4, [5, [6, [7, [8, [9, [10]]]]]]]]]]), 10) + +assert_eq(call("ØD", []), 1) +assert_eq(call("ØD", [[[[[[[[[[]]]]]]]]]]), 10) + +# ØE + +assert_eq(call("ØE", 6, 123), 123123) +assert_eq(call("ØE", 10, 4.56), "4.564.564.") + +assert_eq(call("ØE", 15, "abcd"), "abcdabcdabcdabc") +assert_eq(call("ØE", "thunno", -5.67), "thunn") +assert_eq(call("ØE", 3, ""), "") +assert_eq(call("ØE", "abc", 0), "") + +assert_eq( + call("ØE", [123, 456, 789], 10), [123, 456, 789, 123, 456, 789, 123, 456, 789, 123] +) +assert_eq(call("ØE", -3, ["abc", 123, "def", 456, "ghi", 789]), ["abc", 123, "def"]) +assert_eq(call("ØE", 3, []), []) +assert_eq(call("ØE", [123, 456, 789], 0), []) + +# ØG + +assert_eq(call("ØG", [123, 4567, 89]), 4567) +assert_eq(call("ØG", ["abcd", "ef", "ghi"]), "abcd") +assert_eq(call("ØG", []), []) + +assert_eq(call("ØG", 123), 123) +assert_eq(call("ØG", "abc"), "abc") + +# ØI + +assert_eq(call("ØI", 5, [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]), [1, 0, 0]) +assert_eq(call("ØI", [[[1, 2], [3, 4]], [[5, 6], [7, 8]]], 8), [1, 1, 1]) +assert_eq( + call("ØI", [2, 3, 5, 7], [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]), + [[0, 0, 1], [0, 1, 0], [1, 0, 0], [1, 1, 0]], +) + +assert_eq(call("ØI", "abc", [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]), []) +assert_eq(call("ØI", [[[1, 2], [3, 4]], [[5, 6], [7, 8]]], 9), []) + +assert_eq(call("ØI", 123, 456), 456, 123) +assert_eq(call("ØI", "abc", "def"), "def", "abc") + +# ØM + +assert_eq(call("ØM", [123, 4567, 89]), 89) +assert_eq(call("ØM", ["abcd", "ef", "ghi"]), "ef") +assert_eq(call("ØM", []), []) + +assert_eq(call("ØM", 123), 123) +assert_eq(call("ØM", "abc"), "abc") + +# Ø. + +assert_eq(call("Ø.", [1, 2, 3], [4, 5, 6]), 32) +assert_eq(call("Ø.", [123], [456, 789]), 56088) +assert_eq(call("Ø.", [], [123, 456, 789]), 0) + +assert_eq( + call("Ø.", [5, 6, 7], ["abc", "def", "ghi"]), + "abcabcabcabcabcdefdefdefdefdefdefghighighighighighighi", +) + +# Ø\ + +assert_eq(call("Ø\\", [123, 456, 789]), [1, 5, 9]) +assert_eq(call("Ø\\", ["abcd", 12345, "xyz", 67]), ["a", 2]) +assert_eq(call("Ø\\", [[123, 456, 789], ["abc", "def", "ghi"]]), [123, "def"]) +assert_eq(call("Ø\\", []), []) + +assert_eq(call("Ø\\", 123), 123) +assert_eq(call("Ø\\", "abc"), "abc") + +# Ø/ + +assert_eq(call("Ø/", [123, 456, 789]), [3, 5, 7]) +assert_eq(call("Ø/", ["abcd", 12345, "xyz", 67]), ["b", 1]) +assert_eq(call("Ø/", [[123, 456, 789], ["abc", "def", "ghi"]]), [456, "abc"]) +assert_eq(call("Ø/", []), []) + +assert_eq(call("Ø/", 123), 123) +assert_eq(call("Ø/", "abc"), "abc") + +# Ø“ + +assert_eq(call("Ø“", [123, 456, 789]), [[1, 5, 9], [2, 6], [3], [7], [4, 8]]) +assert_eq( + call("Ø“", ["abcd", 12345, "xyz", 67]), [["a", 2], ["b"], [6], ["x", 7], [1, "y"]] +) +assert_eq( + call("Ø“", [[123, 456, 789], ["abc", "def", "ghi"]]), + [[123, "def"], [456, "ghi"], [789], ["abc"]], +) +assert_eq(call("Ø“", []), []) + +assert_eq(call("Ø“", 123), 123) +assert_eq(call("Ø“", "abc"), "abc") + +# Ø” + +assert_eq(call("Ø”", [123, 456, 789]), [[3, 5, 7], [2, 4], [1], [9], [6, 8]]) +assert_eq( + call("Ø”", ["abcd", 12345, "xyz", 67]), [["b", 1], ["a"], [7], ["y", 6], [2, "x"]] +) +assert_eq( + call("Ø”", [[123, 456, 789], ["abc", "def", "ghi"]]), + [[456, "abc"], [123], ["ghi"], [789, "def"]], +) +assert_eq(call("Ø”", []), []) + +assert_eq(call("Ø”", 123), 123) +assert_eq(call("Ø”", "abc"), "abc") + +# # ÆC +# +# assert_eq(call("ÆC", 0), 1.0) # ~ 1 +# assert_eq(call("ÆC", 0.524), 0.8658247218821449) # ~ sqrt(3) / 2 +# assert_eq(call("ÆC", 0.785), 0.7073882691671998) # ~ sqrt(2) / 2 +# assert_eq(call("ÆC", 1.047), 0.5001710745970702) # ~ 1/2 +# assert_eq(call("ÆC", 1.571), -0.00020367320369517789) # ~ 0 + +# # ÆE +# +# assert_eq(call("ÆE", 0), 1.0) +# assert_eq(call("ÆE", 1), 2.718281828459045) +# assert_eq( +# call("ÆE", [-1.23, 4.56, -7.89, 10.11]), +# [0.2922925776808594, 95.58347983006624, 0.00037446957498607833, 24587.660736455156] +# ) + +# ÆF + +assert_eq(call("ÆF", 0), 0) +assert_eq(call("ÆF", 5), 5) +assert_eq(call("ÆF", 1.23), 1) +assert_eq(call("ÆF", [10, 11, 12, 13, 14]), [55, 89, 144, 233, 377]) + +# ÆH + +assert_eq(call("ÆH", 3, 4), 5.0) +assert_eq(call("ÆH", 12, 5), 13.0) +assert_eq(call("ÆH", 7, 24), 25.0) + +assert_eq(call("ÆH", 123, "abc"), [123, "abc"]) + +# ÆI + +assert_eq(call("ÆI", 0), 1) +assert_eq(call("ÆI", 123), 0) +assert_eq(call("ÆI", -1.23), 0) + +assert_eq( + call("ÆI", [-2, -1.5, -1, -0.5, 0, 0.5, 1, 1.5, 2]), [0, 0, 1, 1, 1, 1, 1, 0, 0] +) + +assert_eq(call("ÆI", "abc"), ["abc"]) + +# # ÆL +# +# assert_eq(call("ÆL", 3, 30), 3.0959032742893844) +# assert_eq(call("ÆL", 10, 50), 1.6989700043360185) +# assert_eq( +# call("ÆL", 2.5, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), +# [0.0, 0.75647079736603, 1.19897784671579, 1.51294159473206, 1.7564707973660298, +# 1.95544864408182, 2.1236820163783645, 2.26941239209809, 2.39795569343158, 2.51294159473206] +# ) +# +# assert_eq(call("ÆL", "abc", "def"), ["abc", "def"]) + +# # ÆN +# +# assert_eq(call("ÆN", 0.1), -2.3025850929940455) +# assert_eq(call("ÆN", 0.25), -1.3862943611198906) +# assert_eq(call("ÆN", 0.5), -0.6931471805599453) +# assert_eq(call("ÆN", 0.75), -0.2876820724517809) +# assert_eq(call("ÆN", 0.9), -0.10536051565782628) +# assert_eq(call("ÆN", 1.0), 0.0) +# assert_eq(call("ÆN", 1.3), 0.26236426446749106) +# +# assert_eq(call("ÆN", 2), 0.6931471805599453) +# assert_eq(call("ÆN", 2.718281828459045), 1.0) +# assert_eq(call("ÆN", 3.141592653589793), 1.1447298858494002) +# assert_eq(call("ÆN", 4), 1.3862943611198906) +# assert_eq(call("ÆN", 5), 1.6094379124341003) +# assert_eq(call("ÆN", 7), 1.9459101490553132) +# +# assert_eq(call("ÆN", 10), 2.302585092994046) +# assert_eq(call("ÆN", 53), 3.970291913552122) +# assert_eq(call("ÆN", 54.59815003314423), 4.0) +# assert_eq(call("ÆN", 99), 4.59511985013459) + +# ÆP + +assert_eq(call("ÆP", 0), 2) +assert_eq(call("ÆP", 5), 13) +assert_eq(call("ÆP", 1.23), 3) +assert_eq(call("ÆP", [10, 11, 12, 13, 14]), [31, 37, 41, 43, 47]) + +# # ÆS +# +# assert_eq(call("ÆS", 0), 0.0) # ~ 0 +# assert_eq(call("ÆS", 0.524), 0.5003474302699141) # ~ 1/2 +# assert_eq(call("ÆS", 0.785), 0.706825181105366) # ~ sqrt(2) / 2 +# assert_eq(call("ÆS", 1.047), 0.8659266112878228) # ~ sqrt(3) / 2 +# assert_eq(call("ÆS", 1.571), 0.9999999792586128) # ~ 1 + +# # ÆT +# +# assert_eq(call("ÆT", 0), 0.0) # ~ 0 +# assert_eq(call("ÆT", 0.524), 0.5778853590392409) # ~ sqrt(3) / 3 +# assert_eq(call("ÆT", 0.785), 0.9992039901050427) # ~ 1 +# assert_eq(call("ÆT", 1.047), 1.73126087306308) # ~ sqrt(3) + +# # Æc +# +# assert_eq(call("Æc", 0), 1.5707963267948966) # ~ pi/2 +# assert_eq(call("Æc", 0.5), 1.0471975511965976) # ~ pi/3 +# assert_eq(call("Æc", 0.707), 0.7855491633997437) # ~ pi/4 +# assert_eq(call("Æc", 0.866), 0.5236495809318289) # ~ pi/6 +# assert_eq(call("Æc", 1), 0.0) # ~ 0 + +# # Æl +# +# assert_eq(call("Æl", 0.1), -1.0) +# assert_eq(call("Æl", 0.25), -0.6020599913279624) +# assert_eq(call("Æl", 0.5), -0.3010299956639812) +# assert_eq(call("Æl", 0.75), -0.12493873660829995) +# assert_eq(call("Æl", 0.9), -0.045757490560675115) +# assert_eq(call("Æl", 1.0), 0.0) +# assert_eq(call("Æl", 1.3), 0.11394335230683679) +# +# assert_eq(call("Æl", 2), 0.3010299956639812) +# assert_eq(call("Æl", 2.718281828459045), 0.4342944819032518) +# assert_eq(call("Æl", 3.141592653589793), 0.49714987269413385) +# assert_eq(call("Æl", 4), 0.6020599913279624) +# assert_eq(call("Æl", 5), 0.6989700043360189) +# assert_eq(call("Æl", 7), 0.8450980400142568) +# +# assert_eq(call("Æl", 10), 1.0) +# assert_eq(call("Æl", 53), 1.724275869600789) +# assert_eq(call("Æl", 54.59815003314423), 1.7371779276130073) +# assert_eq(call("Æl", 99), 1.99563519459755) + +# # Æs +# +# assert_eq(call("Æs", 0), 0.0) # ~ 0 +# assert_eq(call("Æs", 0.5), 0.5235987755982988) # ~ pi/6 +# assert_eq(call("Æs", 0.707), 0.785247163395153) # ~ pi/4 +# assert_eq(call("Æs", 0.866), 1.0471467458630677) # ~ pi/3 +# assert_eq(call("Æs", 1), 1.5707963267948966) # ~ pi/2 + +# # Æt +# +# assert_eq(call("Æt", 0), 0.0) # ~ 0 +# assert_eq(call("Æt", 0.577), 0.5233360338618205) # ~ pi/6 +# assert_eq(call("Æt", 1), 0.7853981633974483) # ~ pi/4 +# assert_eq(call("Æt", 1.732), 1.0471848490249274) # ~ pi/3 + +# # Æḷ +# +# assert_eq(call("Æḷ", 0.1), -3.321928094887362) +# assert_eq(call("Æḷ", 0.25), -2.0) +# assert_eq(call("Æḷ", 0.5), -1.0) +# assert_eq(call("Æḷ", 0.75), -0.4150374992788438) +# assert_eq(call("Æḷ", 0.9), -0.15200309344504995) +# assert_eq(call("Æḷ", 1.0), 0.0) +# assert_eq(call("Æḷ", 1.3), 0.37851162325372983) +# +# assert_eq(call("Æḷ", 2), 1.0) +# assert_eq(call("Æḷ", 2.718281828459045), 1.4426950408889634) +# assert_eq(call("Æḷ", 3.141592653589793), 1.6514961294723187) +# assert_eq(call("Æḷ", 4), 2.0) +# assert_eq(call("Æḷ", 5), 2.321928094887362) +# assert_eq(call("Æḷ", 7), 2.807354922057604) +# +# assert_eq(call("Æḷ", 10), 3.321928094887362) +# assert_eq(call("Æḷ", 53), 5.727920454563199) +# assert_eq(call("Æḷ", 54.59815003314423), 5.7707801635558535) +# assert_eq(call("Æḷ", 99), 6.6293566200796095) + +# Æ& + +assert_eq(call("Æ&", 123, 456), 72) +assert_eq(call("Æ&", -12.34, 56.78), 48) + +assert_eq( + call("Æ&", 100, [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]), + [0, 0, 4, 4, 32, 32, 36, 68, 64, 64, 100], +) +assert_eq(call("Æ&", [12, 34, 56, 78, 90], [2, 4, 6, 8, 10]), [0, 0, 0, 8, 10]) + +assert_eq(call("Æ&", "abc", 123), ["abc", 123]) + +# Æ| + +assert_eq(call("Æ|", 123, 456), 507) +assert_eq(call("Æ|", -12.34, 56.78), -4) + +assert_eq( + call("Æ|", 100, [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]), + [100, 110, 116, 126, 108, 118, 124, 102, 116, 126, 100], +) +assert_eq(call("Æ|", [12, 34, 56, 78, 90], [2, 4, 6, 8, 10]), [14, 38, 62, 78, 90]) + +assert_eq(call("Æ|", "abc", 123), ["abc", 123]) + +# Æ^ + +assert_eq(call("Æ^", 123, 456), 435) +assert_eq(call("Æ^", -12.34, 56.78), -52) + +assert_eq( + call("Æ^", 100, [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]), + [100, 110, 112, 122, 76, 86, 88, 34, 52, 62, 0], +) +assert_eq(call("Æ^", [12, 34, 56, 78, 90], [2, 4, 6, 8, 10]), [14, 38, 62, 70, 80]) + +assert_eq(call("Æ^", "abc", 123), ["abc", 123]) + +# Æ~ + +assert_eq(call("Æ~", 123), -124) +assert_eq(call("Æ~", 12.34), -13) +assert_eq(call("Æ~", -1.23), 0) + +assert_eq( + call("Æ~", [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]), + [-12, -13, -14, -15, -16, -17, -18, -19, -20, -21], +) + +assert_eq(call("Æ~", "abc"), ["abc"]) + +# Ʋ + +assert_eq(call("Ʋ", 100), 1) +assert_eq(call("Ʋ", 10), 0) +assert_eq(call("Ʋ", 6.25), 0) + +assert_eq(call("Ʋ", [-3, -2, -1, 0, 1, 2, 3]), [0, 0, 0, 1, 1, 0, 0]) +assert_eq(call("Ʋ", [9998, 9999, 10000, 10001, 10002]), [0, 0, 1, 0, 0]) + +assert_eq(call("Ʋ", "abc"), "abc") + +# Ƴ + +assert_eq(call("Ƴ", 1000), 1) +assert_eq(call("Ƴ", 100), 0) +assert_eq(call("Ƴ", 15.625), 0) + +assert_eq(call("Ƴ", [-3, -2, -1, 0, 1, 2, 3]), [0, 0, 0, 1, 1, 0, 0]) +assert_eq(call("Ƴ", [998, 999, 1000, 1001, 1002]), [0, 0, 1, 0, 0]) + +assert_eq(call("Ƴ", "abc"), "abc") + +# Æ⁴ + +assert_eq(call("Æ⁴", 256), 1) +assert_eq(call("Æ⁴", 1000), 0) +assert_eq(call("Æ⁴", 39.0625), 0) + +assert_eq(call("Æ⁴", [-3, -2, -1, 0, 1, 2, 3]), [0, 0, 0, 1, 1, 0, 0]) +assert_eq(call("Æ⁴", [623, 624, 625, 626, 627]), [0, 0, 1, 0, 0]) + +assert_eq(call("Æ⁴", "abc"), "abc") + +# Æ⁵ + +assert_eq(call("Æ⁵", 1024), 1) +assert_eq(call("Æ⁵", 512), 0) +assert_eq(call("Æ⁵", 97.65625), 0) + +assert_eq(call("Æ⁵", [-3, -2, -1, 0, 1, 2, 3]), [0, 0, 0, 1, 1, 0, 0]) +assert_eq(call("Æ⁵", [241, 242, 243, 244, 245]), [0, 0, 1, 0, 0]) + +assert_eq(call("Æ⁵", "abc"), "abc") + +# µR + +assert_eq(call("µR", 12), "XII") +assert_eq(call("µR", -4.56), "-IV") +assert_eq( + call("µR", [123, 456, 789, 1234, 5678, 9012]), + ["CXXIII", "CDLVI", "DCCLXXXIX", "MCCXXXIV", "MMMMMDCLXXVIII", "MMMMMMMMMXII"], +) + +assert_eq(call("µR", "CMXCIX"), 999) +assert_eq(call("µR", ""), 0) +assert_eq(call("µR", "abcdef"), 0) + +# µT + +assert_eq(call("µT", 123), 0) +assert_eq(call("µT", -456), 0) + +assert_eq(call("µT", 1.23), 1) +assert_eq(call("µT", -4.56), 1) + +assert_eq(call("µT", "abc"), 2) +assert_eq(call("µT", ""), 2) + +assert_eq(call("µT", [123, 456, 789]), 3) +assert_eq(call("µT", []), 3) + +# µU + +assert_eq(call("µU", 122333444455555), 12345) +assert_eq(call("µU", 123112233111222333), 123123123) +assert_eq(call("µU", 123), 123) +assert_eq(call("µU", 111), 1) + +assert_eq(call("µU", "abbcccddddeeeee"), "abcde") +assert_eq(call("µU", "abcaabbccaaabbbccc"), "abcabcabc") +assert_eq(call("µU", "xyz"), "xyz") +assert_eq(call("µU", "aaa"), "a") +assert_eq(call("µU", ""), "") + +assert_eq(call("µU", [123, 456, 456, 789, 789, 789]), [123, 456, 789]) +assert_eq( + call("µU", [123, 456, 789, 123, 123, 456, 456, 789, 789]), + [123, 456, 789, 123, 456, 789], +) +assert_eq(call("µU", ["abc", "def"]), ["abc", "def"]) +assert_eq(call("µU", ["abc", "abc", "abc"]), ["abc"]) +assert_eq(call("µU", []), []) + +# µv + +assert_eq(call("µv", 1, 111222333111), "222333") +assert_eq(call("µv", 123, 111222333111), "") + +assert_eq(call("µv", "a", "aaabbbcccaaa"), "bbbccc") +assert_eq(call("µv", "abc", "aaabbbcccaaa"), "") +assert_eq(call("µv", "xyz", "aaabbbcccaaa"), "aaabbbcccaaa") + +assert_eq( + call("µv", 123, [123, 123, 123, 456, 456, 456, 789, 789, 789, 123, 123, 123]), + [456, 456, 456, 789, 789, 789], +) +assert_eq( + call( + "µv", + ["abc", "def", "ghi"], + [ + "abc", + "abc", + "abc", + "def", + "def", + "def", + "ghi", + "ghi", + "ghi", + "abc", + "abc", + "abc", + ], + ), + [], +) +assert_eq( + call( + "µv", + ["abc", "def", "ghi"], + [123, 123, 123, 456, 456, 456, 789, 789, 789, 123, 123, 123], + ), + [123, 123, 123, 456, 456, 456, 789, 789, 789, 123, 123, 123], +) + +# µ< + +assert_eq(call("µ<", 1, 111222333111), "222333111") +assert_eq(call("µ<", 123, 111222333111), "") + +assert_eq(call("µ<", "a", "aaabbbcccaaa"), "bbbcccaaa") +assert_eq(call("µ<", "abc", "aaabbbcccaaa"), "") +assert_eq(call("µ<", "xyz", "aaabbbcccaaa"), "aaabbbcccaaa") + +assert_eq( + call("µ<", 123, [123, 123, 123, 456, 456, 456, 789, 789, 789, 123, 123, 123]), + [456, 456, 456, 789, 789, 789, 123, 123, 123], +) +assert_eq( + call( + "µ<", + ["abc", "def", "ghi"], + [ + "abc", + "abc", + "abc", + "def", + "def", + "def", + "ghi", + "ghi", + "ghi", + "abc", + "abc", + "abc", + ], + ), + [], +) +assert_eq( + call( + "µ<", + ["abc", "def", "ghi"], + [123, 123, 123, 456, 456, 456, 789, 789, 789, 123, 123, 123], + ), + [123, 123, 123, 456, 456, 456, 789, 789, 789, 123, 123, 123], +) + +# µ> + +assert_eq(call("µ>", 1, 111222333111), "111222333") +assert_eq(call("µ>", 123, 111222333111), "") + +assert_eq(call("µ>", "a", "aaabbbcccaaa"), "aaabbbccc") +assert_eq(call("µ>", "abc", "aaabbbcccaaa"), "") +assert_eq(call("µ>", "xyz", "aaabbbcccaaa"), "aaabbbcccaaa") + +assert_eq( + call("µ>", 123, [123, 123, 123, 456, 456, 456, 789, 789, 789, 123, 123, 123]), + [123, 123, 123, 456, 456, 456, 789, 789, 789], +) +assert_eq( + call( + "µ>", + ["abc", "def", "ghi"], + [ + "abc", + "abc", + "abc", + "def", + "def", + "def", + "ghi", + "ghi", + "ghi", + "abc", + "abc", + "abc", + ], + ), + [], +) +assert_eq( + call( + "µ>", + ["abc", "def", "ghi"], + [123, 123, 123, 456, 456, 456, 789, 789, 789, 123, 123, 123], + ), + [123, 123, 123, 456, 456, 456, 789, 789, 789, 123, 123, 123], +) + +# µ& + +assert_eq(call("µ&", 123, 456), 123) +assert_eq(call("µ&", 123, 0), 0) + +assert_eq(call("µ&", -123, "abc"), -123) +assert_eq(call("µ&", "xyz", 0), 0) + +assert_eq(call("µ&", [-1, 0, 1], ["abc", "def", ""]), [-1, 0, 1]) +assert_eq(call("µ&", 5, []), []) + +# µ| + +assert_eq(call("µ|", 123, 456), 456) +assert_eq(call("µ|", 123, 0), 123) + +assert_eq(call("µ|", -123, "abc"), "abc") +assert_eq(call("µ|", "xyz", 0), "xyz") + +assert_eq(call("µ|", [-1, 0, 1], ["abc", "def", ""]), ["abc", "def", ""]) +assert_eq(call("µ|", 5, []), 5) + +# µ^ + +assert_eq(call("µ^", 123, 456), 0) +assert_eq(call("µ^", 123, 0), 1) + +assert_eq(call("µ^", -123, "abc"), 0) +assert_eq(call("µ^", "xyz", 0), 1) + +assert_eq(call("µ^", [-1, 0, 1], ["abc", "def", ""]), 0) +assert_eq(call("µ^", 5, []), 1) + +# µ/ + +assert_eq(call("µ/", "b", "abcbabcba"), ["a", "c", "a", "c", "a"]) +assert_eq( + call("µ/", 3, 12345432123454321), [[1, 2], [4, 5, 4], [2, 1, 2], [4, 5, 4], [2, 1]] +) + +assert_eq(call("µ/", 123, [123, 456, 789, 123, 456, 789]), [[], [456, 789], [456, 789]]) + +# After all the tests + +all_commands = ( + [*commands] + + ["ø" + cmd1 for cmd1 in string_digraphs] + + ["Ø" + cmd2 for cmd2 in list_digraphs] + + ["Æ" + cmd3 for cmd3 in random_digraphs_1] + + ["µ" + cmd4 for cmd4 in random_digraphs_2] +) + +untested_commands = sorted( + {*all_commands} - {*tested_commands} - {*UNTESTABLE}, key=all_commands.index +) +if untested_commands: + print(f'\u001b[33mUntested commands: {", ".join(untested_commands)}') + +print(f"\u001b[32mPassed {tests_counter} tests on {len({*tested_commands})} commands.") + +avg_tests = tests_counter / len({*tested_commands}) +if avg_tests < 4: + print(end=f"\u001b[33m") + +print(f"Average tests per command: {avg_tests:.2f}") +print("\u001b[32m") diff --git a/src/build/lib/thunno2/tokens.py b/src/build/lib/thunno2/tokens.py new file mode 100644 index 0000000..d635b72 --- /dev/null +++ b/src/build/lib/thunno2/tokens.py @@ -0,0 +1,155 @@ +""" +NOTE: This is just an experiment. + +Each command in Thunno 2 has been assigned at least one token. +Using those tokens we can retrieve the original command. +""" + +from thunno2.interpreter import commands +from thunno2.commands import ( + string_digraphs, + list_digraphs, + random_digraphs_1, + random_digraphs_2, +) +import sys + + +def get_command(token): + for tokens, cmd in full_list: + if token.lower() == tokens: + return cmd + print(f"Couldn't find a command for token {token!r}", file=sys.stderr) + sys.exit(0) + + +def transpile(code): + r = "" + for word in code.split(): + if word[:1] == "\\": + r += word[1:] + elif word.isdigit(): + r += word + elif word == "": + r += " " + else: + r += get_command(word) + return r + + +def test(): + tokens_list = [x for x, y in full_list] + for t, _ in full_list: + assert ( + tokens_list.count(t) == 1 + ), f"Token {t!r} not unique (used {tokens_list.count(t)} times)" + assert t == t.lower(), f"Token {t!r} not lowercase" + assert t.replace("_", "").isalnum(), f"Token {t!r} invalid" + print("[TOKENS]: Passed") + + +other_tokens = { + '"': ("string_literal",), + "'": ("one_character",), + "`": ("two_characters",), + "ʋ": ("three_characters",), + "“": ("lowercase_string_compression",), + "”": ("title_case_string_compression",), + "‘": ("lowercase_dictionary_compression",), + "’": ("title_case_dictionary_compression",), + "»": ("integer_compression",), + "«": ("small_integer_compression",), + "¿": ("integer_list_compression",), + "[": ("open_list_literal", "open_list", "list"), + "]": ("close_list_literal", "close_list", "end_list"), + "#": ("comment",), + " ": ("nop",), + "¡": ("get_veriable",), + "!": ("set_variable",), + "ı": ("map",), + "€": ("single_function_map",), + "æ": ("filter",), + "œ": ("single_function_filter",), + "Þ": ("sort_by",), + "þ": ("single_function_sort_by",), + "Ñ": ("group_by",), + "ñ": ("single_function_group_by",), + "ȷ": ("outer_product",), + "¥": ("fixed_point",), + "{": ("open_for_loop",), + "}": ("close_for_loop",), + "(": ("open_while_loop",), + ")": ("close_while_loop",), + "⁽": ("open_forever_loop",), + "⁾": ("close_forever_loop",), + "?": ("if_statement", "if"), + ":": ("else_statement", "else"), + ";": ("close_statement",), + "ç": ("pair_apply",), + "n": ("context_variable",), + "ṅ": ("iteration_index",), + "x": ("get_x",), + "y": ("get_y",), + "X": ("set_x",), + "Y": ("set_y",), + "Ẋ": ("set_x_without_popping",), + "Ẏ": ("set_y_without_popping",), + "ẋ": ("apply_to_x",), + "ẏ": ("apply_to_y",), + "Ȥ": ("get_global_array",), + "ȥ": ("add_to_global_array",), + "K": ("stack",), + "ṇ": ("codepage_compression",), + "q": ("quit",), + "$": ("next_input",), + "¤": ("input_list",), + "°": ("first_input",), + "¹": ("second_input",), + "⁶": ("third_input",), + "⁷": ("third_last_input",), + "⁸": ("second_last_input",), + "⁹": ("last_input",), + "£": ("print",), + "¢": ("print_without_newline",), + "ß": ("print_without_popping",), + "Ƙ": ("first_n_integers",), + "Ʋ": ("cumulative_reduce_by",), + "Ɓ": ("execute_without_popping",), + "µµ": ("recursive_environment",), + "µƲ": ("single_function_reduce_by",), + "µɼ": ("single_function_right_reduce_by",), + "µƇ": ("single_function_right_cumulative_reduce_by",), + "µʋ": ("right_reduce_by",), + "µ€": ("apply_to_every_nth_item",), + "µ«": ("rotate_stack_left",), + "µ»": ("rotate_stack_right",), + "µ!": ("reverse_stack",), + "µÑ": ("adjacent_group_by",), + "µñ": ("single_function_adjacent_group_by",), +} + + +full_list = ( + [(token, cmd) for cmd, ovld in commands.items() for token in ovld.keywords] + + [ + (token, "ø" + cmd) + for cmd, ovld in string_digraphs.items() + for token in ovld.keywords + ] + + [ + (token, "Ø" + cmd) + for cmd, ovld in list_digraphs.items() + for token in ovld.keywords + ] + + [ + (token, "Æ" + cmd) + for cmd, ovld in random_digraphs_1.items() + for token in ovld.keywords + ] + + [ + (token, "µ" + cmd) + for cmd, ovld in random_digraphs_2.items() + for token in ovld.keywords + ] + + [(val, key) for key, vals in other_tokens.items() for val in vals] +) diff --git a/src/build/lib/thunno2/version.py b/src/build/lib/thunno2/version.py new file mode 100644 index 0000000..a088e3f --- /dev/null +++ b/src/build/lib/thunno2/version.py @@ -0,0 +1,7 @@ +""" +This file contains only one constant - the version + +That's it! +""" + +THUNNO_VERSION = "2.2.4" diff --git a/src/thunno2/__pycache__/__init__.cpython-311.pyc b/src/thunno2/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000..2cb9d8e Binary files /dev/null and b/src/thunno2/__pycache__/__init__.cpython-311.pyc differ diff --git a/src/thunno2/__pycache__/version.cpython-311.pyc b/src/thunno2/__pycache__/version.cpython-311.pyc new file mode 100644 index 0000000..20bf0ae Binary files /dev/null and b/src/thunno2/__pycache__/version.cpython-311.pyc differ diff --git a/src/thunno2/version.py b/src/thunno2/version.py index a066d9f..a088e3f 100644 --- a/src/thunno2/version.py +++ b/src/thunno2/version.py @@ -4,4 +4,4 @@ That's it! """ -THUNNO_VERSION = "2.2.2" +THUNNO_VERSION = "2.2.4"