diff --git a/examples/amogus.mers b/examples/amogus.mers
index cbf9ee6..dbf1a4d 100644
--- a/examples/amogus.mers
+++ b/examples/amogus.mers
@@ -1,28 +1,28 @@
-text = "ℑ𝔠𝔥 𝔨𝔞𝔫𝔫 𝔡𝔞𝔰 𝔳𝔢𝔯𝔡𝔞𝔪𝔪𝔱 𝔫𝔬𝔠𝔥 𝔪𝔞𝔩 𝔫𝔦𝔠𝔥𝔱 𝔤𝔩𝔞𝔲𝔟𝔢𝔫. 𝔓𝔦𝔫𝔨 𝔳𝔬𝔫 𝔲𝔫𝔱𝔢𝔯 𝔲𝔫𝔰 𝔥𝔞𝔱 𝔪𝔢𝔦𝔫𝔢 𝔈𝔥𝔢 𝔯𝔲𝔦𝔫𝔦𝔢𝔯𝔱. 𝔙𝔬𝔯 𝔢𝔦𝔫 𝔭𝔞𝔞𝔯 𝔐𝔬𝔫𝔞𝔱𝔢𝔫 𝔰𝔞𝔤𝔱𝔢 𝔪𝔢𝔦𝔫𝔢 𝔉𝔯𝔞𝔲, 𝔰𝔦𝔢 𝔴𝔲̈𝔯𝔡𝔢 𝔣𝔲̈𝔯 𝔢𝔦𝔫𝔢 𝔉𝔯𝔞𝔲𝔢𝔫𝔫𝔞𝔠𝔥𝔱 𝔞𝔲𝔰𝔤𝔢𝔥𝔢𝔫. 𝔖𝔦𝔢 𝔟𝔞𝔱 𝔪𝔦𝔠𝔥, 𝔞𝔲𝔣 𝔪𝔢𝔦𝔫𝔢𝔫 𝔖𝔬𝔥𝔫 𝔞𝔲𝔣𝔷𝔲𝔭𝔞𝔰𝔰𝔢𝔫, 𝔞𝔩𝔰𝔬 𝔴𝔞𝔯 𝔦𝔠𝔥 𝔰𝔬𝔣𝔬𝔯𝔱 𝔳𝔢𝔯𝔭𝔣𝔩𝔦𝔠𝔥𝔱𝔢𝔱. \"𝔍𝔞 𝔐𝔞'𝔞𝔪\", 𝔰𝔞𝔤𝔱𝔢 𝔦𝔠𝔥 𝔦𝔥𝔯. 𝔑𝔞𝔠𝔥 𝔢𝔦𝔫𝔢𝔯 𝔚𝔢𝔦𝔩𝔢 𝔡𝔢𝔰 𝔚𝔞𝔯𝔱𝔢𝔫𝔰 𝔤𝔦𝔫𝔤 𝔰𝔦𝔢 𝔢𝔫𝔡𝔩𝔦𝔠𝔥 𝔲𝔫𝔡 𝔦𝔠𝔥 𝔨𝔬𝔫𝔫𝔱𝔢 𝔪𝔢𝔦𝔫 𝔏𝔦𝔢𝔟𝔩𝔦𝔫𝔤𝔰𝔰𝔭𝔦𝔢𝔩 𝔲𝔫𝔱𝔢𝔯 𝔲𝔫𝔰 𝔰𝔭𝔦𝔢𝔩𝔢𝔫. ℑ𝔠𝔥 𝔥𝔲̈𝔭𝔣𝔱𝔢 𝔞𝔲𝔣 𝔪𝔢𝔦𝔫𝔢𝔫 𝔏𝔞𝔭𝔱𝔬𝔭, 𝔰𝔱𝔞𝔯𝔱𝔢𝔱𝔢 𝔦𝔥𝔫 𝔲𝔫𝔡 𝔩𝔲𝔡 𝔪𝔢𝔦𝔫𝔢𝔫 𝔇𝔢𝔰𝔨𝔱𝔬𝔭, 𝔨𝔬𝔪𝔭𝔩𝔢𝔱𝔱 𝔪𝔦𝔱 𝔡𝔢𝔪 𝔯𝔬𝔱𝔢𝔫 𝔖𝔲𝔰-ℌ𝔦𝔫𝔱𝔢𝔯𝔤𝔯𝔲𝔫𝔡 𝔲𝔫𝔡 𝔞𝔩𝔩 𝔪𝔢𝔦𝔫𝔢𝔯 ℑ𝔪𝔭𝔬𝔰𝔱𝔬𝔯-𝔉𝔞𝔫-𝔄𝔯𝔱 𝔲𝔫𝔱𝔢𝔯 𝔲𝔫𝔰. ℑ𝔠𝔥 𝔷𝔦𝔱𝔱𝔢𝔯𝔱𝔢 𝔳𝔬𝔯 𝔄𝔲𝔣𝔯𝔢𝔤𝔲𝔫𝔤. ℑ𝔠𝔥 𝔷𝔬𝔤 𝔪𝔢𝔦𝔫𝔢𝔫 𝔉𝔦𝔫𝔤𝔢𝔯 𝔩𝔞𝔫𝔤𝔰𝔞𝔪 𝔲̈𝔟𝔢𝔯 𝔡𝔞𝔰 𝔗𝔯𝔞𝔠𝔨𝔭𝔞𝔡 𝔲𝔫𝔡 𝔟𝔢𝔬𝔟𝔞𝔠𝔥𝔱𝔢𝔱𝔢 𝔡𝔢𝔫 ℭ𝔲𝔯𝔰𝔬𝔯, 𝔞𝔩𝔰 𝔢𝔯 𝔷𝔲 𝔡𝔢𝔪 𝔖𝔶𝔪𝔟𝔬𝔩 𝔲𝔫𝔱𝔢𝔯 𝔲𝔫𝔰 𝔤𝔩𝔦𝔱𝔱. 𝔲𝔫𝔱𝔢𝔯 𝔲𝔫𝔰. 𝔐𝔢𝔦𝔫 𝔞𝔟𝔰𝔬𝔩𝔲𝔱𝔢𝔰 𝔏𝔦𝔢𝔟𝔩𝔦𝔫𝔤𝔰𝔰𝔭𝔦𝔢𝔩 𝔞𝔩𝔩𝔢𝔯 ℨ𝔢𝔦𝔱𝔢𝔫 𝔲𝔫𝔡 𝔴𝔞𝔥𝔯𝔰𝔠𝔥𝔢𝔦𝔫𝔩𝔦𝔠𝔥 𝔡𝔞𝔰 𝔟𝔢𝔰𝔱𝔢 𝔲𝔫𝔡 𝔞𝔪 𝔟𝔢𝔰𝔱𝔢𝔫 𝔤𝔢𝔪𝔞𝔠𝔥𝔱𝔢 𝔖𝔭𝔦𝔢𝔩 𝔡𝔢𝔯 𝔚𝔢𝔩𝔱. 𝔄𝔩𝔰 𝔦𝔠𝔥 𝔞𝔲𝔣 𝔡𝔢𝔫 𝔎𝔫𝔬𝔭𝔣 𝔨𝔩𝔦𝔠𝔨𝔱𝔢, 𝔷𝔲𝔠𝔨𝔱𝔢 𝔪𝔢𝔦𝔫 𝔎𝔬̈𝔯𝔭𝔢𝔯 𝔳𝔬𝔯 𝔉𝔯𝔢𝔲𝔡𝔢 𝔟𝔢𝔦 𝔡𝔢𝔪 𝔊𝔢𝔡𝔞𝔫𝔨𝔢𝔫, 𝔴𝔦𝔢𝔡𝔢𝔯 𝔡𝔢𝔯 𝔅𝔢𝔱𝔯𝔲̈𝔤𝔢𝔯 𝔷𝔲 𝔰𝔢𝔦𝔫. 𝔐𝔢𝔦𝔫𝔢 𝔉𝔦𝔫𝔤𝔢𝔯 𝔱𝔯𝔬𝔪𝔪𝔢𝔩𝔱𝔢𝔫 𝔲𝔫𝔤𝔢𝔡𝔲𝔩𝔡𝔦𝔤 𝔞𝔲𝔣 𝔪𝔢𝔦𝔫𝔢𝔪 𝔖𝔠𝔥𝔯𝔢𝔦𝔟𝔱𝔦𝔰𝔠𝔥, 𝔞𝔩𝔰 𝔡𝔞𝔰 𝔏𝔬𝔤𝔬 𝔡𝔢𝔯 𝔦𝔫𝔫𝔢𝔯𝔢𝔫 𝔉𝔞𝔲𝔩𝔱𝔦𝔢𝔯𝔢 𝔢𝔦𝔫- 𝔲𝔫𝔡 𝔞𝔲𝔰𝔟𝔩𝔢𝔫𝔡𝔢𝔱𝔢. 𝔇𝔞𝔫𝔫 𝔢𝔯𝔰𝔠𝔥𝔦𝔢𝔫 𝔡𝔢𝔯 ℌ𝔞𝔲𝔭𝔱𝔱𝔦𝔱𝔢𝔩. ℑ𝔠𝔥 𝔰𝔞𝔥 𝔰𝔬𝔣𝔬𝔯𝔱 𝔭𝔦𝔫𝔨 𝔞𝔫, 𝔞𝔩𝔰 𝔰𝔦𝔢 𝔩𝔞𝔫𝔤𝔰𝔞𝔪 𝔲̈𝔟𝔢𝔯 𝔡𝔢𝔫 𝔅𝔦𝔩𝔡𝔰𝔠𝔥𝔦𝔯𝔪 𝔰𝔠𝔥𝔴𝔢𝔟𝔱𝔢. 𝔒𝔥, 𝔴𝔦𝔢 𝔦𝔠𝔥 𝔴𝔲̈𝔫𝔰𝔠𝔥𝔱𝔢, 𝔦𝔠𝔥 𝔨𝔬̈𝔫𝔫𝔱𝔢 𝔡𝔦𝔢𝔰𝔢 𝔲̈𝔭𝔭𝔦𝔤𝔢𝔫, 𝔴𝔢𝔦𝔠𝔥𝔢𝔫 𝔄𝔰𝔰𝔠𝔥𝔢𝔢𝔨𝔰 𝔣𝔲̈𝔥𝔩𝔢𝔫. 𝔓𝔦𝔫𝔨 𝔦𝔰𝔱 𝔪𝔢𝔦𝔫𝔢 𝔎𝔬̈𝔫𝔦𝔤𝔦𝔫. 𝔇𝔦𝔢 𝔢𝔠𝔥𝔱𝔢 𝔉𝔯𝔞𝔲 𝔦𝔫 𝔪𝔢𝔦𝔫𝔢𝔪 𝔏𝔢𝔟𝔢𝔫. 𝔐𝔢𝔦𝔫𝔢 𝔉𝔯𝔞𝔲 𝔨𝔬̈𝔫𝔫𝔱𝔢 𝔫𝔦𝔢𝔪𝔞𝔩𝔰 𝔰𝔬 𝔰𝔢𝔵𝔶 𝔰𝔢𝔦𝔫 𝔴𝔦𝔢 𝔓𝔦𝔫𝔨; ℑ𝔥𝔯𝔢 𝔩𝔢𝔦𝔰𝔢𝔫 𝔢𝔩𝔢𝔨𝔱𝔯𝔦𝔰𝔠𝔥𝔢𝔫 𝔖𝔠𝔥𝔯𝔦𝔱𝔱𝔢, 𝔞𝔩𝔰 𝔦𝔠𝔥 𝔞𝔲𝔰 𝔢𝔦𝔫𝔢𝔪 𝔄𝔟𝔷𝔲𝔤 𝔥𝔢𝔯𝔞𝔲𝔰 𝔞𝔲𝔣 𝔦𝔥𝔯𝔢 𝔨𝔲𝔯𝔳𝔦𝔤𝔢 𝔊𝔢𝔰𝔱𝔞𝔩𝔱 𝔰𝔠𝔥𝔞𝔲𝔢 𝔲𝔫𝔡 𝔞𝔲𝔣 𝔡𝔢𝔫 𝔯𝔦𝔠𝔥𝔱𝔦𝔤𝔢𝔫 ℨ𝔢𝔦𝔱𝔭𝔲𝔫𝔨𝔱 𝔣𝔲̈𝔯 𝔢𝔦𝔫𝔢𝔫 𝔖𝔠𝔥𝔩𝔞𝔤 𝔴𝔞𝔯𝔱𝔢. ℑ𝔠𝔥 𝔨𝔬𝔫𝔫𝔱𝔢 𝔓𝔦𝔫𝔨 𝔧𝔢𝔡𝔬𝔠𝔥 𝔫𝔦𝔢 𝔫𝔞𝔥𝔢 𝔨𝔬𝔪𝔪𝔢𝔫, 𝔞𝔩𝔰 𝔬𝔟 𝔰𝔦𝔢 𝔢𝔦𝔫𝔢𝔫 𝔰𝔢𝔠𝔥𝔰𝔱𝔢𝔫 𝔖𝔦𝔫𝔫 𝔥𝔞̈𝔱𝔱𝔢, 𝔰𝔦𝔢 𝔴𝔲̈𝔯𝔡𝔢 𝔦𝔪𝔪𝔢𝔯 𝔤𝔢𝔥𝔢𝔫, 𝔟𝔢𝔳𝔬𝔯 𝔦𝔠𝔥 𝔪𝔦𝔠𝔥 𝔦𝔥𝔯 𝔞𝔩𝔰 𝔅𝔢𝔱𝔯𝔲̈𝔤𝔢𝔯𝔦𝔫 𝔬𝔣𝔣𝔢𝔫𝔟𝔞𝔯𝔢𝔫 𝔨𝔬𝔫𝔫𝔱𝔢. ℑ𝔠𝔥 𝔡𝔯𝔲̈𝔠𝔨𝔢 𝔞𝔲𝔣 𝔘̈𝔟𝔢𝔫, 𝔲𝔪 𝔪𝔢𝔦𝔫𝔢 𝔉𝔦𝔫𝔤𝔢𝔯 𝔳𝔬𝔯 𝔪𝔢𝔦𝔫𝔢𝔪 𝔢𝔯𝔰𝔱𝔢𝔫 𝔦𝔫𝔱𝔢𝔫𝔰𝔦𝔳𝔢𝔫 𝔖𝔭𝔦𝔢𝔩 𝔲𝔫𝔱𝔢𝔯 𝔲𝔫𝔰 𝔞𝔲𝔣𝔷𝔲𝔴𝔞̈𝔯𝔪𝔢𝔫. ℑ𝔠𝔥 𝔡𝔯𝔲̈𝔠𝔨𝔢 𝔅𝔩𝔲𝔢 𝔦𝔫 ℭ𝔬𝔪𝔪𝔰, 𝔲̈𝔟𝔢𝔯𝔮𝔲𝔢𝔯𝔢 𝔡𝔞𝔫𝔫 𝔡𝔦𝔢 ℌ𝔞𝔩𝔩𝔢 𝔲𝔫𝔡 𝔤𝔢𝔥𝔢 𝔷𝔲 𝔖𝔭𝔢𝔠𝔦𝔪𝔢𝔫, 𝔲𝔪 𝔊𝔯𝔢𝔢𝔫 𝔨𝔞𝔩𝔱𝔟𝔩𝔲̈𝔱𝔦𝔤 𝔷𝔲 𝔢𝔯𝔪𝔬𝔯𝔡𝔢𝔫. 𝔇𝔢𝔯 𝔑𝔢𝔯𝔳𝔢𝔫𝔨𝔦𝔱𝔷𝔢𝔩, 𝔢𝔦𝔫𝔢𝔫 𝔞𝔫𝔦𝔪𝔦𝔢𝔯𝔱𝔢𝔫 ℭ𝔥𝔞𝔯𝔞𝔨𝔱𝔢𝔯 𝔦𝔫 𝔢𝔦𝔫𝔢𝔪 𝔒𝔫𝔩𝔦𝔫𝔢-𝔖𝔭𝔦𝔢𝔩 𝔷𝔲 𝔱𝔬̈𝔱𝔢𝔫, 𝔴𝔞𝔯 𝔫𝔬𝔠𝔥 𝔫𝔦𝔢 𝔰𝔬 𝔰𝔠𝔥𝔫𝔢𝔩𝔩. ℑ𝔠𝔥 𝔤𝔢𝔥𝔢 𝔡𝔞𝔫𝔫 𝔦𝔫 ℜ𝔦𝔠𝔥𝔱𝔲𝔫𝔤 ℜ𝔢𝔞𝔨𝔱𝔬𝔯, 𝔰𝔱𝔢𝔠𝔥𝔢 𝔊𝔢𝔩𝔟 𝔦𝔫 𝔡𝔢𝔫 ℜ𝔲̈𝔠𝔨𝔢𝔫 𝔲𝔫𝔡 𝔯𝔢𝔫𝔫𝔢 𝔡𝔞𝔫𝔫 𝔡𝔢𝔫 𝔎𝔬𝔯𝔯𝔦𝔡𝔬𝔯 𝔫𝔞𝔠𝔥 𝔯𝔢𝔠𝔥𝔱𝔰 𝔥𝔦𝔫𝔲𝔫𝔱𝔢𝔯, 𝔲𝔪 ℨ𝔲𝔤𝔞𝔫𝔤 𝔷𝔲𝔯 𝔇𝔢𝔨𝔬𝔫𝔱𝔞𝔪𝔦𝔫𝔞𝔱𝔦𝔬𝔫 𝔷𝔲 𝔢𝔯𝔥𝔞𝔩𝔱𝔢𝔫. ℑ𝔠𝔥 𝔟𝔢𝔴𝔢𝔤𝔢 𝔪𝔦𝔠𝔥 𝔩𝔢𝔦𝔰𝔢 𝔡𝔲𝔯𝔠𝔥 𝔡𝔦𝔢 ℌ𝔞𝔩𝔩𝔢𝔫, 𝔴𝔦𝔢 𝔢𝔦𝔫𝔢 𝔖𝔠𝔥𝔩𝔞𝔫𝔤𝔢, 𝔡𝔦𝔢 𝔤𝔢𝔯𝔞𝔡𝔢 𝔡𝔞𝔟𝔢𝔦 𝔦𝔰𝔱, 𝔦𝔥𝔯𝔢 𝔅𝔢𝔲𝔱𝔢 𝔷𝔲 𝔰𝔠𝔥𝔩𝔞𝔤𝔢𝔫, 𝔲𝔫𝔡 𝔦𝔠𝔥 𝔰𝔢𝔥𝔢 - 𝔒𝔥 𝔫𝔢𝔦𝔫. 𝔈𝔰 𝔦𝔰𝔱 𝔭𝔦𝔫𝔨. ℑ𝔠𝔥 𝔰𝔱𝔢𝔥𝔢 𝔯𝔢𝔤𝔲𝔫𝔤𝔰𝔩𝔬𝔰 𝔡𝔞 𝔲𝔫𝔡 𝔰𝔢𝔥𝔢 𝔰𝔦𝔢 𝔡𝔦𝔯𝔢𝔨𝔱 𝔞𝔫. ℑ𝔥𝔯 𝔙𝔦𝔰𝔦𝔢𝔯 𝔷𝔢𝔦𝔤𝔱 𝔨𝔢𝔦𝔫𝔢 𝔈𝔪𝔬𝔱𝔦𝔬𝔫𝔢𝔫. 𝔄𝔟𝔢𝔯 𝔰𝔦𝔢 𝔴𝔢𝔦ß 𝔢𝔰. ℑ𝔠𝔥 𝔨𝔞𝔫𝔫 𝔢𝔰 𝔦𝔫 𝔡𝔢𝔯 𝔏𝔲𝔣𝔱 𝔣𝔲̈𝔥𝔩𝔢𝔫. ℑ𝔠𝔥 𝔨𝔞𝔫𝔫 𝔰𝔦𝔢 𝔫𝔦𝔠𝔥𝔱 𝔱𝔬̈𝔱𝔢𝔫. 𝔖𝔦𝔢 𝔦𝔰𝔱 𝔷𝔲 𝔰𝔠𝔥𝔬̈𝔫, 𝔷𝔲 𝔢𝔫𝔤𝔢𝔩𝔥𝔞𝔣𝔱, 𝔡𝔞𝔰 𝔏𝔦𝔠𝔥𝔱 𝔴𝔦𝔯𝔡 𝔳𝔬𝔫 𝔦𝔥𝔯𝔢𝔪 𝔯𝔬𝔰𝔞 𝔅𝔬𝔡𝔶 𝔯𝔢𝔣𝔩𝔢𝔨𝔱𝔦𝔢𝔯𝔱, 𝔴𝔦𝔢 𝔖𝔱𝔢𝔯𝔫𝔢 𝔞𝔫 𝔢𝔦𝔫𝔢𝔪 𝔩𝔢𝔢𝔯𝔢𝔫 ℌ𝔦𝔪𝔪𝔢𝔩. 𝔖𝔦𝔢 𝔯𝔢𝔫𝔫𝔱 𝔫𝔦𝔠𝔥𝔱. ℑ𝔠𝔥 𝔟𝔦𝔫 𝔷𝔲 𝔗𝔯𝔞̈𝔫𝔢𝔫 𝔤𝔢𝔯𝔲̈𝔥𝔯𝔱, 𝔞𝔩𝔰 𝔦𝔠𝔥 𝔡𝔢𝔫 𝔅𝔦𝔩𝔡𝔰𝔠𝔥𝔦𝔯𝔪 𝔰𝔱𝔯𝔢𝔦𝔠𝔥𝔩𝔢 𝔲𝔫𝔡 𝔦𝔥𝔫 𝔷𝔞̈𝔯𝔱𝔩𝔦𝔠𝔥 𝔨𝔲̈𝔰𝔰𝔢. \"𝔄𝔲𝔣 𝔚𝔦𝔢𝔡𝔢𝔯𝔰𝔢𝔥𝔢𝔫, 𝔓𝔦𝔫𝔨. 𝔅𝔦𝔰 𝔟𝔞𝔩𝔡. 𝔈𝔰 𝔴𝔦𝔯𝔡 𝔞𝔩𝔩𝔢𝔰 𝔦𝔫 𝔒𝔯𝔡𝔫𝔲𝔫𝔤 𝔰𝔢𝔦𝔫\", 𝔣𝔩𝔲̈𝔰𝔱𝔢𝔯𝔢 𝔦𝔠𝔥 𝔪𝔦𝔱 𝔩𝔢𝔦𝔰𝔢𝔯, 𝔟𝔢𝔯𝔲𝔥𝔦𝔤𝔢𝔫𝔡𝔢𝔯 𝔖𝔱𝔦𝔪𝔪𝔢. 𝔇𝔞𝔫𝔫 𝔷𝔬̈𝔤𝔢𝔯𝔢 𝔦𝔠𝔥, 𝔴𝔞̈𝔥𝔯𝔢𝔫𝔡 𝔪𝔢𝔦𝔫 ℭ𝔲𝔯𝔰𝔬𝔯 𝔲̈𝔟𝔢𝔯 𝔡𝔢𝔪 𝔎𝔦𝔩𝔩-𝔅𝔲𝔱𝔱𝔬𝔫 𝔰𝔠𝔥𝔴𝔢𝔟𝔱. 𝔊𝔢𝔡𝔞𝔫𝔨𝔢𝔫 𝔡𝔢𝔯 𝔏𝔦𝔢𝔟𝔢 𝔤𝔢𝔥𝔢𝔫 𝔪𝔦𝔯 𝔡𝔲𝔯𝔠𝔥 𝔡𝔢𝔫 𝔎𝔬𝔭𝔣. ℜ𝔬𝔱 𝔪𝔦𝔱 𝔯𝔬̈𝔱𝔩𝔦𝔠𝔥-𝔯𝔬𝔰𝔞 𝔳𝔢𝔯𝔡𝔞̈𝔠𝔥𝔱𝔦𝔤𝔢𝔫 𝔎𝔦𝔫𝔡𝔢𝔯𝔫 𝔪𝔦𝔱 ℜ𝔬𝔰𝔞. 𝔄𝔟𝔢𝔯 𝔦𝔠𝔥 𝔪𝔲𝔰𝔰. 𝔄𝔩𝔰 𝔅𝔢𝔱𝔯𝔲̈𝔤𝔢𝔯 𝔦𝔰𝔱 𝔢𝔰 𝔪𝔢𝔦𝔫𝔢 𝔓𝔣𝔩𝔦𝔠𝔥𝔱 𝔷𝔲 𝔱𝔬̈𝔱𝔢𝔫. ℑ𝔠𝔥 𝔡𝔯𝔲̈𝔠𝔨𝔢 𝔡𝔢𝔫 '𝔎𝔦𝔩𝔩'-𝔎𝔫𝔬𝔭𝔣 𝔲𝔫𝔡 𝔟𝔢𝔬𝔟𝔞𝔠𝔥𝔱𝔢, 𝔴𝔦𝔢 𝔪𝔢𝔦𝔫 ℭ𝔥𝔞𝔯𝔞𝔨𝔱𝔢𝔯 𝔓𝔦𝔫𝔨 𝔩𝔞𝔲𝔱𝔩𝔬𝔰 𝔢𝔫𝔱𝔥𝔞𝔲𝔭𝔱𝔢𝔱. ℑ𝔠𝔥 𝔥𝔬̈𝔯𝔢 𝔫𝔲𝔯 𝔡𝔢𝔫 𝔅𝔩𝔲𝔱𝔰𝔱𝔯𝔞𝔥𝔩. 𝔎𝔢𝔦𝔫𝔢 𝔈𝔦𝔩𝔢. 𝔈𝔰 𝔤𝔦𝔟𝔱 𝔫𝔲𝔯 ℜ𝔢𝔡, 𝔡𝔢𝔯 𝔞𝔩𝔩𝔢𝔦𝔫𝔢 𝔦𝔫 𝔉𝔲𝔢𝔩 𝔰𝔱𝔢𝔥𝔱. ℜ𝔬𝔰𝔞𝔰 𝔩𝔢𝔟𝔩𝔬𝔰𝔢𝔯 𝔎𝔬̈𝔯𝔭𝔢𝔯 𝔩𝔞𝔤 𝔫𝔢𝔟𝔢𝔫 𝔦𝔥𝔪 𝔞𝔲𝔣 𝔡𝔢𝔪 𝔅𝔬𝔡𝔢𝔫. ℑ𝔠𝔥 𝔣𝔲̈𝔥𝔩𝔢 𝔷𝔲𝔢𝔯𝔰𝔱 𝔫𝔦𝔠𝔥𝔱𝔰, 𝔡𝔞𝔫𝔫 𝔲𝔫𝔢𝔯𝔪𝔢𝔰𝔰𝔩𝔦𝔠𝔥𝔢 𝔗𝔯𝔞𝔲𝔯𝔦𝔤𝔨𝔢𝔦𝔱, 𝔞𝔩𝔰 𝔴𝔞̈𝔯𝔢 𝔦𝔠𝔥 𝔟𝔢𝔦 𝔡𝔢𝔯 𝔅𝔢𝔢𝔯𝔡𝔦𝔤𝔲𝔫𝔤 𝔢𝔦𝔫𝔢𝔰 𝔤𝔢𝔩𝔦𝔢𝔟𝔱𝔢𝔫 𝔐𝔢𝔫𝔰𝔠𝔥𝔢𝔫. 𝔐𝔢𝔦𝔫 𝔖𝔬𝔥𝔫 𝔨𝔩𝔬𝔭𝔣𝔱 𝔞𝔫 𝔡𝔦𝔢 𝔗𝔲̈𝔯 𝔲𝔫𝔡 𝔲𝔫𝔱𝔢𝔯𝔟𝔯𝔦𝔠𝔥𝔱 𝔪𝔢𝔦𝔫𝔢𝔫 𝔨𝔲𝔯𝔷𝔢𝔫 𝔐𝔬𝔪𝔢𝔫𝔱 𝔡𝔢𝔯 𝔗𝔯𝔞𝔲𝔢𝔯. 𝔈𝔯 𝔣𝔯𝔞𝔤𝔱: \"𝔇𝔞𝔡? 𝔚𝔦𝔯𝔰𝔱 𝔡𝔲 𝔪𝔦𝔯 𝔢𝔦𝔫𝔢𝔫 𝔖𝔫𝔞𝔠𝔨 𝔪𝔞𝔠𝔥𝔢𝔫?\" ℑ𝔠𝔥 𝔰𝔞𝔤𝔢 𝔦𝔥𝔪, 𝔢𝔯 𝔰𝔬𝔩𝔩 𝔡𝔦𝔢 𝔎𝔩𝔞𝔭𝔭𝔢 𝔥𝔞𝔩𝔱𝔢𝔫, 𝔲𝔫𝔡 𝔪𝔢𝔦𝔫𝔢 𝔖𝔱𝔦𝔪𝔪𝔢 𝔟𝔯𝔦𝔠𝔥𝔱. ℑ𝔠𝔥 𝔟𝔯𝔢𝔠𝔥𝔢 𝔰𝔠𝔥𝔩𝔲𝔠𝔥𝔷𝔢𝔫𝔡 𝔷𝔲𝔰𝔞𝔪𝔪𝔢𝔫. ℑ𝔠𝔥 𝔥𝔞𝔟𝔢 𝔰𝔦𝔢 𝔤𝔢𝔱𝔬̈𝔱𝔢𝔱. ℑ𝔠𝔥 𝔥𝔞𝔟𝔢 𝔪𝔢𝔦𝔫𝔢 𝔢𝔦𝔫𝔷𝔦𝔤 𝔴𝔞𝔥𝔯𝔢 𝔏𝔦𝔢𝔟𝔢 𝔤𝔢𝔱𝔬̈𝔱𝔢𝔱. 𝔊𝔬𝔱𝔱 𝔳𝔢𝔯𝔤𝔦𝔟 𝔪𝔦𝔯. ℑ𝔠𝔥 𝔬̈𝔣𝔣𝔫𝔢 𝔪𝔢𝔦𝔫𝔢𝔪 𝔖𝔬𝔥𝔫 𝔡𝔦𝔢 𝔗𝔲̈𝔯 𝔲𝔫𝔡 𝔢𝔯 𝔥𝔞𝔱 𝔢𝔦𝔫𝔢𝔫 𝔳𝔢𝔯𝔴𝔦𝔯𝔯𝔱𝔢𝔫 𝔊𝔢𝔰𝔦𝔠𝔥𝔱𝔰𝔞𝔲𝔰𝔡𝔯𝔲𝔠𝔨. ℑ𝔠𝔥 𝔰𝔞𝔤𝔢 𝔫𝔦𝔠𝔥𝔱𝔰 𝔲𝔫𝔡 𝔤𝔢𝔥𝔢 𝔦𝔫 𝔡𝔦𝔢 𝔎𝔲̈𝔠𝔥𝔢, 𝔲𝔪 𝔦𝔥𝔪 𝔢𝔦𝔫 𝔖𝔞𝔫𝔡𝔴𝔦𝔠𝔥 𝔷𝔲 𝔪𝔞𝔠𝔥𝔢𝔫. 𝔗𝔯𝔞̈𝔫𝔢𝔫 𝔯𝔬𝔩𝔩𝔢𝔫 𝔳𝔬𝔫 𝔪𝔢𝔦𝔫𝔢𝔪 𝔊𝔢𝔰𝔦𝔠𝔥𝔱 𝔦𝔫𝔰 𝔅𝔯𝔬𝔱, 𝔞𝔩𝔰 𝔦𝔠𝔥 𝔢𝔰 𝔞𝔲𝔣 𝔡𝔦𝔢 𝔗𝔥𝔢𝔨𝔢 𝔩𝔢𝔤𝔢. 𝔖𝔞𝔩𝔞𝔱, 𝔎𝔞̈𝔰𝔢 𝔲𝔫𝔡 𝔉𝔩𝔢𝔦𝔰𝔠𝔥, 𝔤𝔢𝔣𝔬𝔩𝔤𝔱 𝔳𝔬𝔫 𝔢𝔦𝔫𝔢𝔪 𝔱𝔯𝔞𝔲𝔯𝔦𝔤𝔢𝔫 𝔚𝔦𝔯𝔟𝔢𝔩 𝔞𝔲𝔰 𝔖𝔢𝔫𝔣. 𝔐𝔢𝔦𝔫 𝔖𝔬𝔥𝔫 𝔦𝔰𝔱 𝔰𝔱𝔦𝔩𝔩. 𝔈𝔯 𝔰𝔦𝔱𝔷𝔱 𝔞𝔲𝔣 𝔡𝔢𝔯 ℭ𝔬𝔲𝔠𝔥 𝔲𝔫𝔡 𝔰𝔱𝔞𝔯𝔯𝔱 𝔞𝔲𝔣 𝔡𝔢𝔫 𝔅𝔬𝔡𝔢𝔫. 𝔈𝔰 𝔦𝔰𝔱 𝔢𝔦𝔫𝔢 𝔡𝔢𝔭𝔯𝔦𝔪𝔦𝔢𝔯𝔢𝔫𝔡𝔢 𝔏𝔲𝔣𝔱 𝔲𝔪 𝔲𝔫𝔰 𝔥𝔢𝔯𝔲𝔪. ℑ𝔠𝔥 𝔰𝔢𝔯𝔳𝔦𝔢𝔯𝔢 𝔦𝔥𝔪 𝔡𝔞𝔰 𝔖𝔞𝔫𝔡𝔴𝔦𝔠𝔥 𝔲𝔫𝔡 𝔤𝔢𝔥𝔢 𝔷𝔲𝔯𝔲̈𝔠𝔨 𝔦𝔫 𝔪𝔢𝔦𝔫 ℨ𝔦𝔪𝔪𝔢𝔯, 𝔲𝔪 𝔲̈𝔟𝔢𝔯 𝔡𝔞𝔰 𝔏𝔢𝔟𝔢𝔫 𝔫𝔞𝔠𝔥𝔷𝔲𝔡𝔢𝔫𝔨𝔢𝔫. 𝔚𝔢𝔫𝔫 𝔦𝔠𝔥 𝔓𝔦𝔫𝔨 𝔤𝔢𝔱𝔬̈𝔱𝔢𝔱 𝔥𝔞𝔟𝔢, 𝔴𝔦𝔢 𝔨𝔞𝔫𝔫 𝔦𝔠𝔥 𝔪𝔢𝔦𝔫𝔢𝔯 𝔉𝔞𝔪𝔦𝔩𝔦𝔢 𝔳𝔢𝔯𝔱𝔯𝔞𝔲𝔢𝔫? ℑ𝔠𝔥 𝔴𝔢𝔦𝔫𝔢 𝔰𝔱𝔲𝔫𝔡𝔢𝔫𝔩𝔞𝔫𝔤 𝔲𝔫𝔡 𝔰𝔠𝔥𝔩𝔦𝔢ß𝔩𝔦𝔠𝔥 𝔨𝔬𝔪𝔪𝔱 𝔪𝔢𝔦𝔫𝔢 𝔉𝔯𝔞𝔲 𝔷𝔲𝔯𝔲̈𝔠𝔨. 𝔖𝔦𝔢 𝔰𝔦𝔢𝔥𝔱 𝔪𝔦𝔠𝔥 𝔞𝔲𝔣 𝔡𝔢𝔪 𝔅𝔢𝔱𝔱 𝔟𝔯𝔲̈𝔩𝔩𝔢𝔫 𝔴𝔦𝔢 𝔢𝔦𝔫 𝔎𝔦𝔫𝔡, 𝔡𝔞𝔰 𝔰𝔢𝔦𝔫 𝔈𝔦𝔰 𝔣𝔞𝔩𝔩𝔢𝔫 𝔩𝔦𝔢ß. 𝔖𝔦𝔢 𝔣𝔯𝔞𝔤𝔱 𝔪𝔦𝔠𝔥 𝔡𝔞𝔫𝔫, 𝔴𝔞𝔯𝔲𝔪 𝔦𝔠𝔥 𝔴𝔢𝔦𝔫𝔢 𝔲𝔫𝔡 𝔪𝔲𝔯𝔪𝔩𝔢: \"ℑ𝔠𝔥 𝔥𝔞𝔟𝔢 𝔰𝔦𝔢 𝔤𝔢𝔱𝔬̈𝔱𝔢𝔱. ℑ𝔠𝔥 𝔥𝔞𝔟𝔢 𝔪𝔢𝔦𝔫𝔢 𝔢𝔦𝔫𝔷𝔦𝔤𝔢 𝔏𝔦𝔢𝔟𝔢, 𝔓𝔦𝔫𝔨, 𝔲𝔫𝔱𝔢𝔯 𝔲𝔫𝔰 𝔤𝔢𝔱𝔬̈𝔱𝔢𝔱.\" 𝔖𝔦𝔢 𝔦𝔰𝔱 𝔳𝔬𝔩𝔩𝔢𝔯 𝔚𝔲𝔱 𝔲𝔫𝔡 𝔰𝔠𝔥𝔩𝔞̈𝔤𝔱 𝔪𝔦𝔯 𝔦𝔫𝔰 𝔊𝔢𝔰𝔦𝔠𝔥𝔱. ℑ𝔠𝔥 𝔣𝔲̈𝔥𝔩𝔢 𝔪𝔦𝔠𝔥 𝔟𝔢𝔫𝔬𝔪𝔪𝔢𝔫. 𝔖𝔦𝔢 𝔟𝔦𝔱𝔱𝔢𝔱 𝔲𝔪 𝔖𝔠𝔥𝔢𝔦𝔡𝔲𝔫𝔤. ℑ𝔠𝔥 𝔞𝔫𝔱𝔴𝔬𝔯𝔱𝔢 𝔫𝔦𝔠𝔥𝔱. 𝔖𝔱𝔞𝔱𝔱𝔡𝔢𝔰𝔰𝔢𝔫 𝔫𝔢𝔥𝔪𝔢 𝔦𝔠𝔥 𝔪𝔢𝔦𝔫𝔢𝔫 𝔏𝔞𝔭𝔱𝔬𝔭, 𝔰𝔱𝔢𝔦𝔤𝔢 𝔦𝔫 𝔪𝔢𝔦𝔫 𝔄𝔲𝔱𝔬 𝔲𝔫𝔡 𝔣𝔞𝔥𝔯𝔢 𝔷𝔲 𝔢𝔦𝔫𝔢𝔪 𝔫𝔞𝔥𝔢 𝔤𝔢𝔩𝔢𝔤𝔢𝔫𝔢𝔫 ℌ𝔬𝔱𝔢𝔩. 𝔖𝔠𝔥𝔫𝔢𝔩𝔩𝔢𝔯 𝔙𝔬𝔯𝔩𝔞𝔲𝔣 𝔢𝔦𝔫𝔦𝔤𝔢 𝔐𝔬𝔫𝔞𝔱𝔢 𝔟𝔦𝔰 𝔷𝔲𝔯 𝔖𝔠𝔥𝔢𝔦𝔡𝔲𝔫𝔤. 𝔈𝔰 𝔴𝔞𝔯 𝔰𝔠𝔥𝔫𝔢𝔩𝔩 𝔲𝔫𝔡 𝔰𝔠𝔥𝔪𝔢𝔯𝔷𝔩𝔬𝔰. 𝔑𝔞𝔠𝔥 𝔡𝔢𝔪 𝔊𝔢𝔯𝔦𝔠𝔥𝔱 𝔟𝔦𝔱𝔱𝔢 𝔦𝔠𝔥 𝔪𝔢𝔦𝔫𝔢 𝔣𝔯𝔲̈𝔥𝔢𝔯𝔢 𝔉𝔯𝔞𝔲, 𝔪𝔦𝔠𝔥 𝔷𝔲𝔯𝔲̈𝔠𝔨𝔷𝔲𝔫𝔢𝔥𝔪𝔢𝔫. \"ℑ𝔠𝔥 𝔨𝔞𝔫𝔫 𝔡𝔦𝔠𝔥 𝔫𝔦𝔠𝔥𝔱 𝔷𝔲𝔯𝔲̈𝔠𝔨𝔫𝔢𝔥𝔪𝔢𝔫. 𝔇𝔲 𝔴𝔞𝔯𝔰𝔱 𝔦𝔪𝔪𝔢𝔯 𝔰𝔬. ℑ𝔠𝔥 𝔴𝔞𝔯 𝔡𝔦𝔯 𝔳𝔬𝔫 𝔄𝔫𝔣𝔞𝔫𝔤 𝔞𝔫 𝔪𝔦𝔰𝔰𝔱𝔯𝔞𝔲𝔦𝔰𝔠𝔥."
+text := "ℑ𝔠𝔥 𝔨𝔞𝔫𝔫 𝔡𝔞𝔰 𝔳𝔢𝔯𝔡𝔞𝔪𝔪𝔱 𝔫𝔬𝔠𝔥 𝔪𝔞𝔩 𝔫𝔦𝔠𝔥𝔱 𝔤𝔩𝔞𝔲𝔟𝔢𝔫. 𝔓𝔦𝔫𝔨 𝔳𝔬𝔫 𝔲𝔫𝔱𝔢𝔯 𝔲𝔫𝔰 𝔥𝔞𝔱 𝔪𝔢𝔦𝔫𝔢 𝔈𝔥𝔢 𝔯𝔲𝔦𝔫𝔦𝔢𝔯𝔱. 𝔙𝔬𝔯 𝔢𝔦𝔫 𝔭𝔞𝔞𝔯 𝔐𝔬𝔫𝔞𝔱𝔢𝔫 𝔰𝔞𝔤𝔱𝔢 𝔪𝔢𝔦𝔫𝔢 𝔉𝔯𝔞𝔲, 𝔰𝔦𝔢 𝔴𝔲̈𝔯𝔡𝔢 𝔣𝔲̈𝔯 𝔢𝔦𝔫𝔢 𝔉𝔯𝔞𝔲𝔢𝔫𝔫𝔞𝔠𝔥𝔱 𝔞𝔲𝔰𝔤𝔢𝔥𝔢𝔫. 𝔖𝔦𝔢 𝔟𝔞𝔱 𝔪𝔦𝔠𝔥, 𝔞𝔲𝔣 𝔪𝔢𝔦𝔫𝔢𝔫 𝔖𝔬𝔥𝔫 𝔞𝔲𝔣𝔷𝔲𝔭𝔞𝔰𝔰𝔢𝔫, 𝔞𝔩𝔰𝔬 𝔴𝔞𝔯 𝔦𝔠𝔥 𝔰𝔬𝔣𝔬𝔯𝔱 𝔳𝔢𝔯𝔭𝔣𝔩𝔦𝔠𝔥𝔱𝔢𝔱. \"𝔍𝔞 𝔐𝔞'𝔞𝔪\", 𝔰𝔞𝔤𝔱𝔢 𝔦𝔠𝔥 𝔦𝔥𝔯. 𝔑𝔞𝔠𝔥 𝔢𝔦𝔫𝔢𝔯 𝔚𝔢𝔦𝔩𝔢 𝔡𝔢𝔰 𝔚𝔞𝔯𝔱𝔢𝔫𝔰 𝔤𝔦𝔫𝔤 𝔰𝔦𝔢 𝔢𝔫𝔡𝔩𝔦𝔠𝔥 𝔲𝔫𝔡 𝔦𝔠𝔥 𝔨𝔬𝔫𝔫𝔱𝔢 𝔪𝔢𝔦𝔫 𝔏𝔦𝔢𝔟𝔩𝔦𝔫𝔤𝔰𝔰𝔭𝔦𝔢𝔩 𝔲𝔫𝔱𝔢𝔯 𝔲𝔫𝔰 𝔰𝔭𝔦𝔢𝔩𝔢𝔫. ℑ𝔠𝔥 𝔥𝔲̈𝔭𝔣𝔱𝔢 𝔞𝔲𝔣 𝔪𝔢𝔦𝔫𝔢𝔫 𝔏𝔞𝔭𝔱𝔬𝔭, 𝔰𝔱𝔞𝔯𝔱𝔢𝔱𝔢 𝔦𝔥𝔫 𝔲𝔫𝔡 𝔩𝔲𝔡 𝔪𝔢𝔦𝔫𝔢𝔫 𝔇𝔢𝔰𝔨𝔱𝔬𝔭, 𝔨𝔬𝔪𝔭𝔩𝔢𝔱𝔱 𝔪𝔦𝔱 𝔡𝔢𝔪 𝔯𝔬𝔱𝔢𝔫 𝔖𝔲𝔰-ℌ𝔦𝔫𝔱𝔢𝔯𝔤𝔯𝔲𝔫𝔡 𝔲𝔫𝔡 𝔞𝔩𝔩 𝔪𝔢𝔦𝔫𝔢𝔯 ℑ𝔪𝔭𝔬𝔰𝔱𝔬𝔯-𝔉𝔞𝔫-𝔄𝔯𝔱 𝔲𝔫𝔱𝔢𝔯 𝔲𝔫𝔰. ℑ𝔠𝔥 𝔷𝔦𝔱𝔱𝔢𝔯𝔱𝔢 𝔳𝔬𝔯 𝔄𝔲𝔣𝔯𝔢𝔤𝔲𝔫𝔤. ℑ𝔠𝔥 𝔷𝔬𝔤 𝔪𝔢𝔦𝔫𝔢𝔫 𝔉𝔦𝔫𝔤𝔢𝔯 𝔩𝔞𝔫𝔤𝔰𝔞𝔪 𝔲̈𝔟𝔢𝔯 𝔡𝔞𝔰 𝔗𝔯𝔞𝔠𝔨𝔭𝔞𝔡 𝔲𝔫𝔡 𝔟𝔢𝔬𝔟𝔞𝔠𝔥𝔱𝔢𝔱𝔢 𝔡𝔢𝔫 ℭ𝔲𝔯𝔰𝔬𝔯, 𝔞𝔩𝔰 𝔢𝔯 𝔷𝔲 𝔡𝔢𝔪 𝔖𝔶𝔪𝔟𝔬𝔩 𝔲𝔫𝔱𝔢𝔯 𝔲𝔫𝔰 𝔤𝔩𝔦𝔱𝔱. 𝔲𝔫𝔱𝔢𝔯 𝔲𝔫𝔰. 𝔐𝔢𝔦𝔫 𝔞𝔟𝔰𝔬𝔩𝔲𝔱𝔢𝔰 𝔏𝔦𝔢𝔟𝔩𝔦𝔫𝔤𝔰𝔰𝔭𝔦𝔢𝔩 𝔞𝔩𝔩𝔢𝔯 ℨ𝔢𝔦𝔱𝔢𝔫 𝔲𝔫𝔡 𝔴𝔞𝔥𝔯𝔰𝔠𝔥𝔢𝔦𝔫𝔩𝔦𝔠𝔥 𝔡𝔞𝔰 𝔟𝔢𝔰𝔱𝔢 𝔲𝔫𝔡 𝔞𝔪 𝔟𝔢𝔰𝔱𝔢𝔫 𝔤𝔢𝔪𝔞𝔠𝔥𝔱𝔢 𝔖𝔭𝔦𝔢𝔩 𝔡𝔢𝔯 𝔚𝔢𝔩𝔱. 𝔄𝔩𝔰 𝔦𝔠𝔥 𝔞𝔲𝔣 𝔡𝔢𝔫 𝔎𝔫𝔬𝔭𝔣 𝔨𝔩𝔦𝔠𝔨𝔱𝔢, 𝔷𝔲𝔠𝔨𝔱𝔢 𝔪𝔢𝔦𝔫 𝔎𝔬̈𝔯𝔭𝔢𝔯 𝔳𝔬𝔯 𝔉𝔯𝔢𝔲𝔡𝔢 𝔟𝔢𝔦 𝔡𝔢𝔪 𝔊𝔢𝔡𝔞𝔫𝔨𝔢𝔫, 𝔴𝔦𝔢𝔡𝔢𝔯 𝔡𝔢𝔯 𝔅𝔢𝔱𝔯𝔲̈𝔤𝔢𝔯 𝔷𝔲 𝔰𝔢𝔦𝔫. 𝔐𝔢𝔦𝔫𝔢 𝔉𝔦𝔫𝔤𝔢𝔯 𝔱𝔯𝔬𝔪𝔪𝔢𝔩𝔱𝔢𝔫 𝔲𝔫𝔤𝔢𝔡𝔲𝔩𝔡𝔦𝔤 𝔞𝔲𝔣 𝔪𝔢𝔦𝔫𝔢𝔪 𝔖𝔠𝔥𝔯𝔢𝔦𝔟𝔱𝔦𝔰𝔠𝔥, 𝔞𝔩𝔰 𝔡𝔞𝔰 𝔏𝔬𝔤𝔬 𝔡𝔢𝔯 𝔦𝔫𝔫𝔢𝔯𝔢𝔫 𝔉𝔞𝔲𝔩𝔱𝔦𝔢𝔯𝔢 𝔢𝔦𝔫- 𝔲𝔫𝔡 𝔞𝔲𝔰𝔟𝔩𝔢𝔫𝔡𝔢𝔱𝔢. 𝔇𝔞𝔫𝔫 𝔢𝔯𝔰𝔠𝔥𝔦𝔢𝔫 𝔡𝔢𝔯 ℌ𝔞𝔲𝔭𝔱𝔱𝔦𝔱𝔢𝔩. ℑ𝔠𝔥 𝔰𝔞𝔥 𝔰𝔬𝔣𝔬𝔯𝔱 𝔭𝔦𝔫𝔨 𝔞𝔫, 𝔞𝔩𝔰 𝔰𝔦𝔢 𝔩𝔞𝔫𝔤𝔰𝔞𝔪 𝔲̈𝔟𝔢𝔯 𝔡𝔢𝔫 𝔅𝔦𝔩𝔡𝔰𝔠𝔥𝔦𝔯𝔪 𝔰𝔠𝔥𝔴𝔢𝔟𝔱𝔢. 𝔒𝔥, 𝔴𝔦𝔢 𝔦𝔠𝔥 𝔴𝔲̈𝔫𝔰𝔠𝔥𝔱𝔢, 𝔦𝔠𝔥 𝔨𝔬̈𝔫𝔫𝔱𝔢 𝔡𝔦𝔢𝔰𝔢 𝔲̈𝔭𝔭𝔦𝔤𝔢𝔫, 𝔴𝔢𝔦𝔠𝔥𝔢𝔫 𝔄𝔰𝔰𝔠𝔥𝔢𝔢𝔨𝔰 𝔣𝔲̈𝔥𝔩𝔢𝔫. 𝔓𝔦𝔫𝔨 𝔦𝔰𝔱 𝔪𝔢𝔦𝔫𝔢 𝔎𝔬̈𝔫𝔦𝔤𝔦𝔫. 𝔇𝔦𝔢 𝔢𝔠𝔥𝔱𝔢 𝔉𝔯𝔞𝔲 𝔦𝔫 𝔪𝔢𝔦𝔫𝔢𝔪 𝔏𝔢𝔟𝔢𝔫. 𝔐𝔢𝔦𝔫𝔢 𝔉𝔯𝔞𝔲 𝔨𝔬̈𝔫𝔫𝔱𝔢 𝔫𝔦𝔢𝔪𝔞𝔩𝔰 𝔰𝔬 𝔰𝔢𝔵𝔶 𝔰𝔢𝔦𝔫 𝔴𝔦𝔢 𝔓𝔦𝔫𝔨; ℑ𝔥𝔯𝔢 𝔩𝔢𝔦𝔰𝔢𝔫 𝔢𝔩𝔢𝔨𝔱𝔯𝔦𝔰𝔠𝔥𝔢𝔫 𝔖𝔠𝔥𝔯𝔦𝔱𝔱𝔢, 𝔞𝔩𝔰 𝔦𝔠𝔥 𝔞𝔲𝔰 𝔢𝔦𝔫𝔢𝔪 𝔄𝔟𝔷𝔲𝔤 𝔥𝔢𝔯𝔞𝔲𝔰 𝔞𝔲𝔣 𝔦𝔥𝔯𝔢 𝔨𝔲𝔯𝔳𝔦𝔤𝔢 𝔊𝔢𝔰𝔱𝔞𝔩𝔱 𝔰𝔠𝔥𝔞𝔲𝔢 𝔲𝔫𝔡 𝔞𝔲𝔣 𝔡𝔢𝔫 𝔯𝔦𝔠𝔥𝔱𝔦𝔤𝔢𝔫 ℨ𝔢𝔦𝔱𝔭𝔲𝔫𝔨𝔱 𝔣𝔲̈𝔯 𝔢𝔦𝔫𝔢𝔫 𝔖𝔠𝔥𝔩𝔞𝔤 𝔴𝔞𝔯𝔱𝔢. ℑ𝔠𝔥 𝔨𝔬𝔫𝔫𝔱𝔢 𝔓𝔦𝔫𝔨 𝔧𝔢𝔡𝔬𝔠𝔥 𝔫𝔦𝔢 𝔫𝔞𝔥𝔢 𝔨𝔬𝔪𝔪𝔢𝔫, 𝔞𝔩𝔰 𝔬𝔟 𝔰𝔦𝔢 𝔢𝔦𝔫𝔢𝔫 𝔰𝔢𝔠𝔥𝔰𝔱𝔢𝔫 𝔖𝔦𝔫𝔫 𝔥𝔞̈𝔱𝔱𝔢, 𝔰𝔦𝔢 𝔴𝔲̈𝔯𝔡𝔢 𝔦𝔪𝔪𝔢𝔯 𝔤𝔢𝔥𝔢𝔫, 𝔟𝔢𝔳𝔬𝔯 𝔦𝔠𝔥 𝔪𝔦𝔠𝔥 𝔦𝔥𝔯 𝔞𝔩𝔰 𝔅𝔢𝔱𝔯𝔲̈𝔤𝔢𝔯𝔦𝔫 𝔬𝔣𝔣𝔢𝔫𝔟𝔞𝔯𝔢𝔫 𝔨𝔬𝔫𝔫𝔱𝔢. ℑ𝔠𝔥 𝔡𝔯𝔲̈𝔠𝔨𝔢 𝔞𝔲𝔣 𝔘̈𝔟𝔢𝔫, 𝔲𝔪 𝔪𝔢𝔦𝔫𝔢 𝔉𝔦𝔫𝔤𝔢𝔯 𝔳𝔬𝔯 𝔪𝔢𝔦𝔫𝔢𝔪 𝔢𝔯𝔰𝔱𝔢𝔫 𝔦𝔫𝔱𝔢𝔫𝔰𝔦𝔳𝔢𝔫 𝔖𝔭𝔦𝔢𝔩 𝔲𝔫𝔱𝔢𝔯 𝔲𝔫𝔰 𝔞𝔲𝔣𝔷𝔲𝔴𝔞̈𝔯𝔪𝔢𝔫. ℑ𝔠𝔥 𝔡𝔯𝔲̈𝔠𝔨𝔢 𝔅𝔩𝔲𝔢 𝔦𝔫 ℭ𝔬𝔪𝔪𝔰, 𝔲̈𝔟𝔢𝔯𝔮𝔲𝔢𝔯𝔢 𝔡𝔞𝔫𝔫 𝔡𝔦𝔢 ℌ𝔞𝔩𝔩𝔢 𝔲𝔫𝔡 𝔤𝔢𝔥𝔢 𝔷𝔲 𝔖𝔭𝔢𝔠𝔦𝔪𝔢𝔫, 𝔲𝔪 𝔊𝔯𝔢𝔢𝔫 𝔨𝔞𝔩𝔱𝔟𝔩𝔲̈𝔱𝔦𝔤 𝔷𝔲 𝔢𝔯𝔪𝔬𝔯𝔡𝔢𝔫. 𝔇𝔢𝔯 𝔑𝔢𝔯𝔳𝔢𝔫𝔨𝔦𝔱𝔷𝔢𝔩, 𝔢𝔦𝔫𝔢𝔫 𝔞𝔫𝔦𝔪𝔦𝔢𝔯𝔱𝔢𝔫 ℭ𝔥𝔞𝔯𝔞𝔨𝔱𝔢𝔯 𝔦𝔫 𝔢𝔦𝔫𝔢𝔪 𝔒𝔫𝔩𝔦𝔫𝔢-𝔖𝔭𝔦𝔢𝔩 𝔷𝔲 𝔱𝔬̈𝔱𝔢𝔫, 𝔴𝔞𝔯 𝔫𝔬𝔠𝔥 𝔫𝔦𝔢 𝔰𝔬 𝔰𝔠𝔥𝔫𝔢𝔩𝔩. ℑ𝔠𝔥 𝔤𝔢𝔥𝔢 𝔡𝔞𝔫𝔫 𝔦𝔫 ℜ𝔦𝔠𝔥𝔱𝔲𝔫𝔤 ℜ𝔢𝔞𝔨𝔱𝔬𝔯, 𝔰𝔱𝔢𝔠𝔥𝔢 𝔊𝔢𝔩𝔟 𝔦𝔫 𝔡𝔢𝔫 ℜ𝔲̈𝔠𝔨𝔢𝔫 𝔲𝔫𝔡 𝔯𝔢𝔫𝔫𝔢 𝔡𝔞𝔫𝔫 𝔡𝔢𝔫 𝔎𝔬𝔯𝔯𝔦𝔡𝔬𝔯 𝔫𝔞𝔠𝔥 𝔯𝔢𝔠𝔥𝔱𝔰 𝔥𝔦𝔫𝔲𝔫𝔱𝔢𝔯, 𝔲𝔪 ℨ𝔲𝔤𝔞𝔫𝔤 𝔷𝔲𝔯 𝔇𝔢𝔨𝔬𝔫𝔱𝔞𝔪𝔦𝔫𝔞𝔱𝔦𝔬𝔫 𝔷𝔲 𝔢𝔯𝔥𝔞𝔩𝔱𝔢𝔫. ℑ𝔠𝔥 𝔟𝔢𝔴𝔢𝔤𝔢 𝔪𝔦𝔠𝔥 𝔩𝔢𝔦𝔰𝔢 𝔡𝔲𝔯𝔠𝔥 𝔡𝔦𝔢 ℌ𝔞𝔩𝔩𝔢𝔫, 𝔴𝔦𝔢 𝔢𝔦𝔫𝔢 𝔖𝔠𝔥𝔩𝔞𝔫𝔤𝔢, 𝔡𝔦𝔢 𝔤𝔢𝔯𝔞𝔡𝔢 𝔡𝔞𝔟𝔢𝔦 𝔦𝔰𝔱, 𝔦𝔥𝔯𝔢 𝔅𝔢𝔲𝔱𝔢 𝔷𝔲 𝔰𝔠𝔥𝔩𝔞𝔤𝔢𝔫, 𝔲𝔫𝔡 𝔦𝔠𝔥 𝔰𝔢𝔥𝔢 - 𝔒𝔥 𝔫𝔢𝔦𝔫. 𝔈𝔰 𝔦𝔰𝔱 𝔭𝔦𝔫𝔨. ℑ𝔠𝔥 𝔰𝔱𝔢𝔥𝔢 𝔯𝔢𝔤𝔲𝔫𝔤𝔰𝔩𝔬𝔰 𝔡𝔞 𝔲𝔫𝔡 𝔰𝔢𝔥𝔢 𝔰𝔦𝔢 𝔡𝔦𝔯𝔢𝔨𝔱 𝔞𝔫. ℑ𝔥𝔯 𝔙𝔦𝔰𝔦𝔢𝔯 𝔷𝔢𝔦𝔤𝔱 𝔨𝔢𝔦𝔫𝔢 𝔈𝔪𝔬𝔱𝔦𝔬𝔫𝔢𝔫. 𝔄𝔟𝔢𝔯 𝔰𝔦𝔢 𝔴𝔢𝔦ß 𝔢𝔰. ℑ𝔠𝔥 𝔨𝔞𝔫𝔫 𝔢𝔰 𝔦𝔫 𝔡𝔢𝔯 𝔏𝔲𝔣𝔱 𝔣𝔲̈𝔥𝔩𝔢𝔫. ℑ𝔠𝔥 𝔨𝔞𝔫𝔫 𝔰𝔦𝔢 𝔫𝔦𝔠𝔥𝔱 𝔱𝔬̈𝔱𝔢𝔫. 𝔖𝔦𝔢 𝔦𝔰𝔱 𝔷𝔲 𝔰𝔠𝔥𝔬̈𝔫, 𝔷𝔲 𝔢𝔫𝔤𝔢𝔩𝔥𝔞𝔣𝔱, 𝔡𝔞𝔰 𝔏𝔦𝔠𝔥𝔱 𝔴𝔦𝔯𝔡 𝔳𝔬𝔫 𝔦𝔥𝔯𝔢𝔪 𝔯𝔬𝔰𝔞 𝔅𝔬𝔡𝔶 𝔯𝔢𝔣𝔩𝔢𝔨𝔱𝔦𝔢𝔯𝔱, 𝔴𝔦𝔢 𝔖𝔱𝔢𝔯𝔫𝔢 𝔞𝔫 𝔢𝔦𝔫𝔢𝔪 𝔩𝔢𝔢𝔯𝔢𝔫 ℌ𝔦𝔪𝔪𝔢𝔩. 𝔖𝔦𝔢 𝔯𝔢𝔫𝔫𝔱 𝔫𝔦𝔠𝔥𝔱. ℑ𝔠𝔥 𝔟𝔦𝔫 𝔷𝔲 𝔗𝔯𝔞̈𝔫𝔢𝔫 𝔤𝔢𝔯𝔲̈𝔥𝔯𝔱, 𝔞𝔩𝔰 𝔦𝔠𝔥 𝔡𝔢𝔫 𝔅𝔦𝔩𝔡𝔰𝔠𝔥𝔦𝔯𝔪 𝔰𝔱𝔯𝔢𝔦𝔠𝔥𝔩𝔢 𝔲𝔫𝔡 𝔦𝔥𝔫 𝔷𝔞̈𝔯𝔱𝔩𝔦𝔠𝔥 𝔨𝔲̈𝔰𝔰𝔢. \"𝔄𝔲𝔣 𝔚𝔦𝔢𝔡𝔢𝔯𝔰𝔢𝔥𝔢𝔫, 𝔓𝔦𝔫𝔨. 𝔅𝔦𝔰 𝔟𝔞𝔩𝔡. 𝔈𝔰 𝔴𝔦𝔯𝔡 𝔞𝔩𝔩𝔢𝔰 𝔦𝔫 𝔒𝔯𝔡𝔫𝔲𝔫𝔤 𝔰𝔢𝔦𝔫\", 𝔣𝔩𝔲̈𝔰𝔱𝔢𝔯𝔢 𝔦𝔠𝔥 𝔪𝔦𝔱 𝔩𝔢𝔦𝔰𝔢𝔯, 𝔟𝔢𝔯𝔲𝔥𝔦𝔤𝔢𝔫𝔡𝔢𝔯 𝔖𝔱𝔦𝔪𝔪𝔢. 𝔇𝔞𝔫𝔫 𝔷𝔬̈𝔤𝔢𝔯𝔢 𝔦𝔠𝔥, 𝔴𝔞̈𝔥𝔯𝔢𝔫𝔡 𝔪𝔢𝔦𝔫 ℭ𝔲𝔯𝔰𝔬𝔯 𝔲̈𝔟𝔢𝔯 𝔡𝔢𝔪 𝔎𝔦𝔩𝔩-𝔅𝔲𝔱𝔱𝔬𝔫 𝔰𝔠𝔥𝔴𝔢𝔟𝔱. 𝔊𝔢𝔡𝔞𝔫𝔨𝔢𝔫 𝔡𝔢𝔯 𝔏𝔦𝔢𝔟𝔢 𝔤𝔢𝔥𝔢𝔫 𝔪𝔦𝔯 𝔡𝔲𝔯𝔠𝔥 𝔡𝔢𝔫 𝔎𝔬𝔭𝔣. ℜ𝔬𝔱 𝔪𝔦𝔱 𝔯𝔬̈𝔱𝔩𝔦𝔠𝔥-𝔯𝔬𝔰𝔞 𝔳𝔢𝔯𝔡𝔞̈𝔠𝔥𝔱𝔦𝔤𝔢𝔫 𝔎𝔦𝔫𝔡𝔢𝔯𝔫 𝔪𝔦𝔱 ℜ𝔬𝔰𝔞. 𝔄𝔟𝔢𝔯 𝔦𝔠𝔥 𝔪𝔲𝔰𝔰. 𝔄𝔩𝔰 𝔅𝔢𝔱𝔯𝔲̈𝔤𝔢𝔯 𝔦𝔰𝔱 𝔢𝔰 𝔪𝔢𝔦𝔫𝔢 𝔓𝔣𝔩𝔦𝔠𝔥𝔱 𝔷𝔲 𝔱𝔬̈𝔱𝔢𝔫. ℑ𝔠𝔥 𝔡𝔯𝔲̈𝔠𝔨𝔢 𝔡𝔢𝔫 '𝔎𝔦𝔩𝔩'-𝔎𝔫𝔬𝔭𝔣 𝔲𝔫𝔡 𝔟𝔢𝔬𝔟𝔞𝔠𝔥𝔱𝔢, 𝔴𝔦𝔢 𝔪𝔢𝔦𝔫 ℭ𝔥𝔞𝔯𝔞𝔨𝔱𝔢𝔯 𝔓𝔦𝔫𝔨 𝔩𝔞𝔲𝔱𝔩𝔬𝔰 𝔢𝔫𝔱𝔥𝔞𝔲𝔭𝔱𝔢𝔱. ℑ𝔠𝔥 𝔥𝔬̈𝔯𝔢 𝔫𝔲𝔯 𝔡𝔢𝔫 𝔅𝔩𝔲𝔱𝔰𝔱𝔯𝔞𝔥𝔩. 𝔎𝔢𝔦𝔫𝔢 𝔈𝔦𝔩𝔢. 𝔈𝔰 𝔤𝔦𝔟𝔱 𝔫𝔲𝔯 ℜ𝔢𝔡, 𝔡𝔢𝔯 𝔞𝔩𝔩𝔢𝔦𝔫𝔢 𝔦𝔫 𝔉𝔲𝔢𝔩 𝔰𝔱𝔢𝔥𝔱. ℜ𝔬𝔰𝔞𝔰 𝔩𝔢𝔟𝔩𝔬𝔰𝔢𝔯 𝔎𝔬̈𝔯𝔭𝔢𝔯 𝔩𝔞𝔤 𝔫𝔢𝔟𝔢𝔫 𝔦𝔥𝔪 𝔞𝔲𝔣 𝔡𝔢𝔪 𝔅𝔬𝔡𝔢𝔫. ℑ𝔠𝔥 𝔣𝔲̈𝔥𝔩𝔢 𝔷𝔲𝔢𝔯𝔰𝔱 𝔫𝔦𝔠𝔥𝔱𝔰, 𝔡𝔞𝔫𝔫 𝔲𝔫𝔢𝔯𝔪𝔢𝔰𝔰𝔩𝔦𝔠𝔥𝔢 𝔗𝔯𝔞𝔲𝔯𝔦𝔤𝔨𝔢𝔦𝔱, 𝔞𝔩𝔰 𝔴𝔞̈𝔯𝔢 𝔦𝔠𝔥 𝔟𝔢𝔦 𝔡𝔢𝔯 𝔅𝔢𝔢𝔯𝔡𝔦𝔤𝔲𝔫𝔤 𝔢𝔦𝔫𝔢𝔰 𝔤𝔢𝔩𝔦𝔢𝔟𝔱𝔢𝔫 𝔐𝔢𝔫𝔰𝔠𝔥𝔢𝔫. 𝔐𝔢𝔦𝔫 𝔖𝔬𝔥𝔫 𝔨𝔩𝔬𝔭𝔣𝔱 𝔞𝔫 𝔡𝔦𝔢 𝔗𝔲̈𝔯 𝔲𝔫𝔡 𝔲𝔫𝔱𝔢𝔯𝔟𝔯𝔦𝔠𝔥𝔱 𝔪𝔢𝔦𝔫𝔢𝔫 𝔨𝔲𝔯𝔷𝔢𝔫 𝔐𝔬𝔪𝔢𝔫𝔱 𝔡𝔢𝔯 𝔗𝔯𝔞𝔲𝔢𝔯. 𝔈𝔯 𝔣𝔯𝔞𝔤𝔱: \"𝔇𝔞𝔡? 𝔚𝔦𝔯𝔰𝔱 𝔡𝔲 𝔪𝔦𝔯 𝔢𝔦𝔫𝔢𝔫 𝔖𝔫𝔞𝔠𝔨 𝔪𝔞𝔠𝔥𝔢𝔫?\" ℑ𝔠𝔥 𝔰𝔞𝔤𝔢 𝔦𝔥𝔪, 𝔢𝔯 𝔰𝔬𝔩𝔩 𝔡𝔦𝔢 𝔎𝔩𝔞𝔭𝔭𝔢 𝔥𝔞𝔩𝔱𝔢𝔫, 𝔲𝔫𝔡 𝔪𝔢𝔦𝔫𝔢 𝔖𝔱𝔦𝔪𝔪𝔢 𝔟𝔯𝔦𝔠𝔥𝔱. ℑ𝔠𝔥 𝔟𝔯𝔢𝔠𝔥𝔢 𝔰𝔠𝔥𝔩𝔲𝔠𝔥𝔷𝔢𝔫𝔡 𝔷𝔲𝔰𝔞𝔪𝔪𝔢𝔫. ℑ𝔠𝔥 𝔥𝔞𝔟𝔢 𝔰𝔦𝔢 𝔤𝔢𝔱𝔬̈𝔱𝔢𝔱. ℑ𝔠𝔥 𝔥𝔞𝔟𝔢 𝔪𝔢𝔦𝔫𝔢 𝔢𝔦𝔫𝔷𝔦𝔤 𝔴𝔞𝔥𝔯𝔢 𝔏𝔦𝔢𝔟𝔢 𝔤𝔢𝔱𝔬̈𝔱𝔢𝔱. 𝔊𝔬𝔱𝔱 𝔳𝔢𝔯𝔤𝔦𝔟 𝔪𝔦𝔯. ℑ𝔠𝔥 𝔬̈𝔣𝔣𝔫𝔢 𝔪𝔢𝔦𝔫𝔢𝔪 𝔖𝔬𝔥𝔫 𝔡𝔦𝔢 𝔗𝔲̈𝔯 𝔲𝔫𝔡 𝔢𝔯 𝔥𝔞𝔱 𝔢𝔦𝔫𝔢𝔫 𝔳𝔢𝔯𝔴𝔦𝔯𝔯𝔱𝔢𝔫 𝔊𝔢𝔰𝔦𝔠𝔥𝔱𝔰𝔞𝔲𝔰𝔡𝔯𝔲𝔠𝔨. ℑ𝔠𝔥 𝔰𝔞𝔤𝔢 𝔫𝔦𝔠𝔥𝔱𝔰 𝔲𝔫𝔡 𝔤𝔢𝔥𝔢 𝔦𝔫 𝔡𝔦𝔢 𝔎𝔲̈𝔠𝔥𝔢, 𝔲𝔪 𝔦𝔥𝔪 𝔢𝔦𝔫 𝔖𝔞𝔫𝔡𝔴𝔦𝔠𝔥 𝔷𝔲 𝔪𝔞𝔠𝔥𝔢𝔫. 𝔗𝔯𝔞̈𝔫𝔢𝔫 𝔯𝔬𝔩𝔩𝔢𝔫 𝔳𝔬𝔫 𝔪𝔢𝔦𝔫𝔢𝔪 𝔊𝔢𝔰𝔦𝔠𝔥𝔱 𝔦𝔫𝔰 𝔅𝔯𝔬𝔱, 𝔞𝔩𝔰 𝔦𝔠𝔥 𝔢𝔰 𝔞𝔲𝔣 𝔡𝔦𝔢 𝔗𝔥𝔢𝔨𝔢 𝔩𝔢𝔤𝔢. 𝔖𝔞𝔩𝔞𝔱, 𝔎𝔞̈𝔰𝔢 𝔲𝔫𝔡 𝔉𝔩𝔢𝔦𝔰𝔠𝔥, 𝔤𝔢𝔣𝔬𝔩𝔤𝔱 𝔳𝔬𝔫 𝔢𝔦𝔫𝔢𝔪 𝔱𝔯𝔞𝔲𝔯𝔦𝔤𝔢𝔫 𝔚𝔦𝔯𝔟𝔢𝔩 𝔞𝔲𝔰 𝔖𝔢𝔫𝔣. 𝔐𝔢𝔦𝔫 𝔖𝔬𝔥𝔫 𝔦𝔰𝔱 𝔰𝔱𝔦𝔩𝔩. 𝔈𝔯 𝔰𝔦𝔱𝔷𝔱 𝔞𝔲𝔣 𝔡𝔢𝔯 ℭ𝔬𝔲𝔠𝔥 𝔲𝔫𝔡 𝔰𝔱𝔞𝔯𝔯𝔱 𝔞𝔲𝔣 𝔡𝔢𝔫 𝔅𝔬𝔡𝔢𝔫. 𝔈𝔰 𝔦𝔰𝔱 𝔢𝔦𝔫𝔢 𝔡𝔢𝔭𝔯𝔦𝔪𝔦𝔢𝔯𝔢𝔫𝔡𝔢 𝔏𝔲𝔣𝔱 𝔲𝔪 𝔲𝔫𝔰 𝔥𝔢𝔯𝔲𝔪. ℑ𝔠𝔥 𝔰𝔢𝔯𝔳𝔦𝔢𝔯𝔢 𝔦𝔥𝔪 𝔡𝔞𝔰 𝔖𝔞𝔫𝔡𝔴𝔦𝔠𝔥 𝔲𝔫𝔡 𝔤𝔢𝔥𝔢 𝔷𝔲𝔯𝔲̈𝔠𝔨 𝔦𝔫 𝔪𝔢𝔦𝔫 ℨ𝔦𝔪𝔪𝔢𝔯, 𝔲𝔪 𝔲̈𝔟𝔢𝔯 𝔡𝔞𝔰 𝔏𝔢𝔟𝔢𝔫 𝔫𝔞𝔠𝔥𝔷𝔲𝔡𝔢𝔫𝔨𝔢𝔫. 𝔚𝔢𝔫𝔫 𝔦𝔠𝔥 𝔓𝔦𝔫𝔨 𝔤𝔢𝔱𝔬̈𝔱𝔢𝔱 𝔥𝔞𝔟𝔢, 𝔴𝔦𝔢 𝔨𝔞𝔫𝔫 𝔦𝔠𝔥 𝔪𝔢𝔦𝔫𝔢𝔯 𝔉𝔞𝔪𝔦𝔩𝔦𝔢 𝔳𝔢𝔯𝔱𝔯𝔞𝔲𝔢𝔫? ℑ𝔠𝔥 𝔴𝔢𝔦𝔫𝔢 𝔰𝔱𝔲𝔫𝔡𝔢𝔫𝔩𝔞𝔫𝔤 𝔲𝔫𝔡 𝔰𝔠𝔥𝔩𝔦𝔢ß𝔩𝔦𝔠𝔥 𝔨𝔬𝔪𝔪𝔱 𝔪𝔢𝔦𝔫𝔢 𝔉𝔯𝔞𝔲 𝔷𝔲𝔯𝔲̈𝔠𝔨. 𝔖𝔦𝔢 𝔰𝔦𝔢𝔥𝔱 𝔪𝔦𝔠𝔥 𝔞𝔲𝔣 𝔡𝔢𝔪 𝔅𝔢𝔱𝔱 𝔟𝔯𝔲̈𝔩𝔩𝔢𝔫 𝔴𝔦𝔢 𝔢𝔦𝔫 𝔎𝔦𝔫𝔡, 𝔡𝔞𝔰 𝔰𝔢𝔦𝔫 𝔈𝔦𝔰 𝔣𝔞𝔩𝔩𝔢𝔫 𝔩𝔦𝔢ß. 𝔖𝔦𝔢 𝔣𝔯𝔞𝔤𝔱 𝔪𝔦𝔠𝔥 𝔡𝔞𝔫𝔫, 𝔴𝔞𝔯𝔲𝔪 𝔦𝔠𝔥 𝔴𝔢𝔦𝔫𝔢 𝔲𝔫𝔡 𝔪𝔲𝔯𝔪𝔩𝔢: \"ℑ𝔠𝔥 𝔥𝔞𝔟𝔢 𝔰𝔦𝔢 𝔤𝔢𝔱𝔬̈𝔱𝔢𝔱. ℑ𝔠𝔥 𝔥𝔞𝔟𝔢 𝔪𝔢𝔦𝔫𝔢 𝔢𝔦𝔫𝔷𝔦𝔤𝔢 𝔏𝔦𝔢𝔟𝔢, 𝔓𝔦𝔫𝔨, 𝔲𝔫𝔱𝔢𝔯 𝔲𝔫𝔰 𝔤𝔢𝔱𝔬̈𝔱𝔢𝔱.\" 𝔖𝔦𝔢 𝔦𝔰𝔱 𝔳𝔬𝔩𝔩𝔢𝔯 𝔚𝔲𝔱 𝔲𝔫𝔡 𝔰𝔠𝔥𝔩𝔞̈𝔤𝔱 𝔪𝔦𝔯 𝔦𝔫𝔰 𝔊𝔢𝔰𝔦𝔠𝔥𝔱. ℑ𝔠𝔥 𝔣𝔲̈𝔥𝔩𝔢 𝔪𝔦𝔠𝔥 𝔟𝔢𝔫𝔬𝔪𝔪𝔢𝔫. 𝔖𝔦𝔢 𝔟𝔦𝔱𝔱𝔢𝔱 𝔲𝔪 𝔖𝔠𝔥𝔢𝔦𝔡𝔲𝔫𝔤. ℑ𝔠𝔥 𝔞𝔫𝔱𝔴𝔬𝔯𝔱𝔢 𝔫𝔦𝔠𝔥𝔱. 𝔖𝔱𝔞𝔱𝔱𝔡𝔢𝔰𝔰𝔢𝔫 𝔫𝔢𝔥𝔪𝔢 𝔦𝔠𝔥 𝔪𝔢𝔦𝔫𝔢𝔫 𝔏𝔞𝔭𝔱𝔬𝔭, 𝔰𝔱𝔢𝔦𝔤𝔢 𝔦𝔫 𝔪𝔢𝔦𝔫 𝔄𝔲𝔱𝔬 𝔲𝔫𝔡 𝔣𝔞𝔥𝔯𝔢 𝔷𝔲 𝔢𝔦𝔫𝔢𝔪 𝔫𝔞𝔥𝔢 𝔤𝔢𝔩𝔢𝔤𝔢𝔫𝔢𝔫 ℌ𝔬𝔱𝔢𝔩. 𝔖𝔠𝔥𝔫𝔢𝔩𝔩𝔢𝔯 𝔙𝔬𝔯𝔩𝔞𝔲𝔣 𝔢𝔦𝔫𝔦𝔤𝔢 𝔐𝔬𝔫𝔞𝔱𝔢 𝔟𝔦𝔰 𝔷𝔲𝔯 𝔖𝔠𝔥𝔢𝔦𝔡𝔲𝔫𝔤. 𝔈𝔰 𝔴𝔞𝔯 𝔰𝔠𝔥𝔫𝔢𝔩𝔩 𝔲𝔫𝔡 𝔰𝔠𝔥𝔪𝔢𝔯𝔷𝔩𝔬𝔰. 𝔑𝔞𝔠𝔥 𝔡𝔢𝔪 𝔊𝔢𝔯𝔦𝔠𝔥𝔱 𝔟𝔦𝔱𝔱𝔢 𝔦𝔠𝔥 𝔪𝔢𝔦𝔫𝔢 𝔣𝔯𝔲̈𝔥𝔢𝔯𝔢 𝔉𝔯𝔞𝔲, 𝔪𝔦𝔠𝔥 𝔷𝔲𝔯𝔲̈𝔠𝔨𝔷𝔲𝔫𝔢𝔥𝔪𝔢𝔫. \"ℑ𝔠𝔥 𝔨𝔞𝔫𝔫 𝔡𝔦𝔠𝔥 𝔫𝔦𝔠𝔥𝔱 𝔷𝔲𝔯𝔲̈𝔠𝔨𝔫𝔢𝔥𝔪𝔢𝔫. 𝔇𝔲 𝔴𝔞𝔯𝔰𝔱 𝔦𝔪𝔪𝔢𝔯 𝔰𝔬. ℑ𝔠𝔥 𝔴𝔞𝔯 𝔡𝔦𝔯 𝔳𝔬𝔫 𝔄𝔫𝔣𝔞𝔫𝔤 𝔞𝔫 𝔪𝔦𝔰𝔰𝔱𝔯𝔞𝔲𝔦𝔰𝔠𝔥."
 
 // 1/n change to return true
 fn random(min int max int) {
-    res = run_command("fish" ["-c" "random " + min.to_string() + " " + max.to_string() ...])
+    res := run_command("fish" ["-c" "random " + min.to_string() + " " + max.to_string() ...])
     switch res {
         [[]/int string string] res.1.trim().parse_int().assume1()
     }
 }
 fn rnd() {
-    r = random(5 15)
+    r := random(5 15)
     switch r {
         int r
         [] 10
     }
 }
 
