diff --git a/amogus.mers b/amogus.mers
new file mode 100644
index 0000000..6157c5f
--- /dev/null
+++ b/amogus.mers
@@ -0,0 +1,19 @@
+text = "ℑ𝔠𝔥 𝔨𝔞𝔫𝔫 𝔡𝔞𝔰 𝔳𝔢𝔯𝔡𝔞𝔪𝔪𝔱 𝔫𝔬𝔠𝔥 𝔪𝔞𝔩 𝔫𝔦𝔠𝔥𝔱 𝔤𝔩𝔞𝔲𝔟𝔢𝔫. 𝔓𝔦𝔫𝔨 𝔳𝔬𝔫 𝔲𝔫𝔱𝔢𝔯 𝔲𝔫𝔰 𝔥𝔞𝔱 𝔪𝔢𝔦𝔫𝔢 𝔈𝔥𝔢 𝔯𝔲𝔦𝔫𝔦𝔢𝔯𝔱. 𝔙𝔬𝔯 𝔢𝔦𝔫 𝔭𝔞𝔞𝔯 𝔐𝔬𝔫𝔞𝔱𝔢𝔫 𝔰𝔞𝔤𝔱𝔢 𝔪𝔢𝔦𝔫𝔢 𝔉𝔯𝔞𝔲, 𝔰𝔦𝔢 𝔴𝔲̈𝔯𝔡𝔢 𝔣𝔲̈𝔯 𝔢𝔦𝔫𝔢 𝔉𝔯𝔞𝔲𝔢𝔫𝔫𝔞𝔠𝔥𝔱 𝔞𝔲𝔰𝔤𝔢𝔥𝔢𝔫. 𝔖𝔦𝔢 𝔟𝔞𝔱 𝔪𝔦𝔠𝔥, 𝔞𝔲𝔣 𝔪𝔢𝔦𝔫𝔢𝔫 𝔖𝔬𝔥𝔫 𝔞𝔲𝔣𝔷𝔲𝔭𝔞𝔰𝔰𝔢𝔫, 𝔞𝔩𝔰𝔬 𝔴𝔞𝔯 𝔦𝔠𝔥 𝔰𝔬𝔣𝔬𝔯𝔱 𝔳𝔢𝔯𝔭𝔣𝔩𝔦𝔠𝔥𝔱𝔢𝔱. \"𝔍𝔞 𝔐𝔞'𝔞𝔪\", 𝔰𝔞𝔤𝔱𝔢 𝔦𝔠𝔥 𝔦𝔥𝔯. 𝔑𝔞𝔠𝔥 𝔢𝔦𝔫𝔢𝔯 𝔚𝔢𝔦𝔩𝔢 𝔡𝔢𝔰 𝔚𝔞𝔯𝔱𝔢𝔫𝔰 𝔤𝔦𝔫𝔤 𝔰𝔦𝔢 𝔢𝔫𝔡𝔩𝔦𝔠𝔥 𝔲𝔫𝔡 𝔦𝔠𝔥 𝔨𝔬𝔫𝔫𝔱𝔢 𝔪𝔢𝔦𝔫 𝔏𝔦𝔢𝔟𝔩𝔦𝔫𝔤𝔰𝔰𝔭𝔦𝔢𝔩 𝔲𝔫𝔱𝔢𝔯 𝔲𝔫𝔰 𝔰𝔭𝔦𝔢𝔩𝔢𝔫. ℑ𝔠𝔥 𝔥𝔲̈𝔭𝔣𝔱𝔢 𝔞𝔲𝔣 𝔪𝔢𝔦𝔫𝔢𝔫 𝔏𝔞𝔭𝔱𝔬𝔭, 𝔰𝔱𝔞𝔯𝔱𝔢𝔱𝔢 𝔦𝔥𝔫 𝔲𝔫𝔡 𝔩𝔲𝔡 𝔪𝔢𝔦𝔫𝔢𝔫 𝔇𝔢𝔰𝔨𝔱𝔬𝔭, 𝔨𝔬𝔪𝔭𝔩𝔢𝔱𝔱 𝔪𝔦𝔱 𝔡𝔢𝔪 𝔯𝔬𝔱𝔢𝔫 𝔖𝔲𝔰-ℌ𝔦𝔫𝔱𝔢𝔯𝔤𝔯𝔲𝔫𝔡 𝔲𝔫𝔡 𝔞𝔩𝔩 𝔪𝔢𝔦𝔫𝔢𝔯 ℑ𝔪𝔭𝔬𝔰𝔱𝔬𝔯-𝔉𝔞𝔫-𝔄𝔯𝔱 𝔲𝔫𝔱𝔢𝔯 𝔲𝔫𝔰. ℑ𝔠𝔥 𝔷𝔦𝔱𝔱𝔢𝔯𝔱𝔢 𝔳𝔬𝔯 𝔄𝔲𝔣𝔯𝔢𝔤𝔲𝔫𝔤. ℑ𝔠𝔥 𝔷𝔬𝔤 𝔪𝔢𝔦𝔫𝔢𝔫 𝔉𝔦𝔫𝔤𝔢𝔯 𝔩𝔞𝔫𝔤𝔰𝔞𝔪 𝔲̈𝔟𝔢𝔯 𝔡𝔞𝔰 𝔗𝔯𝔞𝔠𝔨𝔭𝔞𝔡 𝔲𝔫𝔡 𝔟𝔢𝔬𝔟𝔞𝔠𝔥𝔱𝔢𝔱𝔢 𝔡𝔢𝔫 ℭ𝔲𝔯𝔰𝔬𝔯, 𝔞𝔩𝔰 𝔢𝔯 𝔷𝔲 𝔡𝔢𝔪 𝔖𝔶𝔪𝔟𝔬𝔩 𝔲𝔫𝔱𝔢𝔯 𝔲𝔫𝔰 𝔤𝔩𝔦𝔱𝔱. 𝔲𝔫𝔱𝔢𝔯 𝔲𝔫𝔰. 𝔐𝔢𝔦𝔫 𝔞𝔟𝔰𝔬𝔩𝔲𝔱𝔢𝔰 𝔏𝔦𝔢𝔟𝔩𝔦𝔫𝔤𝔰𝔰𝔭𝔦𝔢𝔩 𝔞𝔩𝔩𝔢𝔯 ℨ𝔢𝔦𝔱𝔢𝔫 𝔲𝔫𝔡 𝔴𝔞𝔥𝔯𝔰𝔠𝔥𝔢𝔦𝔫𝔩𝔦𝔠𝔥 𝔡𝔞𝔰 𝔟𝔢𝔰𝔱𝔢 𝔲𝔫𝔡 𝔞𝔪 𝔟𝔢𝔰𝔱𝔢𝔫 𝔤𝔢𝔪𝔞𝔠𝔥𝔱𝔢 𝔖𝔭𝔦𝔢𝔩 𝔡𝔢𝔯 𝔚𝔢𝔩𝔱. 𝔄𝔩𝔰 𝔦𝔠𝔥 𝔞𝔲𝔣 𝔡𝔢𝔫 𝔎𝔫𝔬𝔭𝔣 𝔨𝔩𝔦𝔠𝔨𝔱𝔢, 𝔷𝔲𝔠𝔨𝔱𝔢 𝔪𝔢𝔦𝔫 𝔎𝔬̈𝔯𝔭𝔢𝔯 𝔳𝔬𝔯 𝔉𝔯𝔢𝔲𝔡𝔢 𝔟𝔢𝔦 𝔡𝔢𝔪 𝔊𝔢𝔡𝔞𝔫𝔨𝔢𝔫, 𝔴𝔦𝔢𝔡𝔢𝔯 𝔡𝔢𝔯 𝔅𝔢𝔱𝔯𝔲̈𝔤𝔢𝔯 𝔷𝔲 𝔰𝔢𝔦𝔫. 𝔐𝔢𝔦𝔫𝔢 𝔉𝔦𝔫𝔤𝔢𝔯 𝔱𝔯𝔬𝔪𝔪𝔢𝔩𝔱𝔢𝔫 𝔲𝔫𝔤𝔢𝔡𝔲𝔩𝔡𝔦𝔤 𝔞𝔲𝔣 𝔪𝔢𝔦𝔫𝔢𝔪 𝔖𝔠𝔥𝔯𝔢𝔦𝔟𝔱𝔦𝔰𝔠𝔥, 𝔞𝔩𝔰 𝔡𝔞𝔰 𝔏𝔬𝔤𝔬 𝔡𝔢𝔯 𝔦𝔫𝔫𝔢𝔯𝔢𝔫 𝔉𝔞𝔲𝔩𝔱𝔦𝔢𝔯𝔢 𝔢𝔦𝔫- 𝔲𝔫𝔡 𝔞𝔲𝔰𝔟𝔩𝔢𝔫𝔡𝔢𝔱𝔢. 𝔇𝔞𝔫𝔫 𝔢𝔯𝔰𝔠𝔥𝔦𝔢𝔫 𝔡𝔢𝔯 ℌ𝔞𝔲𝔭𝔱𝔱𝔦𝔱𝔢𝔩. ℑ𝔠𝔥 𝔰𝔞𝔥 𝔰𝔬𝔣𝔬𝔯𝔱 𝔭𝔦𝔫𝔨 𝔞𝔫, 𝔞𝔩𝔰 𝔰𝔦𝔢 𝔩𝔞𝔫𝔤𝔰𝔞𝔪 𝔲̈𝔟𝔢𝔯 𝔡𝔢𝔫 𝔅𝔦𝔩𝔡𝔰𝔠𝔥𝔦𝔯𝔪 𝔰𝔠𝔥𝔴𝔢𝔟𝔱𝔢. 𝔒𝔥, 𝔴𝔦𝔢 𝔦𝔠𝔥 𝔴𝔲̈𝔫𝔰𝔠𝔥𝔱𝔢, 𝔦𝔠𝔥 𝔨𝔬̈𝔫𝔫𝔱𝔢 𝔡𝔦𝔢𝔰𝔢 𝔲̈𝔭𝔭𝔦𝔤𝔢𝔫, 𝔴𝔢𝔦𝔠𝔥𝔢𝔫 𝔄𝔰𝔰𝔠𝔥𝔢𝔢𝔨𝔰 𝔣𝔲̈𝔥𝔩𝔢𝔫. 𝔓𝔦𝔫𝔨 𝔦𝔰𝔱 𝔪𝔢𝔦𝔫𝔢 𝔎𝔬̈𝔫𝔦𝔤𝔦𝔫. 𝔇𝔦𝔢 𝔢𝔠𝔥𝔱𝔢 𝔉𝔯𝔞𝔲 𝔦𝔫 𝔪𝔢𝔦𝔫𝔢𝔪 𝔏𝔢𝔟𝔢𝔫. 𝔐𝔢𝔦𝔫𝔢 𝔉𝔯𝔞𝔲 𝔨𝔬̈𝔫𝔫𝔱𝔢 𝔫𝔦𝔢𝔪𝔞𝔩𝔰 𝔰𝔬 𝔰𝔢𝔵𝔶 𝔰𝔢𝔦𝔫 𝔴𝔦𝔢 𝔓𝔦𝔫𝔨; ℑ𝔥𝔯𝔢 𝔩𝔢𝔦𝔰𝔢𝔫 𝔢𝔩𝔢𝔨𝔱𝔯𝔦𝔰𝔠𝔥𝔢𝔫 𝔖𝔠𝔥𝔯𝔦𝔱𝔱𝔢, 𝔞𝔩𝔰 𝔦𝔠𝔥 𝔞𝔲𝔰 𝔢𝔦𝔫𝔢𝔪 𝔄𝔟𝔷𝔲𝔤 𝔥𝔢𝔯𝔞𝔲𝔰 𝔞𝔲𝔣 𝔦𝔥𝔯𝔢 𝔨𝔲𝔯𝔳𝔦𝔤𝔢 𝔊𝔢𝔰𝔱𝔞𝔩𝔱 𝔰𝔠𝔥𝔞𝔲𝔢 𝔲𝔫𝔡 𝔞𝔲𝔣 𝔡𝔢𝔫 𝔯𝔦𝔠𝔥𝔱𝔦𝔤𝔢𝔫 ℨ𝔢𝔦𝔱𝔭𝔲𝔫𝔨𝔱 𝔣𝔲̈𝔯 𝔢𝔦𝔫𝔢𝔫 𝔖𝔠𝔥𝔩𝔞𝔤 𝔴𝔞𝔯𝔱𝔢. ℑ𝔠𝔥 𝔨𝔬𝔫𝔫𝔱𝔢 𝔓𝔦𝔫𝔨 𝔧𝔢𝔡𝔬𝔠𝔥 𝔫𝔦𝔢 𝔫𝔞𝔥𝔢 𝔨𝔬𝔪𝔪𝔢𝔫, 𝔞𝔩𝔰 𝔬𝔟 𝔰𝔦𝔢 𝔢𝔦𝔫𝔢𝔫 𝔰𝔢𝔠𝔥𝔰𝔱𝔢𝔫 𝔖𝔦𝔫𝔫 𝔥𝔞̈𝔱𝔱𝔢, 𝔰𝔦𝔢 𝔴𝔲̈𝔯𝔡𝔢 𝔦𝔪𝔪𝔢𝔯 𝔤𝔢𝔥𝔢𝔫, 𝔟𝔢𝔳𝔬𝔯 𝔦𝔠𝔥 𝔪𝔦𝔠𝔥 𝔦𝔥𝔯 𝔞𝔩𝔰 𝔅𝔢𝔱𝔯𝔲̈𝔤𝔢𝔯𝔦𝔫 𝔬𝔣𝔣𝔢𝔫𝔟𝔞𝔯𝔢𝔫 𝔨𝔬𝔫𝔫𝔱𝔢. ℑ𝔠𝔥 𝔡𝔯𝔲̈𝔠𝔨𝔢 𝔞𝔲𝔣 𝔘̈𝔟𝔢𝔫, 𝔲𝔪 𝔪𝔢𝔦𝔫𝔢 𝔉𝔦𝔫𝔤𝔢𝔯 𝔳𝔬𝔯 𝔪𝔢𝔦𝔫𝔢𝔪 𝔢𝔯𝔰𝔱𝔢𝔫 𝔦𝔫𝔱𝔢𝔫𝔰𝔦𝔳𝔢𝔫 𝔖𝔭𝔦𝔢𝔩 𝔲𝔫𝔱𝔢𝔯 𝔲𝔫𝔰 𝔞𝔲𝔣𝔷𝔲𝔴𝔞̈𝔯𝔪𝔢𝔫. ℑ𝔠𝔥 𝔡𝔯𝔲̈𝔠𝔨𝔢 𝔅𝔩𝔲𝔢 𝔦𝔫 ℭ𝔬𝔪𝔪𝔰, 𝔲̈𝔟𝔢𝔯𝔮𝔲𝔢𝔯𝔢 𝔡𝔞𝔫𝔫 𝔡𝔦𝔢 ℌ𝔞𝔩𝔩𝔢 𝔲𝔫𝔡 𝔤𝔢𝔥𝔢 𝔷𝔲 𝔖𝔭𝔢𝔠𝔦𝔪𝔢𝔫, 𝔲𝔪 𝔊𝔯𝔢𝔢𝔫 𝔨𝔞𝔩𝔱𝔟𝔩𝔲̈𝔱𝔦𝔤 𝔷𝔲 𝔢𝔯𝔪𝔬𝔯𝔡𝔢𝔫. 𝔇𝔢𝔯 𝔑𝔢𝔯𝔳𝔢𝔫𝔨𝔦𝔱𝔷𝔢𝔩, 𝔢𝔦𝔫𝔢𝔫 𝔞𝔫𝔦𝔪𝔦𝔢𝔯𝔱𝔢𝔫 ℭ𝔥𝔞𝔯𝔞𝔨𝔱𝔢𝔯 𝔦𝔫 𝔢𝔦𝔫𝔢𝔪 𝔒𝔫𝔩𝔦𝔫𝔢-𝔖𝔭𝔦𝔢𝔩 𝔷𝔲 𝔱𝔬̈𝔱𝔢𝔫, 𝔴𝔞𝔯 𝔫𝔬𝔠𝔥 𝔫𝔦𝔢 𝔰𝔬 𝔰𝔠𝔥𝔫𝔢𝔩𝔩. ℑ𝔠𝔥 𝔤𝔢𝔥𝔢 𝔡𝔞𝔫𝔫 𝔦𝔫 ℜ𝔦𝔠𝔥𝔱𝔲𝔫𝔤 ℜ𝔢𝔞𝔨𝔱𝔬𝔯, 𝔰𝔱𝔢𝔠𝔥𝔢 𝔊𝔢𝔩𝔟 𝔦𝔫 𝔡𝔢𝔫 ℜ𝔲̈𝔠𝔨𝔢𝔫 𝔲𝔫𝔡 𝔯𝔢𝔫𝔫𝔢 𝔡𝔞𝔫𝔫 𝔡𝔢𝔫 𝔎𝔬𝔯𝔯𝔦𝔡𝔬𝔯 𝔫𝔞𝔠𝔥 𝔯𝔢𝔠𝔥𝔱𝔰 𝔥𝔦𝔫𝔲𝔫𝔱𝔢𝔯, 𝔲𝔪 ℨ𝔲𝔤𝔞𝔫𝔤 𝔷𝔲𝔯 𝔇𝔢𝔨𝔬𝔫𝔱𝔞𝔪𝔦𝔫𝔞𝔱𝔦𝔬𝔫 𝔷𝔲 𝔢𝔯𝔥𝔞𝔩𝔱𝔢𝔫. ℑ𝔠𝔥 𝔟𝔢𝔴𝔢𝔤𝔢 𝔪𝔦𝔠𝔥 𝔩𝔢𝔦𝔰𝔢 𝔡𝔲𝔯𝔠𝔥 𝔡𝔦𝔢 ℌ𝔞𝔩𝔩𝔢𝔫, 𝔴𝔦𝔢 𝔢𝔦𝔫𝔢 𝔖𝔠𝔥𝔩𝔞𝔫𝔤𝔢, 𝔡𝔦𝔢 𝔤𝔢𝔯𝔞𝔡𝔢 𝔡𝔞𝔟𝔢𝔦 𝔦𝔰𝔱, 𝔦𝔥𝔯𝔢 𝔅𝔢𝔲𝔱𝔢 𝔷𝔲 𝔰𝔠𝔥𝔩𝔞𝔤𝔢𝔫, 𝔲𝔫𝔡 𝔦𝔠𝔥 𝔰𝔢𝔥𝔢 - 𝔒𝔥 𝔫𝔢𝔦𝔫. 𝔈𝔰 𝔦𝔰𝔱 𝔭𝔦𝔫𝔨. ℑ𝔠𝔥 𝔰𝔱𝔢𝔥𝔢 𝔯𝔢𝔤𝔲𝔫𝔤𝔰𝔩𝔬𝔰 𝔡𝔞 𝔲𝔫𝔡 𝔰𝔢𝔥𝔢 𝔰𝔦𝔢 𝔡𝔦𝔯𝔢𝔨𝔱 𝔞𝔫. ℑ𝔥𝔯 𝔙𝔦𝔰𝔦𝔢𝔯 𝔷𝔢𝔦𝔤𝔱 𝔨𝔢𝔦𝔫𝔢 𝔈𝔪𝔬𝔱𝔦𝔬𝔫𝔢𝔫. 𝔄𝔟𝔢𝔯 𝔰𝔦𝔢 𝔴𝔢𝔦ß 𝔢𝔰. ℑ𝔠𝔥 𝔨𝔞𝔫𝔫 𝔢𝔰 𝔦𝔫 𝔡𝔢𝔯 𝔏𝔲𝔣𝔱 𝔣𝔲̈𝔥𝔩𝔢𝔫. ℑ𝔠𝔥 𝔨𝔞𝔫𝔫 𝔰𝔦𝔢 𝔫𝔦𝔠𝔥𝔱 𝔱𝔬̈𝔱𝔢𝔫. 𝔖𝔦𝔢 𝔦𝔰𝔱 𝔷𝔲 𝔰𝔠𝔥𝔬̈𝔫, 𝔷𝔲 𝔢𝔫𝔤𝔢𝔩𝔥𝔞𝔣𝔱, 𝔡𝔞𝔰 𝔏𝔦𝔠𝔥𝔱 𝔴𝔦𝔯𝔡 𝔳𝔬𝔫 𝔦𝔥𝔯𝔢𝔪 𝔯𝔬𝔰𝔞 𝔅𝔬𝔡𝔶 𝔯𝔢𝔣𝔩𝔢𝔨𝔱𝔦𝔢𝔯𝔱, 𝔴𝔦𝔢 𝔖𝔱𝔢𝔯𝔫𝔢 𝔞𝔫 𝔢𝔦𝔫𝔢𝔪 𝔩𝔢𝔢𝔯𝔢𝔫 ℌ𝔦𝔪𝔪𝔢𝔩. 𝔖𝔦𝔢 𝔯𝔢𝔫𝔫𝔱 𝔫𝔦𝔠𝔥𝔱. ℑ𝔠𝔥 𝔟𝔦𝔫 𝔷𝔲 𝔗𝔯𝔞̈𝔫𝔢𝔫 𝔤𝔢𝔯𝔲̈𝔥𝔯𝔱, 𝔞𝔩𝔰 𝔦𝔠𝔥 𝔡𝔢𝔫 𝔅𝔦𝔩𝔡𝔰𝔠𝔥𝔦𝔯𝔪 𝔰𝔱𝔯𝔢𝔦𝔠𝔥𝔩𝔢 𝔲𝔫𝔡 𝔦𝔥𝔫 𝔷𝔞̈𝔯𝔱𝔩𝔦𝔠𝔥 𝔨𝔲̈𝔰𝔰𝔢. \"𝔄𝔲𝔣 𝔚𝔦𝔢𝔡𝔢𝔯𝔰𝔢𝔥𝔢𝔫, 𝔓𝔦𝔫𝔨. 𝔅𝔦𝔰 𝔟𝔞𝔩𝔡. 𝔈𝔰 𝔴𝔦𝔯𝔡 𝔞𝔩𝔩𝔢𝔰 𝔦𝔫 𝔒𝔯𝔡𝔫𝔲𝔫𝔤 𝔰𝔢𝔦𝔫\", 𝔣𝔩𝔲̈𝔰𝔱𝔢𝔯𝔢 𝔦𝔠𝔥 𝔪𝔦𝔱 𝔩𝔢𝔦𝔰𝔢𝔯, 𝔟𝔢𝔯𝔲𝔥𝔦𝔤𝔢𝔫𝔡𝔢𝔯 𝔖𝔱𝔦𝔪𝔪𝔢. 𝔇𝔞𝔫𝔫 𝔷𝔬̈𝔤𝔢𝔯𝔢 𝔦𝔠𝔥, 𝔴𝔞̈𝔥𝔯𝔢𝔫𝔡 𝔪𝔢𝔦𝔫 ℭ𝔲𝔯𝔰𝔬𝔯 𝔲̈𝔟𝔢𝔯 𝔡𝔢𝔪 𝔎𝔦𝔩𝔩-𝔅𝔲𝔱𝔱𝔬𝔫 𝔰𝔠𝔥𝔴𝔢𝔟𝔱. 𝔊𝔢𝔡𝔞𝔫𝔨𝔢𝔫 𝔡𝔢𝔯 𝔏𝔦𝔢𝔟𝔢 𝔤𝔢𝔥𝔢𝔫 𝔪𝔦𝔯 𝔡𝔲𝔯𝔠𝔥 𝔡𝔢𝔫 𝔎𝔬𝔭𝔣. ℜ𝔬𝔱 𝔪𝔦𝔱 𝔯𝔬̈𝔱𝔩𝔦𝔠𝔥-𝔯𝔬𝔰𝔞 𝔳𝔢𝔯𝔡𝔞̈𝔠𝔥𝔱𝔦𝔤𝔢𝔫 𝔎𝔦𝔫𝔡𝔢𝔯𝔫 𝔪𝔦𝔱 ℜ𝔬𝔰𝔞. 𝔄𝔟𝔢𝔯 𝔦𝔠𝔥 𝔪𝔲𝔰𝔰. 𝔄𝔩𝔰 𝔅𝔢𝔱𝔯𝔲̈𝔤𝔢𝔯 𝔦𝔰𝔱 𝔢𝔰 𝔪𝔢𝔦𝔫𝔢 𝔓𝔣𝔩𝔦𝔠𝔥𝔱 𝔷𝔲 𝔱𝔬̈𝔱𝔢𝔫. ℑ𝔠𝔥 𝔡𝔯𝔲̈𝔠𝔨𝔢 𝔡𝔢𝔫 '𝔎𝔦𝔩𝔩'-𝔎𝔫𝔬𝔭𝔣 𝔲𝔫𝔡 𝔟𝔢𝔬𝔟𝔞𝔠𝔥𝔱𝔢, 𝔴𝔦𝔢 𝔪𝔢𝔦𝔫 ℭ𝔥𝔞𝔯𝔞𝔨𝔱𝔢𝔯 𝔓𝔦𝔫𝔨 𝔩𝔞𝔲𝔱𝔩𝔬𝔰 𝔢𝔫𝔱𝔥𝔞𝔲𝔭𝔱𝔢𝔱. ℑ𝔠𝔥 𝔥𝔬̈𝔯𝔢 𝔫𝔲𝔯 𝔡𝔢𝔫 𝔅𝔩𝔲𝔱𝔰𝔱𝔯𝔞𝔥𝔩. 𝔎𝔢𝔦𝔫𝔢 𝔈𝔦𝔩𝔢. 𝔈𝔰 𝔤𝔦𝔟𝔱 𝔫𝔲𝔯 ℜ𝔢𝔡, 𝔡𝔢𝔯 𝔞𝔩𝔩𝔢𝔦𝔫𝔢 𝔦𝔫 𝔉𝔲𝔢𝔩 𝔰𝔱𝔢𝔥𝔱. ℜ𝔬𝔰𝔞𝔰 𝔩𝔢𝔟𝔩𝔬𝔰𝔢𝔯 𝔎𝔬̈𝔯𝔭𝔢𝔯 𝔩𝔞𝔤 𝔫𝔢𝔟𝔢𝔫 𝔦𝔥𝔪 𝔞𝔲𝔣 𝔡𝔢𝔪 𝔅𝔬𝔡𝔢𝔫. ℑ𝔠𝔥 𝔣𝔲̈𝔥𝔩𝔢 𝔷𝔲𝔢𝔯𝔰𝔱 𝔫𝔦𝔠𝔥𝔱𝔰, 𝔡𝔞𝔫𝔫 𝔲𝔫𝔢𝔯𝔪𝔢𝔰𝔰𝔩𝔦𝔠𝔥𝔢 𝔗𝔯𝔞𝔲𝔯𝔦𝔤𝔨𝔢𝔦𝔱, 𝔞𝔩𝔰 𝔴𝔞̈𝔯𝔢 𝔦𝔠𝔥 𝔟𝔢𝔦 𝔡𝔢𝔯 𝔅𝔢𝔢𝔯𝔡𝔦𝔤𝔲𝔫𝔤 𝔢𝔦𝔫𝔢𝔰 𝔤𝔢𝔩𝔦𝔢𝔟𝔱𝔢𝔫 𝔐𝔢𝔫𝔰𝔠𝔥𝔢𝔫. 𝔐𝔢𝔦𝔫 𝔖𝔬𝔥𝔫 𝔨𝔩𝔬𝔭𝔣𝔱 𝔞𝔫 𝔡𝔦𝔢 𝔗𝔲̈𝔯 𝔲𝔫𝔡 𝔲𝔫𝔱𝔢𝔯𝔟𝔯𝔦𝔠𝔥𝔱 𝔪𝔢𝔦𝔫𝔢𝔫 𝔨𝔲𝔯𝔷𝔢𝔫 𝔐𝔬𝔪𝔢𝔫𝔱 𝔡𝔢𝔯 𝔗𝔯𝔞𝔲𝔢𝔯. 𝔈𝔯 𝔣𝔯𝔞𝔤𝔱: \"𝔇𝔞𝔡? 𝔚𝔦𝔯𝔰𝔱 𝔡𝔲 𝔪𝔦𝔯 𝔢𝔦𝔫𝔢𝔫 𝔖𝔫𝔞𝔠𝔨 𝔪𝔞𝔠𝔥𝔢𝔫?\" ℑ𝔠𝔥 𝔰𝔞𝔤𝔢 𝔦𝔥𝔪, 𝔢𝔯 𝔰𝔬𝔩𝔩 𝔡𝔦𝔢 𝔎𝔩𝔞𝔭𝔭𝔢 𝔥𝔞𝔩𝔱𝔢𝔫, 𝔲𝔫𝔡 𝔪𝔢𝔦𝔫𝔢 𝔖𝔱𝔦𝔪𝔪𝔢 𝔟𝔯𝔦𝔠𝔥𝔱. ℑ𝔠𝔥 𝔟𝔯𝔢𝔠𝔥𝔢 𝔰𝔠𝔥𝔩𝔲𝔠𝔥𝔷𝔢𝔫𝔡 𝔷𝔲𝔰𝔞𝔪𝔪𝔢𝔫. ℑ𝔠𝔥 𝔥𝔞𝔟𝔢 𝔰𝔦𝔢 𝔤𝔢𝔱𝔬̈𝔱𝔢𝔱. ℑ𝔠𝔥 𝔥𝔞𝔟𝔢 𝔪𝔢𝔦𝔫𝔢 𝔢𝔦𝔫𝔷𝔦𝔤 𝔴𝔞𝔥𝔯𝔢 𝔏𝔦𝔢𝔟𝔢 𝔤𝔢𝔱𝔬̈𝔱𝔢𝔱. 𝔊𝔬𝔱𝔱 𝔳𝔢𝔯𝔤𝔦𝔟 𝔪𝔦𝔯. ℑ𝔠𝔥 𝔬̈𝔣𝔣𝔫𝔢 𝔪𝔢𝔦𝔫𝔢𝔪 𝔖𝔬𝔥𝔫 𝔡𝔦𝔢 𝔗𝔲̈𝔯 𝔲𝔫𝔡 𝔢𝔯 𝔥𝔞𝔱 𝔢𝔦𝔫𝔢𝔫 𝔳𝔢𝔯𝔴𝔦𝔯𝔯𝔱𝔢𝔫 𝔊𝔢𝔰𝔦𝔠𝔥𝔱𝔰𝔞𝔲𝔰𝔡𝔯𝔲𝔠𝔨. ℑ𝔠𝔥 𝔰𝔞𝔤𝔢 𝔫𝔦𝔠𝔥𝔱𝔰 𝔲𝔫𝔡 𝔤𝔢𝔥𝔢 𝔦𝔫 𝔡𝔦𝔢 𝔎𝔲̈𝔠𝔥𝔢, 𝔲𝔪 𝔦𝔥𝔪 𝔢𝔦𝔫 𝔖𝔞𝔫𝔡𝔴𝔦𝔠𝔥 𝔷𝔲 𝔪𝔞𝔠𝔥𝔢𝔫. 𝔗𝔯𝔞̈𝔫𝔢𝔫 𝔯𝔬𝔩𝔩𝔢𝔫 𝔳𝔬𝔫 𝔪𝔢𝔦𝔫𝔢𝔪 𝔊𝔢𝔰𝔦𝔠𝔥𝔱 𝔦𝔫𝔰 𝔅𝔯𝔬𝔱, 𝔞𝔩𝔰 𝔦𝔠𝔥 𝔢𝔰 𝔞𝔲𝔣 𝔡𝔦𝔢 𝔗𝔥𝔢𝔨𝔢 𝔩𝔢𝔤𝔢. 𝔖𝔞𝔩𝔞𝔱, 𝔎𝔞̈𝔰𝔢 𝔲𝔫𝔡 𝔉𝔩𝔢𝔦𝔰𝔠𝔥, 𝔤𝔢𝔣𝔬𝔩𝔤𝔱 𝔳𝔬𝔫 𝔢𝔦𝔫𝔢𝔪 𝔱𝔯𝔞𝔲𝔯𝔦𝔤𝔢𝔫 𝔚𝔦𝔯𝔟𝔢𝔩 𝔞𝔲𝔰 𝔖𝔢𝔫𝔣. 𝔐𝔢𝔦𝔫 𝔖𝔬𝔥𝔫 𝔦𝔰𝔱 𝔰𝔱𝔦𝔩𝔩. 𝔈𝔯 𝔰𝔦𝔱𝔷𝔱 𝔞𝔲𝔣 𝔡𝔢𝔯 ℭ𝔬𝔲𝔠𝔥 𝔲𝔫𝔡 𝔰𝔱𝔞𝔯𝔯𝔱 𝔞𝔲𝔣 𝔡𝔢𝔫 𝔅𝔬𝔡𝔢𝔫. 𝔈𝔰 𝔦𝔰𝔱 𝔢𝔦𝔫𝔢 𝔡𝔢𝔭𝔯𝔦𝔪𝔦𝔢𝔯𝔢𝔫𝔡𝔢 𝔏𝔲𝔣𝔱 𝔲𝔪 𝔲𝔫𝔰 𝔥𝔢𝔯𝔲𝔪. ℑ𝔠𝔥 𝔰𝔢𝔯𝔳𝔦𝔢𝔯𝔢 𝔦𝔥𝔪 𝔡𝔞𝔰 𝔖𝔞𝔫𝔡𝔴𝔦𝔠𝔥 𝔲𝔫𝔡 𝔤𝔢𝔥𝔢 𝔷𝔲𝔯𝔲̈𝔠𝔨 𝔦𝔫 𝔪𝔢𝔦𝔫 ℨ𝔦𝔪𝔪𝔢𝔯, 𝔲𝔪 𝔲̈𝔟𝔢𝔯 𝔡𝔞𝔰 𝔏𝔢𝔟𝔢𝔫 𝔫𝔞𝔠𝔥𝔷𝔲𝔡𝔢𝔫𝔨𝔢𝔫. 𝔚𝔢𝔫𝔫 𝔦𝔠𝔥 𝔓𝔦𝔫𝔨 𝔤𝔢𝔱𝔬̈𝔱𝔢𝔱 𝔥𝔞𝔟𝔢, 𝔴𝔦𝔢 𝔨𝔞𝔫𝔫 𝔦𝔠𝔥 𝔪𝔢𝔦𝔫𝔢𝔯 𝔉𝔞𝔪𝔦𝔩𝔦𝔢 𝔳𝔢𝔯𝔱𝔯𝔞𝔲𝔢𝔫? ℑ𝔠𝔥 𝔴𝔢𝔦𝔫𝔢 𝔰𝔱𝔲𝔫𝔡𝔢𝔫𝔩𝔞𝔫𝔤 𝔲𝔫𝔡 𝔰𝔠𝔥𝔩𝔦𝔢ß𝔩𝔦𝔠𝔥 𝔨𝔬𝔪𝔪𝔱 𝔪𝔢𝔦𝔫𝔢 𝔉𝔯𝔞𝔲 𝔷𝔲𝔯𝔲̈𝔠𝔨. 𝔖𝔦𝔢 𝔰𝔦𝔢𝔥𝔱 𝔪𝔦𝔠𝔥 𝔞𝔲𝔣 𝔡𝔢𝔪 𝔅𝔢𝔱𝔱 𝔟𝔯𝔲̈𝔩𝔩𝔢𝔫 𝔴𝔦𝔢 𝔢𝔦𝔫 𝔎𝔦𝔫𝔡, 𝔡𝔞𝔰 𝔰𝔢𝔦𝔫 𝔈𝔦𝔰 𝔣𝔞𝔩𝔩𝔢𝔫 𝔩𝔦𝔢ß. 𝔖𝔦𝔢 𝔣𝔯𝔞𝔤𝔱 𝔪𝔦𝔠𝔥 𝔡𝔞𝔫𝔫, 𝔴𝔞𝔯𝔲𝔪 𝔦𝔠𝔥 𝔴𝔢𝔦𝔫𝔢 𝔲𝔫𝔡 𝔪𝔲𝔯𝔪𝔩𝔢: \"ℑ𝔠𝔥 𝔥𝔞𝔟𝔢 𝔰𝔦𝔢 𝔤𝔢𝔱𝔬̈𝔱𝔢𝔱. ℑ𝔠𝔥 𝔥𝔞𝔟𝔢 𝔪𝔢𝔦𝔫𝔢 𝔢𝔦𝔫𝔷𝔦𝔤𝔢 𝔏𝔦𝔢𝔟𝔢, 𝔓𝔦𝔫𝔨, 𝔲𝔫𝔱𝔢𝔯 𝔲𝔫𝔰 𝔤𝔢𝔱𝔬̈𝔱𝔢𝔱.\" 𝔖𝔦𝔢 𝔦𝔰𝔱 𝔳𝔬𝔩𝔩𝔢𝔯 𝔚𝔲𝔱 𝔲𝔫𝔡 𝔰𝔠𝔥𝔩𝔞̈𝔤𝔱 𝔪𝔦𝔯 𝔦𝔫𝔰 𝔊𝔢𝔰𝔦𝔠𝔥𝔱. ℑ𝔠𝔥 𝔣𝔲̈𝔥𝔩𝔢 𝔪𝔦𝔠𝔥 𝔟𝔢𝔫𝔬𝔪𝔪𝔢𝔫. 𝔖𝔦𝔢 𝔟𝔦𝔱𝔱𝔢𝔱 𝔲𝔪 𝔖𝔠𝔥𝔢𝔦𝔡𝔲𝔫𝔤. ℑ𝔠𝔥 𝔞𝔫𝔱𝔴𝔬𝔯𝔱𝔢 𝔫𝔦𝔠𝔥𝔱. 𝔖𝔱𝔞𝔱𝔱𝔡𝔢𝔰𝔰𝔢𝔫 𝔫𝔢𝔥𝔪𝔢 𝔦𝔠𝔥 𝔪𝔢𝔦𝔫𝔢𝔫 𝔏𝔞𝔭𝔱𝔬𝔭, 𝔰𝔱𝔢𝔦𝔤𝔢 𝔦𝔫 𝔪𝔢𝔦𝔫 𝔄𝔲𝔱𝔬 𝔲𝔫𝔡 𝔣𝔞𝔥𝔯𝔢 𝔷𝔲 𝔢𝔦𝔫𝔢𝔪 𝔫𝔞𝔥𝔢 𝔤𝔢𝔩𝔢𝔤𝔢𝔫𝔢𝔫 ℌ𝔬𝔱𝔢𝔩. 𝔖𝔠𝔥𝔫𝔢𝔩𝔩𝔢𝔯 𝔙𝔬𝔯𝔩𝔞𝔲𝔣 𝔢𝔦𝔫𝔦𝔤𝔢 𝔐𝔬𝔫𝔞𝔱𝔢 𝔟𝔦𝔰 𝔷𝔲𝔯 𝔖𝔠𝔥𝔢𝔦𝔡𝔲𝔫𝔤. 𝔈𝔰 𝔴𝔞𝔯 𝔰𝔠𝔥𝔫𝔢𝔩𝔩 𝔲𝔫𝔡 𝔰𝔠𝔥𝔪𝔢𝔯𝔷𝔩𝔬𝔰. 𝔑𝔞𝔠𝔥 𝔡𝔢𝔪 𝔊𝔢𝔯𝔦𝔠𝔥𝔱 𝔟𝔦𝔱𝔱𝔢 𝔦𝔠𝔥 𝔪𝔢𝔦𝔫𝔢 𝔣𝔯𝔲̈𝔥𝔢𝔯𝔢 𝔉𝔯𝔞𝔲, 𝔪𝔦𝔠𝔥 𝔷𝔲𝔯𝔲̈𝔠𝔨𝔷𝔲𝔫𝔢𝔥𝔪𝔢𝔫. \"ℑ𝔠𝔥 𝔨𝔞𝔫𝔫 𝔡𝔦𝔠𝔥 𝔫𝔦𝔠𝔥𝔱 𝔷𝔲𝔯𝔲̈𝔠𝔨𝔫𝔢𝔥𝔪𝔢𝔫. 𝔇𝔲 𝔴𝔞𝔯𝔰𝔱 𝔦𝔪𝔪𝔢𝔯 𝔰𝔬. ℑ𝔠𝔥 𝔴𝔞𝔯 𝔡𝔦𝔯 𝔳𝔬𝔫 𝔄𝔫𝔣𝔞𝔫𝔤 𝔞𝔫 𝔪𝔦𝔰𝔰𝔱𝔯𝔞𝔲𝔦𝔰𝔠𝔥."
+
+// 1/n change to return true
+fn random(min int max int) {
+    run_command("fish" ["-c" "random " + min.to_string() + " " + max.to_string() ...]).assume_no_enum().1.trim().parse_int().assume1()
+}
+fn rnd() random(5 15)
+
+words = rnd()
+for word text.regex("\\S+").assume_no_enum()
+    if words > 0 {
+        print(word + " ")
+        words = words - 1
+    } else if words == 0 {
+        println(word)
+        words = rnd()
+        sleep(0.75)
+    }
+println(" ~ ~ ~ ~ ~ ~ ~ ~ ~ ~")
diff --git a/get_ref.mers b/get_ref.mers
index a3801ac..f184436 100644
--- a/get_ref.mers
+++ b/get_ref.mers
@@ -1,8 +1,10 @@
 list = [1 2 3 4 5 6 7 8 9 ...]
 
-second = &list.get_ref(2).assume1()
-second.debug()
-*second = 24
-second.debug()
+// second = &list.get_ref(2).assume1()
+// second.debug()
+// *second = 24
+// second.debug()
+
+&list.get_ref(2).assume1() = 24
 
 list.debug()
diff --git a/http.mers b/http.mers
index 7c3c78a..954b6cf 100644
--- a/http.mers
+++ b/http.mers
@@ -12,6 +12,6 @@ sleep(0.5)
 http_get("https:\//github.com/").assume_no_enum()
 println("got github start page as html")
 
-// t.await()
+t.await()
 
 http_get("not a url").debug()
diff --git a/iterators.mers b/iterators.mers
index 3472508..ff4d2af 100755
--- a/iterators.mers
+++ b/iterators.mers
@@ -19,3 +19,21 @@ fn map_string_to_int(list [string ...] func fn((string int))) {
 for v ["1" "2" "5" "-10" ...].map_string_to_int((s string) s.parse_int().assume1("list contained strings that can't be parsed to an int!")) {
     debug(v)
 }
+
+
+// returns an iterator to iteratively compute square numbers
+// using the fact that (n+1)^2 = n^2 + 2n + 1
+fn square_numbers() {
+    i = 0
+    val = 0
+    () {
+        val = val + { 2 * i } + 1
+        i = i + 1
+        [val]
+    }
+}
+
+for n square_numbers() {
+    println(n.to_string())
+    n >= 100
+}
diff --git a/mers/a.mers b/mers/a.mers
new file mode 100644
index 0000000..0edeae7
--- /dev/null
+++ b/mers/a.mers
@@ -0,0 +1,4 @@
+a = 1
+b = 2
+a.debug()
+b.debug()
diff --git a/mers/src/main.rs b/mers/src/main.rs
index b3fd4da..6b933b2 100755
--- a/mers/src/main.rs
+++ b/mers/src/main.rs
@@ -128,6 +128,8 @@ fn normal_main() {
     };
     match parsing::parse::parse(&mut file) {
         Ok(script) => {
+            #[cfg(debug_assertions)]
+            eprintln!("{script:#?}");
             println!(" - - - - -");
             let start = Instant::now();
             let out = script.run(std::env::args().skip(2).collect());
diff --git a/mers/src/nushell_plugin.rs b/mers/src/nushell_plugin.rs
index 07b50a2..57b5cbb 100755
--- a/mers/src/nushell_plugin.rs
+++ b/mers/src/nushell_plugin.rs
@@ -120,10 +120,7 @@ impl Plugin for MersNuPlugin {
             }
             Err(e) => Value::Error {
                 error: Box::new(ShellError::IncorrectValue {
-                    msg: format!(
-                        "Couldn't compile mers, error: {}",
-                        e.with_file(&file)
-                    ),
+                    msg: format!("Couldn't compile mers, error: {}", e.with_file(&file)),
                     span: source_span,
                 }),
             },
diff --git a/mers/src/parsing/parse.rs b/mers/src/parsing/parse.rs
index f5cb11f..6e7f822 100755
--- a/mers/src/parsing/parse.rs
+++ b/mers/src/parsing/parse.rs
@@ -148,6 +148,9 @@ pub fn parse(file: &mut File) -> Result<RScript, Error> {
         Err(e) => return Err((e.into(), ginfo.to_arc()).into()),
     };
 
+    #[cfg(debug_assertions)]
+    eprintln!("{func:#?}");
+
     ginfo.libs = match parse_step_libs_load(libs, &mut ginfo) {
         Ok(v) => v,
         Err(e) => return Err((e.into(), ginfo.to_arc()).into()),
@@ -533,11 +536,12 @@ pub mod implementation {
     }
 
     pub(crate) fn parse_statement(file: &mut File) -> Result<SStatement, ParseError> {
-        parse_statement_adv(file, false)
+        parse_statement_adv(file, false, 0)
     }
     pub(crate) fn parse_statement_adv(
         file: &mut File,
         is_part_of_chain_already: bool,
+        chain_level: usize,
     ) -> Result<SStatement, ParseError> {
         file.skip_whitespaces();
         let err_start_of_statement = *file.get_pos();
@@ -589,37 +593,6 @@ pub mod implementation {
                 };
                 match nchar {
                     Some(':') => {
-                        let file_pos_before_pot_type = *file.get_pos();
-                        let parsed_type = parse_type(file);
-                        file.skip_whitespaces();
-                        if let Some('=') = file.next() {
-                            let err_equals_sign = *file.get_pos();
-                            let start = start.trim();
-                            let derefs = start.chars().take_while(|c| *c == '*').count();
-                            match parse_statement(file) {
-                            Ok(v) => break v
-                                .output_to(start[derefs..].to_owned(), derefs)
-                                .force_output_type(Some(match parsed_type {
-                                    Ok(v) => v,
-                                    Err(mut e) => {
-                                        e.context.push((
-                                            format!("interpreted this as an assignment to a variable with the format <var>::<var_type> = <statement>"), Some((err_start_of_statement, Some(err_equals_sign)))
-                                        ));
-                                        return Err(e);
-                                    }
-                                })),
-                            Err(mut e) => {
-                                e.context.push((
-                                    format!(
-                                        "statement was supposed to be assigned to variable {start}"
-                                    ),
-                                    Some((err_start_of_statement, Some(err_equals_sign))),
-                                ));
-                                return Err(e);
-                            }
-                        }
-                        }
-                        file.set_pos(file_pos_before_pot_type);
                         return Ok(SStatement::new(SStatementEnum::EnumVariant(
                             start,
                             parse_statement(file)?,
@@ -636,25 +609,6 @@ pub mod implementation {
                             });
                         }
                         file.skip_whitespaces();
-                        // var = statement
-                        if let Some('=') = file.peek() {
-                            file.next();
-                            let err_equals_sign = *file.get_pos();
-                            let start = start.trim();
-                            let derefs = start.chars().take_while(|c| *c == '*').count();
-                            match parse_statement(file) {
-                                Ok(v) => break v.output_to(start[derefs..].to_owned(), derefs),
-                                Err(mut e) => {
-                                    e.context.push((
-                                        format!(
-                                        "statement was supposed to be assigned to variable {start}"
-                                    ),
-                                        Some((err_start_of_statement, Some(err_equals_sign))),
-                                    ));
-                                    return Err(e);
-                                }
-                            };
-                        }
                         // parse normal statement
                         let start = start.trim();
                         match start {
@@ -889,23 +843,21 @@ pub mod implementation {
             }
         };
         let err_end_of_original_statement = *file.get_pos();
-        file.skip_whitespaces();
-        if !file[file.get_pos().current_char_index..].starts_with("..") {
-            // dot chain syntax only works if there is only one dot
-            if let Some('.') = file.peek() {
-                // consume the dot (otherwise, a.b.c syntax will break in certain cases)
-                file.next();
-            }
-            if !is_part_of_chain_already {
-                let mut chain_length = 0;
-                let mut err_end_of_prev = err_end_of_original_statement;
-                while let Some('.') =
-                    file.get_char(file.get_pos().current_char_index.saturating_sub(1))
+        // special characters that can follow a statement (loop because these can be chained)
+        loop {
+            file.skip_whitespaces();
+            out = match (chain_level, file.peek()) {
+                (0..=200, Some('.'))
+                    if !matches!(
+                        file.get_char(file.get_pos().current_char_index + 1),
+                        Some('.')
+                    ) =>
                 {
+                    file.next();
                     let err_start_of_wrapper = *file.get_pos();
-                    let wrapper = parse_statement_adv(file, true)?;
+                    let wrapper = parse_statement_adv(file, true, 250)?;
                     let err_end_of_wrapper = *file.get_pos();
-                    out = match *wrapper.statement {
+                    match *wrapper.statement {
                         SStatementEnum::FunctionCall(func, args) => {
                             let args = [out].into_iter().chain(args.into_iter()).collect();
                             SStatementEnum::FunctionCall(func, args).to()
@@ -913,67 +865,131 @@ pub mod implementation {
                         SStatementEnum::Value(vd) => match &vd.data().0 {
                             VDataEnum::Int(i) => SStatementEnum::IndexFixed(out, *i as _).to(),
                             _ => {
-                                let mut context = vec![];
-                                if chain_length > 0 {
-                                    context.push((
-                                        format!(
-                                            "this is the {} wrapping statement in a chain.",
-                                            match chain_length {
-                                                1 => format!("second"),
-                                                2 => format!("third"),
-                                                // NOTE: this technically breaks at 21, but I don't care.
-                                                len => format!("{}th", len + 1),
-                                            }
-                                        ),
-                                        None,
-                                    ));
-                                }
-                                context.push((
-                                    format!("the statement that was supposed to be wrapped"),
-                                    Some((err_start_of_statement, Some(err_end_of_prev))),
-                                ));
                                 return Err(ParseError {
                                     err: ParseErrors::CannotUseFixedIndexingWithThisType(vd.out()),
                                     location: err_start_of_wrapper,
                                     location_end: Some(err_end_of_wrapper),
-                                    context,
+                                    context: vec![(
+                                        format!("this is a wrapping statement (a.f(), a.0, etc.).",),
+                                        None,
+                                    )],
                                     info: None,
                                 });
                             }
                         },
                         other => {
-                            let mut context = vec![];
-                            if chain_length > 0 {
-                                context.push((
-                                    format!(
-                                        "this is the {} wrapping statement in a chain.",
-                                        match chain_length {
-                                            1 => format!("second"),
-                                            2 => format!("third"),
-                                            // NOTE: this technically breaks at 21, but I don't care.
-                                            len => format!("{}th", len + 1),
-                                        }
-                                    ),
-                                    None,
-                                ));
-                            }
-                            context.push((
-                                format!("the statement that was supposed to be wrapped"),
-                                Some((err_start_of_statement, Some(err_end_of_prev))),
-                            ));
                             return Err(ParseError {
                                 err: ParseErrors::CannotWrapWithThisStatement(other),
                                 location: err_start_of_wrapper,
                                 location_end: Some(err_end_of_wrapper),
-                                context,
+                                context: vec![(
+                                    format!("this is a wrapping statement (a.f(), a.0, etc.).",),
+                                    None,
+                                )],
                                 info: None,
                             });
                         }
-                    };
-                    err_end_of_prev = err_end_of_wrapper;
-                    chain_length += 1;
+                    }
                 }
-            }
+                (0..=100, Some('+')) => {
+                    file.next();
+                    SStatementEnum::FunctionCall(
+                        "add".to_owned(),
+                        // AMONG
+                        vec![out, parse_statement_adv(file, true, 100)?],
+                    )
+                    .to()
+                }
+                (0..=100, Some('-')) => {
+                    file.next();
+                    SStatementEnum::FunctionCall(
+                        "sub".to_owned(),
+                        // US
+                        vec![out, parse_statement_adv(file, true, 100)?],
+                    )
+                    .to()
+                }
+                (0..=100, Some('*')) => {
+                    file.next();
+                    SStatementEnum::FunctionCall(
+                        "mul".to_owned(),
+                        vec![out, parse_statement_adv(file, true, 100)?],
+                    )
+                    .to()
+                }
+                (0..=100, Some('/')) => {
+                    file.next();
+                    SStatementEnum::FunctionCall(
+                        "div".to_owned(),
+                        // RED SUSSY MOGUS MAN
+                        vec![out, parse_statement_adv(file, true, 100)?],
+                    )
+                    .to()
+                }
+                (0..=100, Some('%')) => {
+                    file.next();
+                    SStatementEnum::FunctionCall(
+                        "mod".to_owned(),
+                        vec![out, parse_statement_adv(file, true, 100)?],
+                    )
+                    .to()
+                }
+                (0..=50, Some('>')) => {
+                    file.next();
+                    SStatementEnum::FunctionCall(
+                        if let Some('=') = file.peek() {
+                            file.next();
+                            "gtoe".to_owned()
+                        } else {
+                            "gt".to_owned()
+                        },
+                        vec![out, parse_statement_adv(file, true, 50)?],
+                    )
+                    .to()
+                }
+                (0..=50, Some('<')) => {
+                    file.next();
+                    SStatementEnum::FunctionCall(
+                        if let Some('=') = file.peek() {
+                            file.next();
+                            "ltoe".to_owned()
+                        } else {
+                            "lt".to_owned()
+                        },
+                        vec![out, parse_statement_adv(file, true, 50)?],
+                    )
+                    .to()
+                }
+                (0..=50, Some('='))
+                    if matches!(
+                        file.get_char(file.get_pos().current_char_index + 1),
+                        Some('=')
+                    ) =>
+                {
+                    file.next();
+                    file.next();
+                    SStatementEnum::FunctionCall(
+                        "eq".to_owned(),
+                        vec![out, parse_statement_adv(file, true, 50)?],
+                    )
+                    .to()
+                }
+                (0..=10, Some('=')) => {
+                    file.next();
+                    match out.statement.as_mut() {
+                        SStatementEnum::Variable(name, r) => {
+                            if name.starts_with("*") {
+                                *name = name[1..].to_owned();
+                            } else {
+                                *r = true
+                            }
+                        }
+                        _ => {}
+                    }
+                    parse_statement(file)?.output_to(out, 0)
+                }
+                _ => break,
+            };
         }
         Ok(out)
     }
diff --git a/mers/src/script/code_macro.rs b/mers/src/script/code_macro.rs
index d0889ba..3c940f3 100755
--- a/mers/src/script/code_macro.rs
+++ b/mers/src/script/code_macro.rs
@@ -63,6 +63,7 @@ fn parse_mers_code(file: &mut File) -> Result<RScript, MacroError> {
     }
 }
 
+#[derive(Debug)]
 pub enum Macro {
     /// Compiles and executes the provided mers code at compile-time and inserts the value
     StaticMers(VData),
diff --git a/mers/src/script/code_parsed.rs b/mers/src/script/code_parsed.rs
index 33fc065..eb2f66e 100755
--- a/mers/src/script/code_parsed.rs
+++ b/mers/src/script/code_parsed.rs
@@ -2,6 +2,7 @@ use std::fmt::{self, Display, Formatter, Pointer};
 
 use super::{code_macro::Macro, global_info::GlobalScriptInfo, val_data::VData, val_type::VType};
 
+#[derive(Debug)]
 pub enum SStatementEnum {
     Value(VData),
     Tuple(Vec<SStatement>),
@@ -30,8 +31,9 @@ impl SStatementEnum {
     }
 }
 
+#[derive(Debug)]
 pub struct SStatement {
-    pub output_to: Option<(String, usize)>,
+    pub output_to: Option<(Box<SStatement>, usize)>,
     pub statement: Box<SStatementEnum>,
     pub force_output_type: Option<VType>,
 }
@@ -44,8 +46,8 @@ impl SStatement {
             force_output_type: None,
         }
     }
-    pub fn output_to(mut self, var: String, derefs: usize) -> Self {
-        self.output_to = Some((var, derefs));
+    pub fn output_to(mut self, statement: SStatement, derefs: usize) -> Self {
+        self.output_to = Some((Box::new(statement), derefs));
         self
     }
     // forces the statement's output to fit in a certain type.
@@ -56,6 +58,7 @@ impl SStatement {
 }
 
 /// A block of code is a collection of statements.
+#[derive(Debug)]
 pub struct SBlock {
     pub statements: Vec<SStatement>,
 }
@@ -66,6 +69,7 @@ impl SBlock {
 }
 
 // A function is a block of code that starts with some local variables as inputs and returns some value as its output. The last statement in the block will be the output.
+#[derive(Debug)]
 pub struct SFunction {
     pub inputs: Vec<(String, VType)>,
     pub block: SBlock,
diff --git a/mers/src/script/code_runnable.rs b/mers/src/script/code_runnable.rs
index 85dc9a8..8945f3d 100755
--- a/mers/src/script/code_runnable.rs
+++ b/mers/src/script/code_runnable.rs
@@ -82,32 +82,23 @@ impl RFunction {
 #[derive(Clone, Debug)]
 pub struct RStatement {
     // (_, _, is_init)
-    pub output_to: Option<(usize, usize, bool)>,
+    pub output_to: Option<(Box<RStatement>, usize, bool)>,
     statement: Box<RStatementEnum>,
     pub force_output_type: Option<VType>,
 }
 impl RStatement {
     pub fn run(&self, vars: &mut Vec<VData>, info: &GSInfo) -> VData {
         let out = self.statement.run(vars, info);
-        if let Some((v, derefs, is_init)) = self.output_to {
-            // let mut parent = None;
-            let mut val = &mut vars[v];
-            fn deref(n: usize, val: &mut VData, is_init: bool, out: VData) {
-                if n == 0 {
-                    if is_init {
-                        *val = out.inner().to();
-                    } else {
-                        val.assign(out.inner());
-                    }
-                } else {
-                    if let VDataEnum::Reference(r) = &mut val.data().0 {
-                        deref(n - 1, r, is_init, out)
-                    } else {
-                        unreachable!("cannot derefence: not a reference.");
-                    }
-                }
+        if let Some((v, derefs, is_init)) = &self.output_to {
+            let mut val = v.run(vars, info);
+            // even if 0 derefs, deref once because it *has* to end on a reference (otherwise writing to it would be unacceptable as the value might not expect to be modified)
+            for _ in 0..(derefs + 1) {
+                val = match val.inner().deref() {
+                    Some(v) => v,
+                    None => unreachable!("can't dereference..."),
+                };
             }
-            deref(derefs, val, is_init, out);
+            val.assign(out.inner());
             VDataEnum::Tuple(vec![]).to()
         } else {
             out
@@ -370,6 +361,7 @@ impl RStatementEnum {
     }
 }
 
+#[derive(Debug)]
 pub struct RScript {
     main: RFunction,
     info: GSInfo,
diff --git a/mers/src/script/global_info.rs b/mers/src/script/global_info.rs
index fb15c24..7230982 100755
--- a/mers/src/script/global_info.rs
+++ b/mers/src/script/global_info.rs
@@ -6,6 +6,7 @@ use super::{builtins, val_type::VType};
 
 pub type GSInfo = Arc<GlobalScriptInfo>;
 
+#[derive(Debug)]
 pub struct GlobalScriptInfo {
     pub vars: usize,
 
diff --git a/mers/src/script/to_runnable.rs b/mers/src/script/to_runnable.rs
index c2d50aa..1e4be51 100755
--- a/mers/src/script/to_runnable.rs
+++ b/mers/src/script/to_runnable.rs
@@ -36,6 +36,7 @@ pub enum ToRunnableError {
         found: VType,
         problematic: VType,
     },
+    CannotAssignTo(VType, VType),
     CaseForceButTypeNotCovered(VType),
     MatchConditionInvalidReturn(VType),
     NotIndexableFixed(VType, usize),
@@ -129,6 +130,14 @@ impl ToRunnableError {
                     }
                     write!(f, ".")
                 }
+                Self::CannotAssignTo(val, target) => {
+                    write!(f, "Cannot assign type ")?;
+                    val.fmtgs(f, info)?;
+                    write!(f, " to ")?;
+                    target.fmtgs(f, info)?;
+                    write!(f, ".")?;
+                    Ok(())
+                },
                 Self::ForLoopContainerHasNoInnerTypes => {
                     write!(f, "For loop: container had no inner types, cannot iterate.")
                 }
@@ -332,7 +341,16 @@ fn statement(
     ginfo: &mut GlobalScriptInfo,
     linfo: &mut LInfo,
 ) -> Result<RStatement, ToRunnableError> {
-    let mut statement = match &*s.statement {
+    statement_adv(s, ginfo, linfo, None)
+}
+fn statement_adv(
+    s: &SStatement,
+    ginfo: &mut GlobalScriptInfo,
+    linfo: &mut LInfo,
+    // if Some((t, is_init)), the statement creates by this function is the left side of an assignment, meaning it can create variables. t is the type that will be assigned to it.
+    to_be_assigned_to: Option<(VType, &mut bool)>,
+) -> Result<RStatement, ToRunnableError> {
+    let mut state = match &*s.statement {
             SStatementEnum::Value(v) => RStatementEnum::Value(v.clone()),
             SStatementEnum::Tuple(v) | SStatementEnum::List(v) => {
                 let mut w = Vec::with_capacity(v.len());
@@ -346,11 +364,18 @@ fn statement(
                 }
             }
             SStatementEnum::Variable(v, is_ref) => {
+                if !linfo.vars.contains_key(v) {
+                    if let Some((t, is_init)) = to_be_assigned_to {
+                        *is_init = true;
+                        linfo.vars.insert(v.to_owned(), (ginfo.vars, t));
+                        ginfo.vars += 1;
+                    }
+                }
                 if let Some(var) = linfo.vars.get(v) {
                     RStatementEnum::Variable(var.0, {
                         let mut v = var.1.clone(); stypes(&mut v, ginfo)?; v }, *is_ref)
                 } else {
-                    return Err(ToRunnableError::UseOfUndefinedVariable(v.clone()));
+                        return Err(ToRunnableError::UseOfUndefinedVariable(v.clone()));
                 }
             }
             SStatementEnum::FunctionCall(v, args) => {
@@ -620,61 +645,103 @@ fn statement(
     if let Some(force_opt) = &s.force_output_type {
         let mut force_opt = force_opt.to_owned();
         stypes(&mut force_opt, ginfo)?;
-        let real_output_type = statement.out(ginfo);
+        let real_output_type = state.out(ginfo);
         let problematic_types = real_output_type.fits_in(&force_opt, ginfo);
         if problematic_types.is_empty() {
-            statement.force_output_type = Some(force_opt);
+            state.force_output_type = Some(force_opt);
         } else {
             return Err(ToRunnableError::StatementRequiresOutputTypeToBeAButItActuallyOutputsBWhichDoesNotFitInA(force_opt.clone(), real_output_type, VType { types: problematic_types }));
         }
     }
     if let Some((opt, derefs)) = &s.output_to {
-        if let Some((var_id, var_out)) = linfo.vars.get(opt) {
-            let out = statement.out(ginfo);
-            let mut var_derefd = var_out.clone();
-            for _ in 0..*derefs {
-                var_derefd = if let Some(v) = var_derefd.dereference() {
-                    v
-                } else {
-                    return Err(ToRunnableError::CannotDereferenceTypeNTimes(
-                        var_out.clone(),
-                        *derefs,
-                        var_derefd,
-                    ));
-                }
-            }
-            let inv_types = out.fits_in(&var_derefd, ginfo);
-            if !inv_types.is_empty() {
-                eprintln!("Warn: shadowing variable {opt} because statement's output type {out} does not fit in the original variable's {var_out}. This might become an error in the future, or it might stop shadowing the variiable entirely - for stable scripts, avoid this by giving the variable a different name.");
-                if *derefs != 0 {
-                    return Err(ToRunnableError::CannotDeclareVariableWithDereference(
-                        opt.clone(),
-                    ));
-                }
-                linfo.vars.insert(opt.clone(), (ginfo.vars, out));
-                statement.output_to = Some((ginfo.vars, 0, true));
-                ginfo.vars += 1;
+        let mut is_init = false;
+        let optr = statement_adv(
+            opt,
+            ginfo,
+            linfo,
+            if *derefs == 0 {
+                Some((state.out(ginfo), &mut is_init))
             } else {
-                // mutate existing variable
-                statement.output_to = Some((*var_id, *derefs, false));
+                None
+            },
+        )?;
+        let mut opt_type = optr.out(ginfo);
+        for _ in 0..*derefs {
+            if let Some(deref_type) = optr.out(ginfo).dereference() {
+                opt_type = deref_type;
+            } else {
+                return Err(ToRunnableError::CannotDereferenceTypeNTimes(
+                    optr.out(ginfo),
+                    *derefs,
+                    opt_type,
+                ));
             }
-        } else {
-            let mut out = statement.out(ginfo);
-            for _ in 0..*derefs {
-                out = if let Some(v) = out.dereference() {
-                    v
-                } else {
-                    return Err(ToRunnableError::CannotDereferenceTypeNTimes(
-                        statement.out(ginfo),
-                        *derefs,
-                        out,
-                    ));
-                }
-            }
-            linfo.vars.insert(opt.clone(), (ginfo.vars, out));
-            statement.output_to = Some((ginfo.vars, *derefs, true));
-            ginfo.vars += 1;
         }
+        let opt_type_assign = match opt_type.dereference() {
+            Some(v) => v,
+            None => {
+                return Err(ToRunnableError::CannotDereferenceTypeNTimes(
+                    optr.out(ginfo),
+                    derefs + 1,
+                    opt_type,
+                ))
+            }
+        };
+        if state.out(ginfo).fits_in(&opt_type_assign, ginfo).is_empty() {
+            state.output_to = Some((Box::new(optr), *derefs, is_init));
+        } else {
+            return Err(ToRunnableError::CannotAssignTo(
+                state.out(ginfo),
+                opt_type_assign,
+            ));
+        }
+        //
+        // if let Some((var_id, var_out)) = linfo.vars.get(opt) {
+        //     let out = state.out(ginfo);
+        //     let mut var_derefd = var_out.clone();
+        //     for _ in 0..*derefs {
+        //         var_derefd = if let Some(v) = var_derefd.dereference() {
+        //             v
+        //         } else {
+        //             return Err(ToRunnableError::CannotDereferenceTypeNTimes(
+        //                 var_out.clone(),
+        //                 *derefs,
+        //                 var_derefd,
+        //             ));
+        //         }
+        //     }
+        //     let inv_types = out.fits_in(&var_derefd, ginfo);
+        //     if !inv_types.is_empty() {
+        //         eprintln!("Warn: shadowing variable {opt} because statement's output type {out} does not fit in the original variable's {var_out}. This might become an error in the future, or it might stop shadowing the variiable entirely - for stable scripts, avoid this by giving the variable a different name.");
+        //         if *derefs != 0 {
+        //             return Err(ToRunnableError::CannotDeclareVariableWithDereference(
+        //                 opt.clone(),
+        //             ));
+        //         }
+        //         linfo.vars.insert(opt.clone(), (ginfo.vars, out));
+        //         state.output_to = Some((ginfo.vars, 0, true));
+        //         ginfo.vars += 1;
+        //     } else {
+        //         // mutate existing variable
+        //         state.output_to = Some((*var_id, *derefs, false));
+        //     }
+        // } else {
+        //     let mut out = state.out(ginfo);
+        //     for _ in 0..*derefs {
+        //         out = if let Some(v) = out.dereference() {
+        //             v
+        //         } else {
+        //             return Err(ToRunnableError::CannotDereferenceTypeNTimes(
+        //                 state.out(ginfo),
+        //                 *derefs,
+        //                 out,
+        //             ));
+        //         }
+        //     }
+        //     linfo.vars.insert(opt.clone(), (ginfo.vars, out));
+        //     state.output_to = Some((ginfo.vars, *derefs, true));
+        //     ginfo.vars += 1;
+        // }
     }
-    Ok(statement)
+    Ok(state)
 }
diff --git a/mers/src/script/val_data.rs b/mers/src/script/val_data.rs
index 297188f..b69da10 100755
--- a/mers/src/script/val_data.rs
+++ b/mers/src/script/val_data.rs
@@ -24,8 +24,8 @@ impl VData {
                 return;
             }
         }
-        #[cfg(debug_assertions)]
-        eprintln!("VData: assign: overwriting my previous Arc because it was immutable.");
+        // #[cfg(debug_assertions)]
+        // eprintln!("VData: assign: overwriting my previous Arc because it was immutable.");
         *self = new_val.to();
     }
     pub fn inner_replace(&mut self, new_val: VDataEnum) -> VDataEnum {
@@ -90,22 +90,18 @@ impl VData {
 }
 impl Clone for VData {
     fn clone(&self) -> Self {
-        #[cfg(debug_assertions)]
-        eprint!("VData: Clone: ");
         let mut d = self.data.lock().unwrap();
         let o = if d.1 {
             if Arc::strong_count(&self.data) > 1 {
                 // mutable, copy the value to avoid accidentally modifying it.
                 #[cfg(debug_assertions)]
-                eprint!(
-                    "copying value due to clone of a mutable shared value. (strong count: {})",
+                eprintln!(
+                    "VData: Clone: copying value due to clone of a mutable shared value. (strong count: {})",
                     Arc::strong_count(&self.data)
                 );
                 d.0.clone().to()
             } else {
                 // mutable, but not shared. just change it to not being mutable.
-                #[cfg(debug_assertions)]
-                eprint!("setting mutable value to immutable to avoid copying. clone will happen when value is used mutably.");
                 d.1 = false;
                 // then return the same arc (-> avoid cloning)
                 Self {
@@ -113,15 +109,11 @@ impl Clone for VData {
                 }
             }
         } else {
-            #[cfg(debug_assertions)]
-            eprint!("immutably cloning immutable value. no copy necessary.");
             // immutable, return the same arc (-> avoid cloning)
             Self {
                 data: Arc::clone(&self.data),
             }
         };
-        #[cfg(debug_assertions)]
-        eprintln!();
         o
     }
 }
@@ -229,6 +221,13 @@ impl VDataEnum {
             data: Arc::new(Mutex::new((self, true))),
         }
     }
+    pub fn deref(self) -> Option<VData> {
+        if let Self::Reference(r) = self {
+            Some(r)
+        } else {
+            None
+        }
+    }
 }
 
 // get()
diff --git a/mers/src/script/val_type.rs b/mers/src/script/val_type.rs
index 72125d1..21de3c5 100755
--- a/mers/src/script/val_type.rs
+++ b/mers/src/script/val_type.rs
@@ -100,6 +100,7 @@ impl VType {
             None
         }
     }
+    /// returns Some(t) where t is the type you get from dereferencing self or None if self contains even a single type that cannot be dereferenced.
     pub fn dereference(&self) -> Option<Self> {
         let mut out = Self::empty();
         for t in self.types.iter() {
diff --git a/mers/t.mers b/mers/t.mers
new file mode 100644
index 0000000..70aa192
--- /dev/null
+++ b/mers/t.mers
@@ -0,0 +1,11 @@
+a = (max int) {
+    println("Max: " + max.to_string())
+    for i max {
+        println(i.to_string())
+    }
+}
+a.debug()
+// why does this work
+a.thread(10).await()
+// and this just blocks and does nothing
+a.run(10)
diff --git a/thread.mers b/thread.mers
index bf1317d..dbcadde 100755
--- a/thread.mers
+++ b/thread.mers
@@ -11,10 +11,12 @@ progress = 0
 calculator = (max int) {
     sum = 0
     for i max {
-        i = i.add(1)
-        sum = sum.add(i)
+        i = i + 1
+        // println("i: {0}".format(i.to_string()))
+        println("i: {0} s: {1}".format(i.to_string() sum.to_string()))
+        sum = sum + i + 1
         if fake_delay sleep(1)
-        progress = i.mul(100).div(max)
+        v = i * 100 / max
     }
     "the sum of all numbers from 0 to {0} is {1}!".format(max.to_string() sum.to_string())
 }
@@ -26,7 +28,7 @@ slow_calculation_thread = calculator.thread(if fake_delay 10 else 20000000)
 loop {
     sleep(1)
     println("{0}%".format(progress.to_string()))
-    progress.eq(100) // break from the loop
+    progress == 100 // break from the loop
 }
 
 // use await() to get the result from the thread. if the thread is still running, this will block until the thread finishes.
diff --git a/when_clone.mers b/when_clone.mers
new file mode 100644
index 0000000..954c3c3
--- /dev/null
+++ b/when_clone.mers
@@ -0,0 +1,8 @@
+&a = "value"
+&list = ["a" "b" "c" ...]
+&elem = &list.get_ref(1)
+switch! elem {
+    [&string] elem.0 = "z"
+    [] {}
+}
+list.debug()