-words = rnd()
+words := rnd()
 for word text.regex("\\S+").assume_no_enum()
     if words > 0 {
         print(word + " ")
-        words = words - 1
+        &words = words - 1
         sleep(0.1)
     } else if words == 0 {
         println(word)
-        words = rnd()
+        &words = rnd()
         sleep(0.5)
     }
diff --git a/examples/custom_type.mers b/examples/custom_type.mers
index 47f708e..3f358a6 100644
--- a/examples/custom_type.mers
+++ b/examples/custom_type.mers
@@ -4,7 +4,7 @@ type elem [int []/elem]
 fn print_linked_list(start elem) {
     loop {
         println(start.0.to_string())
-        elem = start.1
+        elem := start.1
         switch! elem {
             [] {
                 println("[END]")
diff --git a/examples/get_ref.mers b/examples/get_ref.mers
index 6e33329..0971d81 100644
--- a/examples/get_ref.mers
+++ b/examples/get_ref.mers
@@ -1,9 +1,9 @@
-list = [1 2 3 4 5 6 7 8 9 ...]
+list := [1 2 3 4 5 6 7 8 9 ...]
 
 // calling get on an &list will get a reference
 &list.get(2).assume1() = 24
 // calling get on a list will get a value
-should_not_be_changeable = list.get(3).assume1()
+should_not_be_changeable := list.get(3).assume1()
 &should_not_be_changeable = 24
 
 if list.get(2) != [24] println("[!!] list.get(2) != 24 (was {0})".format(list.get(2).to_string()))
diff --git a/examples/iterators.mers b/examples/iterators.mers
index ad45e98..69a7a3f 100644
--- a/examples/iterators.mers
+++ b/examples/iterators.mers
@@ -4,7 +4,7 @@ fn map_string_to_int(list [string ...] func fn((string int))) {
         // this function will be called by the for loop
         // whenever it wants to retrieve the next item in the collection.
         // get the element
-        elem = &list.remove(0)
+        elem := &list.remove(0)
         switch! elem {
             // if the element was present, run the map function to convert it from a string to an int and return the result
             [string] {
@@ -24,8 +24,8 @@ for v ["1" "2" "5" "-10" ...].map_string_to_int((s string) s.parse_int().assume1
 // 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
+    i := 0
+    val := 0
     () {
         &val = val + { 2 * i } + 1
         &i = i + 1
diff --git a/examples/macro.mers b/examples/macro.mers
index 6cec7de..a44bfbb 100644
--- a/examples/macro.mers
+++ b/examples/macro.mers
@@ -1,8 +1,8 @@
-val = "some string"
-val = !(mers {
+val := "some string"
+val := !(mers {
     println("macro is running now!")
     "macro returned value"
 })
 println(val)
-val = !(mers "my_macro.mers")
+val := !(mers "my_macro.mers")
 println(val)
diff --git a/examples/modify_variable.mers b/examples/modify_variable.mers
index 823d008..c3e602b 100644
--- a/examples/modify_variable.mers
+++ b/examples/modify_variable.mers
@@ -1,9 +1,10 @@
 // NOTE: Might change, but this is the current state of things
-x = 10
-t = thread(() {
+x := 10
+t := thread(() {
     sleep(0.25)
     println(x.to_string())
 })
-// if this was x = 20 instead, the thread would still be using the old x = 10 value.
-&x = 20
+&x = 20 // -> 20 20 because it modifies the original variable x
+// x := 20 // -> 10 20 because it shadows the original variable x
 t.await()
+println(x.to_string())
diff --git a/examples/thread.mers b/examples/thread.mers
index f542746..93cac12 100644
--- a/examples/thread.mers
+++ b/examples/thread.mers
@@ -1,17 +1,17 @@
 // this is true by default so the example doesn't finish too quickly or too slowly depending on your hardware.
 // you can set it to false and tweak the max value for a more authentic cpu-heavy workload.
-fake_delay = true
+fake_delay := true
 
 // this will be shared between the two threads to report the progress in percent (0-100%).
-progress = 0
+progress := 0
 
 // an anonymous function that sums all numbers from 0 to max.
 // it captures the progress variable and uses it to report its status to the main thread, which will periodically print the current progress.
 // once done, it returns a string with the sum of all numbers.
-calculator = (max int) {
-    sum = 0
+calculator := (max int) {
+    sum := 0
     for i max {
-        i = i + 1
+        i := i + 1
         // println("i: {0} s: {1}".format(i.to_string() sum.to_string()))
         &sum = sum + i
         if fake_delay sleep(1)
@@ -21,7 +21,7 @@ calculator = (max int) {
 }
 
 // start the thread. if fake_delay is true, calculate 1+2+3+4+5+6+7+8+9+10. if fake_delay is false, count up to some ridiculously large number.
-slow_calculation_thread = calculator.thread(if fake_delay 10 else 20000000)
+slow_calculation_thread := calculator.thread(if fake_delay 10 else 20000000)
 
 // every second, print the progress. once it reaches 100%, stop
 loop {
@@ -31,6 +31,6 @@ loop {
 }
 
 // use await() to get the result from the thread. if the thread is still running, this will block until the thread finishes.
-result = slow_calculation_thread.await()
+result := slow_calculation_thread.await()
 
 println("Thread finished, result: {0}".format(result))
diff --git a/mers/src/lang/code_parsed.rs b/mers/src/lang/code_parsed.rs
index 871a014..b74ae0d 100755
--- a/mers/src/lang/code_parsed.rs
+++ b/mers/src/lang/code_parsed.rs
@@ -40,8 +40,8 @@ impl SStatementEnum {
 pub struct SStatement {
     /// if the statement is a Variable that doesn't exist yet, it will be initialized.
     /// if it's a variable that exists, but is_ref is false, an error may show up: cannot dereference
-    /// NOTE: Maybe add a bool that indicates a variable should be newly declared, shadowing old ones with the same name.
-    pub output_to: Option<(Box<SStatement>, usize)>,
+    /// if the third value is true, the variable will always be initialized, shadowing previous mentions of the same name.
+    pub output_to: Option<(Box<SStatement>, usize, bool)>,
     pub statement: Box<SStatementEnum>,
     pub force_output_type: Option<VType>,
 }
@@ -55,7 +55,12 @@ impl SStatement {
         }
     }
     pub fn output_to(mut self, statement: SStatement, derefs: usize) -> Self {
-        self.output_to = Some((Box::new(statement), derefs));
+        self.output_to = Some((Box::new(statement), derefs, false));
+        self
+    }
+    /// like output_to, but always initializes the variable (shadows previous variables of the same name)
+    pub fn initialize_to(mut self, statement: SStatement, derefs: usize) -> Self {
+        self.output_to = Some((Box::new(statement), derefs, true));
         self
     }
     // forces the statement's output to fit in a certain type.
@@ -248,7 +253,7 @@ impl FormatGs for SStatement {
         form: &mut super::fmtgs::FormatInfo,
         file: Option<&crate::parsing::file::File>,
     ) -> std::fmt::Result {
-        if let Some((opt, derefs)) = &self.output_to {
+        if let Some((opt, derefs, is_init)) = &self.output_to {
             // TODO!
             match opt.statement.as_ref() {
                 // SStatementEnum::Variable(name, is_ref) => {
@@ -261,7 +266,13 @@ impl FormatGs for SStatement {
                 //     )?;
                 // }
                 _ => {
-                    write!(f, "{}{} = ", "*".repeat(*derefs), opt.with(info, file))?;
+                    write!(
+                        f,
+                        "{}{} {} ",
+                        "*".repeat(*derefs),
+                        opt.with(info, file),
+                        if *is_init { ":=" } else { "=" }
+                    )?;
                 }
             }
         }
diff --git a/mers/src/lang/global_info.rs b/mers/src/lang/global_info.rs
index d35b608..f8fd354 100755
--- a/mers/src/lang/global_info.rs
+++ b/mers/src/lang/global_info.rs
@@ -25,6 +25,11 @@ pub struct GlobalScriptInfo {
     pub custom_type_names: HashMap<String, usize>,
     pub custom_types: Vec<VType>,
 
+    /// if true, trying to assign to the reference of a variable that doesn't exist yet will create and initialize that variable.
+    /// if false, variables will only be initialized if this is explicitly stated.
+    /// settings this to true is useful for "x = 2; x = 5;" syntax in parser implementations that don't differenciate initialization and assignment syntactically.
+    pub to_runnable_automatic_initialization: bool,
+
     pub formatter: ColorFormatter,
 
     pub log: Logger,
@@ -94,6 +99,7 @@ impl Default for GlobalScriptInfo {
             enum_variants: Self::default_enum_variants(),
             custom_type_names: HashMap::new(),
             custom_types: vec![],
+            to_runnable_automatic_initialization: false,
             formatter: Default::default(),
             log: Logger::new(),
         }
diff --git a/mers/src/lang/to_runnable.rs b/mers/src/lang/to_runnable.rs
index 267d2c1..b16a28e 100755
--- a/mers/src/lang/to_runnable.rs
+++ b/mers/src/lang/to_runnable.rs
@@ -371,8 +371,9 @@ fn statement_adv(
             }
             SStatementEnum::Variable(v, is_ref) => {
                 let existing_var = linfo.vars.get(v);
+                let is_init_force = if let Some(v) = &to_be_assigned_to { *v.1 } else { false };
                 // we can't assign to a variable that doesn't exist yet -> create a new one
-                if existing_var.is_none() {
+                if is_init_force || (existing_var.is_none() && ginfo.to_runnable_automatic_initialization) {
                     // if to_be_assigned_to is some (-> this is on the left side of an assignment), create a new variable. else, return an error.
                     if let Some((t, is_init)) = to_be_assigned_to {
                         *is_init = true;
@@ -401,7 +402,7 @@ fn statement_adv(
                         *is_ref
                     )
                 } else {
-                    unreachable!()
+                    return Err(ToRunnableError::UseOfUndefinedVariable(v.clone()));
                 }
             }
             SStatementEnum::FunctionCall(v, args) => {
@@ -678,8 +679,9 @@ fn statement_adv(
             return Err(ToRunnableError::StatementRequiresOutputTypeToBeAButItActuallyOutputsBWhichDoesNotFitInA(force_opt.clone(), real_output_type, VType { types: problematic_types }));
         }
     }
-    if let Some((opt, derefs)) = &s.output_to {
-        let mut is_init = false;
+    if let Some((opt, derefs, is_init)) = &s.output_to {
+        // if false, may be changed to true by statement_adv
+        let mut is_init = *is_init;
         let optr = statement_adv(
             opt,
             ginfo,
diff --git a/mers/src/parsing/parse.rs b/mers/src/parsing/parse.rs
index 25fe848..a574668 100755
--- a/mers/src/parsing/parse.rs
+++ b/mers/src/parsing/parse.rs
@@ -1005,23 +1005,21 @@ pub mod implementation {
                     )
                     .to()
                 }
-                // 000 =
+                // 000 = :=
                 (0..=0, Some('=')) => {
                     file.next();
-                    // NOTE: Old code to change `x = 10` to `&x = 10`
-                    // match out.statement.as_mut() {
-                    //     SStatementEnum::Variable(name, r) => {
-                    //         if name.starts_with("*") {
-                    //             *name = name[1..].to_owned();
-                    //         } else {
-                    //             *r = true
-                    //         }
-                    //     }
-                    //     _ => {}
-                    // }
-                    // NOTE: Set this 0 to 1 to prevent a = b = c from being valid
                     parse_statement(file)?.output_to(out, 0)
                 }
+                (0..=0, Some(':'))
+                    if matches!(
+                        file.get_char(file.get_pos().current_char_index + 1),
+                        Some('=')
+                    ) =>
+                {
+                    file.next();
+                    file.next();
+                    parse_statement(file)?.initialize_to(out, 0)
+                }
                 _ => break,
             };
         }