querysub 0.356.0 → 0.357.0

package/src/wat/watInstructions.txt

@@ -0,0 +1,707 @@
+Logo of WebAssembly
+
+Navigation
+Introduction
+Structure
+Validation
+Execution
+Binary Format
+Conventions
+Values
+Types
+Instructions
+Modules
+Text Format
+Appendix
+Index of Types
+Index of Instructions
+Index of Semantic Rules
+Index
+Download as PDF
+Quick search
+Instructions
+Instructions are encoded by opcodes. Each opcode is represented by a single byte, and is followed by the instruction’s immediate arguments, where present. The only exception are structured control instructions, which consist of several opcodes bracketing their nested instruction sequences.
+
+Note
+The byte codes chosen to encode instructions are historical and do not follow a consistent pattern. In this section, instructions are hence not presented in opcode order, but instead grouped consistently with other sections in this document. An instruction index ordered by opcode can be found in the Appendix.
+
+Gaps in the byte code ranges are reserved for future extensions.
+
+Parametric Instructions
+Parametric instructions are represented by single byte codes, possibly followed by a type annotation.
+
+𝚒𝚗𝚜𝚝𝚛	::=	𝟶𝚡𝟶𝟶		⇒		𝗎𝗇𝗋𝖾𝖺𝖼𝗁𝖺𝖻𝗅𝖾	
+|	𝟶𝚡𝟶𝟷		⇒		𝗇𝗈𝗉	
+|	𝟶𝚡𝟷𝙰		⇒		𝖽𝗋𝗈𝗉	
+|	𝟶𝚡𝟷𝙱		⇒		𝗌𝖾𝗅𝖾𝖼𝗍	
+|	𝟶𝚡𝟷𝙲  𝑡∗:𝚕𝚒𝚜𝚝(𝚟𝚊𝚕𝚝𝚢𝚙𝚎)		⇒		𝗌𝖾𝗅𝖾𝖼𝗍 𝑡∗	
+ 
+ 
+Control Instructions
+Control instructions have varying encodings. For structured instructions, the instruction sequences forming nested blocks are delimited with explicit opcodes for 𝖾𝗇𝖽 and 𝖾𝗅𝗌𝖾.
+
+Block types are encoded in special compressed form, by either the byte 𝟶𝚡𝟺𝟶 indicating the empty type, as a single value type, or as a type index encoded as a positive signed integer.
+
+𝚋𝚕𝚘𝚌𝚔𝚝𝚢𝚙𝚎	::=	𝟶𝚡𝟺𝟶		⇒		𝜖			
+|	𝑡:𝚟𝚊𝚕𝚝𝚢𝚙𝚎		⇒		𝑡			
+|	𝑖:𝚜𝟹𝟹		⇒		𝑖		if 𝑖≥0	
+𝚒𝚗𝚜𝚝𝚛	::=	…							
+|	𝟶𝚡𝟶𝟸  bt:𝚋𝚕𝚘𝚌𝚔𝚝𝚢𝚙𝚎  (in:𝚒𝚗𝚜𝚝𝚛)∗  𝟶𝚡𝟶𝙱		⇒		𝖻𝗅𝗈𝖼𝗄 bt in∗			
+|	𝟶𝚡𝟶𝟹  bt:𝚋𝚕𝚘𝚌𝚔𝚝𝚢𝚙𝚎  (in:𝚒𝚗𝚜𝚝𝚛)∗  𝟶𝚡𝟶𝙱		⇒		𝗅𝗈𝗈𝗉 bt in∗			
+|	𝟶𝚡𝟶𝟺  bt:𝚋𝚕𝚘𝚌𝚔𝚝𝚢𝚙𝚎  (in:𝚒𝚗𝚜𝚝𝚛)∗  𝟶𝚡𝟶𝙱		⇒		𝗂𝖿 bt in∗ 𝖾𝗅𝗌𝖾 𝜖			
+|	 
+𝟶𝚡𝟶𝟺  bt:𝚋𝚕𝚘𝚌𝚔𝚝𝚢𝚙𝚎  (in1:𝚒𝚗𝚜𝚝𝚛)∗	
+𝟶𝚡𝟶𝟻  (in2:𝚒𝚗𝚜𝚝𝚛)∗  𝟶𝚡𝟶𝙱	
+ 		⇒		𝗂𝖿 bt in∗
+1 𝖾𝗅𝗌𝖾 in∗
+2			
+|	𝟶𝚡𝟶𝟾  𝑥:𝚝𝚊𝚐𝚒𝚍𝚡		⇒		𝗍𝗁𝗋𝗈𝗐 𝑥			
+|	𝟶𝚡𝟶𝙰		⇒		𝗍𝗁𝗋𝗈𝗐_𝗋𝖾𝖿			
+|	𝟶𝚡𝟶𝙲  𝑙:𝚕𝚊𝚋𝚎𝚕𝚒𝚍𝚡		⇒		𝖻𝗋 𝑙			
+|	𝟶𝚡𝟶𝙳  𝑙:𝚕𝚊𝚋𝚎𝚕𝚒𝚍𝚡		⇒		𝖻𝗋_𝗂𝖿 𝑙			
+|	𝟶𝚡𝟶𝙴  𝑙∗:𝚕𝚒𝚜𝚝(𝚕𝚊𝚋𝚎𝚕𝚒𝚍𝚡)  𝑙𝑛:𝚕𝚊𝚋𝚎𝚕𝚒𝚍𝚡		⇒		𝖻𝗋_𝗍𝖺𝖻𝗅𝖾 𝑙∗ 𝑙𝑛			
+|	𝟶𝚡𝟶𝙵		⇒		𝗋𝖾𝗍𝗎𝗋𝗇			
+|	𝟶𝚡𝟷𝟶  𝑥:𝚏𝚞𝚗𝚌𝚒𝚍𝚡		⇒		𝖼𝖺𝗅𝗅 𝑥			
+|	𝟶𝚡𝟷𝟷  𝑦:𝚝𝚢𝚙𝚎𝚒𝚍𝚡  𝑥:𝚝𝚊𝚋𝚕𝚎𝚒𝚍𝚡		⇒		𝖼𝖺𝗅𝗅_𝗂𝗇𝖽𝗂𝗋𝖾𝖼𝗍 𝑥 𝑦			
+|	𝟶𝚡𝟷𝟸  𝑥:𝚏𝚞𝚗𝚌𝚒𝚍𝚡		⇒		𝗋𝖾𝗍𝗎𝗋𝗇_𝖼𝖺𝗅𝗅 𝑥			
+|	𝟶𝚡𝟷𝟹  𝑦:𝚝𝚢𝚙𝚎𝚒𝚍𝚡  𝑥:𝚝𝚊𝚋𝚕𝚎𝚒𝚍𝚡		⇒		𝗋𝖾𝗍𝗎𝗋𝗇_𝖼𝖺𝗅𝗅_𝗂𝗇𝖽𝗂𝗋𝖾𝖼𝗍 𝑥 𝑦			
+|	𝟶𝚡𝟷𝟺  𝑥:𝚝𝚢𝚙𝚎𝚒𝚍𝚡		⇒		𝖼𝖺𝗅𝗅_𝗋𝖾𝖿 𝑥			
+|	𝟶𝚡𝟷𝟻  𝑥:𝚝𝚢𝚙𝚎𝚒𝚍𝚡		⇒		𝗋𝖾𝗍𝗎𝗋𝗇_𝖼𝖺𝗅𝗅_𝗋𝖾𝖿 𝑥			
+|	𝟶𝚡𝟷𝙵  bt:𝚋𝚕𝚘𝚌𝚔𝚝𝚢𝚙𝚎  𝑐∗:𝚕𝚒𝚜𝚝(𝚌𝚊𝚝𝚌𝚑)  (in:𝚒𝚗𝚜𝚝𝚛)∗  𝟶𝚡𝟶𝙱		⇒		𝗍𝗋𝗒_𝗍𝖺𝖻𝗅𝖾 bt 𝑐∗ in∗			
+|	𝟶𝚡𝙳𝟻  𝑙:𝚕𝚊𝚋𝚎𝚕𝚒𝚍𝚡		⇒		𝖻𝗋_𝗈𝗇_𝗇𝗎𝗅𝗅 𝑙			
+|	𝟶𝚡𝙳𝟼  𝑙:𝚕𝚊𝚋𝚎𝚕𝚒𝚍𝚡		⇒		𝖻𝗋_𝗈𝗇_𝗇𝗈𝗇_𝗇𝗎𝗅𝗅 𝑙			
+|	 
+𝟶𝚡𝙵𝙱  24:𝚞𝟹𝟸  (𝗇𝗎𝗅𝗅?
+1,𝗇𝗎𝗅𝗅?
+2):𝚌𝚊𝚜𝚝𝚘𝚙	
+𝑙:𝚕𝚊𝚋𝚎𝚕𝚒𝚍𝚡  ht1:𝚑𝚎𝚊𝚙𝚝𝚢𝚙𝚎  ht2:𝚑𝚎𝚊𝚙𝚝𝚢𝚙𝚎	
+ 		⇒		𝖻𝗋_𝗈𝗇_𝖼𝖺𝗌𝗍 𝑙 (𝗋𝖾𝖿 𝗇𝗎𝗅𝗅?
+1 ht1) (𝗋𝖾𝖿 𝗇𝗎𝗅𝗅?
+2 ht2)			
+|	 
+𝟶𝚡𝙵𝙱  25:𝚞𝟹𝟸  (𝗇𝗎𝗅𝗅?
+1,𝗇𝗎𝗅𝗅?
+2):𝚌𝚊𝚜𝚝𝚘𝚙	
+𝑙:𝚕𝚊𝚋𝚎𝚕𝚒𝚍𝚡  ht1:𝚑𝚎𝚊𝚙𝚝𝚢𝚙𝚎  ht2:𝚑𝚎𝚊𝚙𝚝𝚢𝚙𝚎	
+ 		⇒		𝖻𝗋_𝗈𝗇_𝖼𝖺𝗌𝗍_𝖿𝖺𝗂𝗅 𝑙 (𝗋𝖾𝖿 𝗇𝗎𝗅𝗅?
+1 ht1) (𝗋𝖾𝖿 𝗇𝗎𝗅𝗅?
+2 ht2)			
+𝚌𝚊𝚝𝚌𝚑	::=	𝟶𝚡𝟶𝟶  𝑥:𝚝𝚊𝚐𝚒𝚍𝚡  𝑙:𝚕𝚊𝚋𝚎𝚕𝚒𝚍𝚡		⇒		𝖼𝖺𝗍𝖼𝗁 𝑥 𝑙			
+|	𝟶𝚡𝟶𝟷  𝑥:𝚝𝚊𝚐𝚒𝚍𝚡  𝑙:𝚕𝚊𝚋𝚎𝚕𝚒𝚍𝚡		⇒		𝖼𝖺𝗍𝖼𝗁_𝗋𝖾𝖿 𝑥 𝑙			
+|	𝟶𝚡𝟶𝟸  𝑙:𝚕𝚊𝚋𝚎𝚕𝚒𝚍𝚡		⇒		𝖼𝖺𝗍𝖼𝗁_𝖺𝗅𝗅 𝑙			
+|	𝟶𝚡𝟶𝟹  𝑙:𝚕𝚊𝚋𝚎𝚕𝚒𝚍𝚡		⇒		𝖼𝖺𝗍𝖼𝗁_𝖺𝗅𝗅_𝗋𝖾𝖿 𝑙			
+𝚌𝚊𝚜𝚝𝚘𝚙	::=	𝟶𝚡𝟶𝟶		⇒		(𝜖,𝜖)			
+|	𝟶𝚡𝟶𝟷		⇒		(𝗇𝗎𝗅𝗅,𝜖)			
+|	𝟶𝚡𝟶𝟸		⇒		(𝜖,𝗇𝗎𝗅𝗅)			
+|	𝟶𝚡𝟶𝟹		⇒		(𝗇𝗎𝗅𝗅,𝗇𝗎𝗅𝗅)			
+ 
+ 
+Note
+The 𝖾𝗅𝗌𝖾 opcode 𝟶𝚡𝟶𝟻 in the encoding of an 𝗂𝖿 instruction can be omitted if the following instruction sequence is empty.
+
+Unlike any other occurrence, the type index in a block type is encoded as a positive signed integer, so that its signed LEB128 bit pattern cannot collide with the encoding of value types or the special code 𝟶𝚡𝟺𝟶, which correspond to the LEB128 encoding of negative integers. To avoid any loss in the range of allowed indices, it is treated as a 33 bit signed integer.
+
+Variable Instructions
+Variable instructions are represented by byte codes followed by the encoding of the respective index.
+
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝟸𝟶  𝑥:𝚕𝚘𝚌𝚊𝚕𝚒𝚍𝚡		⇒		𝗅𝗈𝖼𝖺𝗅.𝗀𝖾𝗍 𝑥	
+|	𝟶𝚡𝟸𝟷  𝑥:𝚕𝚘𝚌𝚊𝚕𝚒𝚍𝚡		⇒		𝗅𝗈𝖼𝖺𝗅.𝗌𝖾𝗍 𝑥	
+|	𝟶𝚡𝟸𝟸  𝑥:𝚕𝚘𝚌𝚊𝚕𝚒𝚍𝚡		⇒		𝗅𝗈𝖼𝖺𝗅.𝗍𝖾𝖾 𝑥	
+|	𝟶𝚡𝟸𝟹  𝑥:𝚐𝚕𝚘𝚋𝚊𝚕𝚒𝚍𝚡		⇒		𝗀𝗅𝗈𝖻𝖺𝗅.𝗀𝖾𝗍 𝑥	
+|	𝟶𝚡𝟸𝟺  𝑥:𝚐𝚕𝚘𝚋𝚊𝚕𝚒𝚍𝚡		⇒		𝗀𝗅𝗈𝖻𝖺𝗅.𝗌𝖾𝗍 𝑥	
+ 
+ 
+Table Instructions
+Table instructions are represented either by a single byte or a one byte prefix followed by a variable-length unsigned integer.
+
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝟸𝟻  𝑥:𝚝𝚊𝚋𝚕𝚎𝚒𝚍𝚡		⇒		𝗍𝖺𝖻𝗅𝖾.𝗀𝖾𝗍 𝑥	
+|	𝟶𝚡𝟸𝟼  𝑥:𝚝𝚊𝚋𝚕𝚎𝚒𝚍𝚡		⇒		𝗍𝖺𝖻𝗅𝖾.𝗌𝖾𝗍 𝑥	
+|	𝟶𝚡𝙵𝙲  12:𝚞𝟹𝟸  𝑦:𝚎𝚕𝚎𝚖𝚒𝚍𝚡  𝑥:𝚝𝚊𝚋𝚕𝚎𝚒𝚍𝚡		⇒		𝗍𝖺𝖻𝗅𝖾.𝗂𝗇𝗂𝗍 𝑥 𝑦	
+|	𝟶𝚡𝙵𝙲  13:𝚞𝟹𝟸  𝑥:𝚎𝚕𝚎𝚖𝚒𝚍𝚡		⇒		𝖾𝗅𝖾𝗆.𝖽𝗋𝗈𝗉 𝑥	
+|	𝟶𝚡𝙵𝙲  14:𝚞𝟹𝟸  𝑥1:𝚝𝚊𝚋𝚕𝚎𝚒𝚍𝚡  𝑥2:𝚝𝚊𝚋𝚕𝚎𝚒𝚍𝚡		⇒		𝗍𝖺𝖻𝗅𝖾.𝖼𝗈𝗉𝗒 𝑥1 𝑥2	
+|	𝟶𝚡𝙵𝙲  15:𝚞𝟹𝟸  𝑥:𝚝𝚊𝚋𝚕𝚎𝚒𝚍𝚡		⇒		𝗍𝖺𝖻𝗅𝖾.𝗀𝗋𝗈𝗐 𝑥	
+|	𝟶𝚡𝙵𝙲  16:𝚞𝟹𝟸  𝑥:𝚝𝚊𝚋𝚕𝚎𝚒𝚍𝚡		⇒		𝗍𝖺𝖻𝗅𝖾.𝗌𝗂𝗓𝖾 𝑥	
+|	𝟶𝚡𝙵𝙲  17:𝚞𝟹𝟸  𝑥:𝚝𝚊𝚋𝚕𝚎𝚒𝚍𝚡		⇒		𝗍𝖺𝖻𝗅𝖾.𝖿𝗂𝗅𝗅 𝑥	
+ 
+ 
+Memory Instructions
+Each variant of memory instruction is encoded with a different byte code. Loads and stores are followed by the encoding of their memarg immediate, which includes the memory index if bit 6 of the flags field containing alignment is set; the memory index defaults to 0 otherwise.
+
+𝚖𝚎𝚖𝚊𝚛𝚐	::=	𝑛:𝚞𝟹𝟸  𝑚:𝚞𝟼𝟺		⇒		(0,{𝖺𝗅𝗂𝗀𝗇 𝑛,𝗈𝖿𝖿𝗌𝖾𝗍 𝑚})		if 𝑛<26	
+|	𝑛:𝚞𝟹𝟸  𝑥:𝚖𝚎𝚖𝚒𝚍𝚡  𝑚:𝚞𝟼𝟺		⇒		(𝑥,{𝖺𝗅𝗂𝗀𝗇 (𝑛−26),𝗈𝖿𝖿𝗌𝖾𝗍 𝑚})		if 26≤𝑛<27	
+𝚒𝚗𝚜𝚝𝚛	::=	…							
+|	𝟶𝚡𝟸𝟾  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗂𝟥𝟤.𝗅𝗈𝖺𝖽 𝑥 ao			
+|	𝟶𝚡𝟸𝟿  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗂𝟨𝟦.𝗅𝗈𝖺𝖽 𝑥 ao			
+|	𝟶𝚡𝟸𝙰  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝖿𝟥𝟤.𝗅𝗈𝖺𝖽 𝑥 ao			
+|	𝟶𝚡𝟸𝙱  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝖿𝟨𝟦.𝗅𝗈𝖺𝖽 𝑥 ao			
+|	𝟶𝚡𝟸𝙲  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗂𝟥𝟤.𝗅𝗈𝖺𝖽𝟪_𝗌 𝑥 ao			
+|	𝟶𝚡𝟸𝙳  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗂𝟥𝟤.𝗅𝗈𝖺𝖽𝟪_𝗎 𝑥 ao			
+|	𝟶𝚡𝟸𝙴  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗂𝟥𝟤.𝗅𝗈𝖺𝖽𝟣𝟨_𝗌 𝑥 ao			
+|	𝟶𝚡𝟸𝙵  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗂𝟥𝟤.𝗅𝗈𝖺𝖽𝟣𝟨_𝗎 𝑥 ao			
+|	𝟶𝚡𝟹𝟶  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗂𝟨𝟦.𝗅𝗈𝖺𝖽𝟪_𝗌 𝑥 ao			
+|	𝟶𝚡𝟹𝟷  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗂𝟨𝟦.𝗅𝗈𝖺𝖽𝟪_𝗎 𝑥 ao			
+|	𝟶𝚡𝟹𝟸  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗂𝟨𝟦.𝗅𝗈𝖺𝖽𝟣𝟨_𝗌 𝑥 ao			
+|	𝟶𝚡𝟹𝟹  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗂𝟨𝟦.𝗅𝗈𝖺𝖽𝟣𝟨_𝗎 𝑥 ao			
+|	𝟶𝚡𝟹𝟺  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗂𝟨𝟦.𝗅𝗈𝖺𝖽𝟥𝟤_𝗌 𝑥 ao			
+|	𝟶𝚡𝟹𝟻  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗂𝟨𝟦.𝗅𝗈𝖺𝖽𝟥𝟤_𝗎 𝑥 ao			
+|	𝟶𝚡𝟹𝟼  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗂𝟥𝟤.𝗌𝗍𝗈𝗋𝖾 𝑥 ao			
+|	𝟶𝚡𝟹𝟽  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗂𝟨𝟦.𝗌𝗍𝗈𝗋𝖾 𝑥 ao			
+|	𝟶𝚡𝟹𝟾  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝖿𝟥𝟤.𝗌𝗍𝗈𝗋𝖾 𝑥 ao			
+|	𝟶𝚡𝟹𝟿  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝖿𝟨𝟦.𝗌𝗍𝗈𝗋𝖾 𝑥 ao			
+|	𝟶𝚡𝟹𝙰  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗂𝟥𝟤.𝗌𝗍𝗈𝗋𝖾𝟪 𝑥 ao			
+|	𝟶𝚡𝟹𝙱  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗂𝟥𝟤.𝗌𝗍𝗈𝗋𝖾𝟣𝟨 𝑥 ao			
+|	𝟶𝚡𝟹𝙲  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗂𝟨𝟦.𝗌𝗍𝗈𝗋𝖾𝟪 𝑥 ao			
+|	𝟶𝚡𝟹𝙳  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗂𝟨𝟦.𝗌𝗍𝗈𝗋𝖾𝟣𝟨 𝑥 ao			
+|	𝟶𝚡𝟹𝙴  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗂𝟨𝟦.𝗌𝗍𝗈𝗋𝖾𝟥𝟤 𝑥 ao			
+|	𝟶𝚡𝟹𝙵  𝑥:𝚖𝚎𝚖𝚒𝚍𝚡		⇒		𝗆𝖾𝗆𝗈𝗋𝗒.𝗌𝗂𝗓𝖾 𝑥			
+|	𝟶𝚡𝟺𝟶  𝑥:𝚖𝚎𝚖𝚒𝚍𝚡		⇒		𝗆𝖾𝗆𝗈𝗋𝗒.𝗀𝗋𝗈𝗐 𝑥			
+|	𝟶𝚡𝙵𝙲  8:𝚞𝟹𝟸  𝑦:𝚍𝚊𝚝𝚊𝚒𝚍𝚡  𝑥:𝚖𝚎𝚖𝚒𝚍𝚡		⇒		𝗆𝖾𝗆𝗈𝗋𝗒.𝗂𝗇𝗂𝗍 𝑥 𝑦			
+|	𝟶𝚡𝙵𝙲  9:𝚞𝟹𝟸  𝑥:𝚍𝚊𝚝𝚊𝚒𝚍𝚡		⇒		𝖽𝖺𝗍𝖺.𝖽𝗋𝗈𝗉 𝑥			
+|	𝟶𝚡𝙵𝙲  10:𝚞𝟹𝟸  𝑥1:𝚖𝚎𝚖𝚒𝚍𝚡  𝑥2:𝚖𝚎𝚖𝚒𝚍𝚡		⇒		𝗆𝖾𝗆𝗈𝗋𝗒.𝖼𝗈𝗉𝗒 𝑥1 𝑥2			
+|	𝟶𝚡𝙵𝙲  11:𝚞𝟹𝟸  𝑥:𝚖𝚎𝚖𝚒𝚍𝚡		⇒		𝗆𝖾𝗆𝗈𝗋𝗒.𝖿𝗂𝗅𝗅 𝑥			
+ 
+ 
+Reference Instructions
+Generic reference instructions are represented by single byte codes, others use prefixes and type operands.
+
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝙳𝟶  ht:𝚑𝚎𝚊𝚙𝚝𝚢𝚙𝚎		⇒		𝗋𝖾𝖿.𝗇𝗎𝗅𝗅 ht	
+|	𝟶𝚡𝙳𝟷		⇒		𝗋𝖾𝖿.𝗂𝗌_𝗇𝗎𝗅𝗅	
+|	𝟶𝚡𝙳𝟸  𝑥:𝚏𝚞𝚗𝚌𝚒𝚍𝚡		⇒		𝗋𝖾𝖿.𝖿𝗎𝗇𝖼 𝑥	
+|	𝟶𝚡𝙳𝟹		⇒		𝗋𝖾𝖿.𝖾𝗊	
+|	𝟶𝚡𝙳𝟺		⇒		𝗋𝖾𝖿.𝖺𝗌_𝗇𝗈𝗇_𝗇𝗎𝗅𝗅	
+|	𝟶𝚡𝙵𝙱  20:𝚞𝟹𝟸  ht:𝚑𝚎𝚊𝚙𝚝𝚢𝚙𝚎		⇒		𝗋𝖾𝖿.𝗍𝖾𝗌𝗍 (𝗋𝖾𝖿 ht)	
+|	𝟶𝚡𝙵𝙱  21:𝚞𝟹𝟸  ht:𝚑𝚎𝚊𝚙𝚝𝚢𝚙𝚎		⇒		𝗋𝖾𝖿.𝗍𝖾𝗌𝗍 (𝗋𝖾𝖿 𝗇𝗎𝗅𝗅 ht)	
+|	𝟶𝚡𝙵𝙱  22:𝚞𝟹𝟸  ht:𝚑𝚎𝚊𝚙𝚝𝚢𝚙𝚎		⇒		𝗋𝖾𝖿.𝖼𝖺𝗌𝗍 (𝗋𝖾𝖿 ht)	
+|	𝟶𝚡𝙵𝙱  23:𝚞𝟹𝟸  ht:𝚑𝚎𝚊𝚙𝚝𝚢𝚙𝚎		⇒		𝗋𝖾𝖿.𝖼𝖺𝗌𝗍 (𝗋𝖾𝖿 𝗇𝗎𝗅𝗅 ht)	
+ 
+ 
+Aggregate Instructions
+Aggregate instructions all use a prefix.
+
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝙵𝙱  0:𝚞𝟹𝟸  𝑥:𝚝𝚢𝚙𝚎𝚒𝚍𝚡		⇒		𝗌𝗍𝗋𝗎𝖼𝗍.𝗇𝖾𝗐 𝑥	
+|	𝟶𝚡𝙵𝙱  1:𝚞𝟹𝟸  𝑥:𝚝𝚢𝚙𝚎𝚒𝚍𝚡		⇒		𝗌𝗍𝗋𝗎𝖼𝗍.𝗇𝖾𝗐_𝖽𝖾𝖿𝖺𝗎𝗅𝗍 𝑥	
+|	𝟶𝚡𝙵𝙱  2:𝚞𝟹𝟸  𝑥:𝚝𝚢𝚙𝚎𝚒𝚍𝚡  𝑖:𝚞𝟹𝟸		⇒		𝗌𝗍𝗋𝗎𝖼𝗍.𝗀𝖾𝗍 𝑥 𝑖	
+|	𝟶𝚡𝙵𝙱  3:𝚞𝟹𝟸  𝑥:𝚝𝚢𝚙𝚎𝚒𝚍𝚡  𝑖:𝚞𝟹𝟸		⇒		𝗌𝗍𝗋𝗎𝖼𝗍.𝗀𝖾𝗍_𝗌 𝑥 𝑖	
+|	𝟶𝚡𝙵𝙱  4:𝚞𝟹𝟸  𝑥:𝚝𝚢𝚙𝚎𝚒𝚍𝚡  𝑖:𝚞𝟹𝟸		⇒		𝗌𝗍𝗋𝗎𝖼𝗍.𝗀𝖾𝗍_𝗎 𝑥 𝑖	
+|	𝟶𝚡𝙵𝙱  5:𝚞𝟹𝟸  𝑥:𝚝𝚢𝚙𝚎𝚒𝚍𝚡  𝑖:𝚞𝟹𝟸		⇒		𝗌𝗍𝗋𝗎𝖼𝗍.𝗌𝖾𝗍 𝑥 𝑖	
+|	𝟶𝚡𝙵𝙱  6:𝚞𝟹𝟸  𝑥:𝚝𝚢𝚙𝚎𝚒𝚍𝚡		⇒		𝖺𝗋𝗋𝖺𝗒.𝗇𝖾𝗐 𝑥	
+|	𝟶𝚡𝙵𝙱  7:𝚞𝟹𝟸  𝑥:𝚝𝚢𝚙𝚎𝚒𝚍𝚡		⇒		𝖺𝗋𝗋𝖺𝗒.𝗇𝖾𝗐_𝖽𝖾𝖿𝖺𝗎𝗅𝗍 𝑥	
+|	𝟶𝚡𝙵𝙱  8:𝚞𝟹𝟸  𝑥:𝚝𝚢𝚙𝚎𝚒𝚍𝚡  𝑛:𝚞𝟹𝟸		⇒		𝖺𝗋𝗋𝖺𝗒.𝗇𝖾𝗐_𝖿𝗂𝗑𝖾𝖽 𝑥 𝑛	
+|	𝟶𝚡𝙵𝙱  9:𝚞𝟹𝟸  𝑥:𝚝𝚢𝚙𝚎𝚒𝚍𝚡  𝑦:𝚍𝚊𝚝𝚊𝚒𝚍𝚡		⇒		𝖺𝗋𝗋𝖺𝗒.𝗇𝖾𝗐_𝖽𝖺𝗍𝖺 𝑥 𝑦	
+|	𝟶𝚡𝙵𝙱  10:𝚞𝟹𝟸  𝑥:𝚝𝚢𝚙𝚎𝚒𝚍𝚡  𝑦:𝚎𝚕𝚎𝚖𝚒𝚍𝚡		⇒		𝖺𝗋𝗋𝖺𝗒.𝗇𝖾𝗐_𝖾𝗅𝖾𝗆 𝑥 𝑦	
+|	𝟶𝚡𝙵𝙱  11:𝚞𝟹𝟸  𝑥:𝚝𝚢𝚙𝚎𝚒𝚍𝚡		⇒		𝖺𝗋𝗋𝖺𝗒.𝗀𝖾𝗍 𝑥	
+|	𝟶𝚡𝙵𝙱  12:𝚞𝟹𝟸  𝑥:𝚝𝚢𝚙𝚎𝚒𝚍𝚡		⇒		𝖺𝗋𝗋𝖺𝗒.𝗀𝖾𝗍_𝗌 𝑥	
+|	𝟶𝚡𝙵𝙱  13:𝚞𝟹𝟸  𝑥:𝚝𝚢𝚙𝚎𝚒𝚍𝚡		⇒		𝖺𝗋𝗋𝖺𝗒.𝗀𝖾𝗍_𝗎 𝑥	
+|	𝟶𝚡𝙵𝙱  14:𝚞𝟹𝟸  𝑥:𝚝𝚢𝚙𝚎𝚒𝚍𝚡		⇒		𝖺𝗋𝗋𝖺𝗒.𝗌𝖾𝗍 𝑥	
+|	𝟶𝚡𝙵𝙱  15:𝚞𝟹𝟸		⇒		𝖺𝗋𝗋𝖺𝗒.𝗅𝖾𝗇	
+|	𝟶𝚡𝙵𝙱  16:𝚞𝟹𝟸  𝑥:𝚝𝚢𝚙𝚎𝚒𝚍𝚡		⇒		𝖺𝗋𝗋𝖺𝗒.𝖿𝗂𝗅𝗅 𝑥	
+|	𝟶𝚡𝙵𝙱  17:𝚞𝟹𝟸  𝑥1:𝚝𝚢𝚙𝚎𝚒𝚍𝚡  𝑥2:𝚝𝚢𝚙𝚎𝚒𝚍𝚡		⇒		𝖺𝗋𝗋𝖺𝗒.𝖼𝗈𝗉𝗒 𝑥1 𝑥2	
+|	𝟶𝚡𝙵𝙱  18:𝚞𝟹𝟸  𝑥:𝚝𝚢𝚙𝚎𝚒𝚍𝚡  𝑦:𝚍𝚊𝚝𝚊𝚒𝚍𝚡		⇒		𝖺𝗋𝗋𝖺𝗒.𝗂𝗇𝗂𝗍_𝖽𝖺𝗍𝖺 𝑥 𝑦	
+|	𝟶𝚡𝙵𝙱  19:𝚞𝟹𝟸  𝑥:𝚝𝚢𝚙𝚎𝚒𝚍𝚡  𝑦:𝚎𝚕𝚎𝚖𝚒𝚍𝚡		⇒		𝖺𝗋𝗋𝖺𝗒.𝗂𝗇𝗂𝗍_𝖾𝗅𝖾𝗆 𝑥 𝑦	
+|	𝟶𝚡𝙵𝙱  26:𝚞𝟹𝟸		⇒		𝖺𝗇𝗒.𝖼𝗈𝗇𝗏𝖾𝗋𝗍_𝖾𝗑𝗍𝖾𝗋𝗇	
+|	𝟶𝚡𝙵𝙱  27:𝚞𝟹𝟸		⇒		𝖾𝗑𝗍𝖾𝗋𝗇.𝖼𝗈𝗇𝗏𝖾𝗋𝗍_𝖺𝗇𝗒	
+|	𝟶𝚡𝙵𝙱  28:𝚞𝟹𝟸		⇒		𝗋𝖾𝖿.𝗂𝟥𝟣	
+|	𝟶𝚡𝙵𝙱  29:𝚞𝟹𝟸		⇒		𝗂𝟥𝟣.𝗀𝖾𝗍_𝗌	
+|	𝟶𝚡𝙵𝙱  30:𝚞𝟹𝟸		⇒		𝗂𝟥𝟣.𝗀𝖾𝗍_𝗎	
+ 
+ 
+Numeric Instructions
+All variants of numeric instructions are represented by separate byte codes.
+
+The 𝖼𝗈𝗇𝗌𝗍 instructions are followed by the respective literal.
+
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝟺𝟷  𝑖:𝚒𝟹𝟸		⇒		𝗂𝟥𝟤.𝖼𝗈𝗇𝗌𝗍 𝑖	
+|	𝟶𝚡𝟺𝟸  𝑖:𝚒𝟼𝟺		⇒		𝗂𝟨𝟦.𝖼𝗈𝗇𝗌𝗍 𝑖	
+|	𝟶𝚡𝟺𝟹  𝑝:𝚏𝟹𝟸		⇒		𝖿𝟥𝟤.𝖼𝗈𝗇𝗌𝗍 𝑝	
+|	𝟶𝚡𝟺𝟺  𝑝:𝚏𝟼𝟺		⇒		𝖿𝟨𝟦.𝖼𝗈𝗇𝗌𝗍 𝑝	
+ 
+ 
+All other numeric instructions are plain opcodes without any immediates.
+
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝟺𝟻		⇒		𝗂𝟥𝟤.𝖾𝗊𝗓	
+|	𝟶𝚡𝟺𝟼		⇒		𝗂𝟥𝟤.𝖾𝗊	
+|	𝟶𝚡𝟺𝟽		⇒		𝗂𝟥𝟤.𝗇𝖾	
+|	𝟶𝚡𝟺𝟾		⇒		𝗂𝟥𝟤.𝗅𝗍_𝗌	
+|	𝟶𝚡𝟺𝟿		⇒		𝗂𝟥𝟤.𝗅𝗍_𝗎	
+|	𝟶𝚡𝟺𝙰		⇒		𝗂𝟥𝟤.𝗀𝗍_𝗌	
+|	𝟶𝚡𝟺𝙱		⇒		𝗂𝟥𝟤.𝗀𝗍_𝗎	
+|	𝟶𝚡𝟺𝙲		⇒		𝗂𝟥𝟤.𝗅𝖾_𝗌	
+|	𝟶𝚡𝟺𝙳		⇒		𝗂𝟥𝟤.𝗅𝖾_𝗎	
+|	𝟶𝚡𝟺𝙴		⇒		𝗂𝟥𝟤.𝗀𝖾_𝗌	
+|	𝟶𝚡𝟺𝙵		⇒		𝗂𝟥𝟤.𝗀𝖾_𝗎	
+|	𝟶𝚡𝟻𝟶		⇒		𝗂𝟨𝟦.𝖾𝗊𝗓	
+|	𝟶𝚡𝟻𝟷		⇒		𝗂𝟨𝟦.𝖾𝗊	
+|	𝟶𝚡𝟻𝟸		⇒		𝗂𝟨𝟦.𝗇𝖾	
+|	𝟶𝚡𝟻𝟹		⇒		𝗂𝟨𝟦.𝗅𝗍_𝗌	
+|	𝟶𝚡𝟻𝟺		⇒		𝗂𝟨𝟦.𝗅𝗍_𝗎	
+|	𝟶𝚡𝟻𝟻		⇒		𝗂𝟨𝟦.𝗀𝗍_𝗌	
+|	𝟶𝚡𝟻𝟼		⇒		𝗂𝟨𝟦.𝗀𝗍_𝗎	
+|	𝟶𝚡𝟻𝟽		⇒		𝗂𝟨𝟦.𝗅𝖾_𝗌	
+|	𝟶𝚡𝟻𝟾		⇒		𝗂𝟨𝟦.𝗅𝖾_𝗎	
+|	𝟶𝚡𝟻𝟿		⇒		𝗂𝟨𝟦.𝗀𝖾_𝗌	
+|	𝟶𝚡𝟻𝙰		⇒		𝗂𝟨𝟦.𝗀𝖾_𝗎	
+ 
+ 
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝟻𝙱		⇒		𝖿𝟥𝟤.𝖾𝗊	
+|	𝟶𝚡𝟻𝙲		⇒		𝖿𝟥𝟤.𝗇𝖾	
+|	𝟶𝚡𝟻𝙳		⇒		𝖿𝟥𝟤.𝗅𝗍	
+|	𝟶𝚡𝟻𝙴		⇒		𝖿𝟥𝟤.𝗀𝗍	
+|	𝟶𝚡𝟻𝙵		⇒		𝖿𝟥𝟤.𝗅𝖾	
+|	𝟶𝚡𝟼𝟶		⇒		𝖿𝟥𝟤.𝗀𝖾	
+|	𝟶𝚡𝟼𝟷		⇒		𝖿𝟨𝟦.𝖾𝗊	
+|	𝟶𝚡𝟼𝟸		⇒		𝖿𝟨𝟦.𝗇𝖾	
+|	𝟶𝚡𝟼𝟹		⇒		𝖿𝟨𝟦.𝗅𝗍	
+|	𝟶𝚡𝟼𝟺		⇒		𝖿𝟨𝟦.𝗀𝗍	
+|	𝟶𝚡𝟼𝟻		⇒		𝖿𝟨𝟦.𝗅𝖾	
+|	𝟶𝚡𝟼𝟼		⇒		𝖿𝟨𝟦.𝗀𝖾	
+ 
+ 
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝟼𝟽		⇒		𝗂𝟥𝟤.𝖼𝗅𝗓	
+|	𝟶𝚡𝟼𝟾		⇒		𝗂𝟥𝟤.𝖼𝗍𝗓	
+|	𝟶𝚡𝟼𝟿		⇒		𝗂𝟥𝟤.𝗉𝗈𝗉𝖼𝗇𝗍	
+|	𝟶𝚡𝟼𝙰		⇒		𝗂𝟥𝟤.𝖺𝖽𝖽	
+|	𝟶𝚡𝟼𝙱		⇒		𝗂𝟥𝟤.𝗌𝗎𝖻	
+|	𝟶𝚡𝟼𝙲		⇒		𝗂𝟥𝟤.𝗆𝗎𝗅	
+|	𝟶𝚡𝟼𝙳		⇒		𝗂𝟥𝟤.𝖽𝗂𝗏_𝗌	
+|	𝟶𝚡𝟼𝙴		⇒		𝗂𝟥𝟤.𝖽𝗂𝗏_𝗎	
+|	𝟶𝚡𝟼𝙵		⇒		𝗂𝟥𝟤.𝗋𝖾𝗆_𝗌	
+|	𝟶𝚡𝟽𝟶		⇒		𝗂𝟥𝟤.𝗋𝖾𝗆_𝗎	
+|	𝟶𝚡𝟽𝟷		⇒		𝗂𝟥𝟤.𝖺𝗇𝖽	
+|	𝟶𝚡𝟽𝟸		⇒		𝗂𝟥𝟤.𝗈𝗋	
+|	𝟶𝚡𝟽𝟹		⇒		𝗂𝟥𝟤.𝗑𝗈𝗋	
+|	𝟶𝚡𝟽𝟺		⇒		𝗂𝟥𝟤.𝗌𝗁𝗅	
+|	𝟶𝚡𝟽𝟻		⇒		𝗂𝟥𝟤.𝗌𝗁𝗋_𝗌	
+|	𝟶𝚡𝟽𝟼		⇒		𝗂𝟥𝟤.𝗌𝗁𝗋_𝗎	
+|	𝟶𝚡𝟽𝟽		⇒		𝗂𝟥𝟤.𝗋𝗈𝗍𝗅	
+|	𝟶𝚡𝟽𝟾		⇒		𝗂𝟥𝟤.𝗋𝗈𝗍𝗋	
+|	𝟶𝚡𝟽𝟿		⇒		𝗂𝟨𝟦.𝖼𝗅𝗓	
+|	𝟶𝚡𝟽𝙰		⇒		𝗂𝟨𝟦.𝖼𝗍𝗓	
+|	𝟶𝚡𝟽𝙱		⇒		𝗂𝟨𝟦.𝗉𝗈𝗉𝖼𝗇𝗍	
+|	𝟶𝚡𝟽𝙲		⇒		𝗂𝟨𝟦.𝖺𝖽𝖽	
+|	𝟶𝚡𝟽𝙳		⇒		𝗂𝟨𝟦.𝗌𝗎𝖻	
+|	𝟶𝚡𝟽𝙴		⇒		𝗂𝟨𝟦.𝗆𝗎𝗅	
+|	𝟶𝚡𝟽𝙵		⇒		𝗂𝟨𝟦.𝖽𝗂𝗏_𝗌	
+|	𝟶𝚡𝟾𝟶		⇒		𝗂𝟨𝟦.𝖽𝗂𝗏_𝗎	
+|	𝟶𝚡𝟾𝟷		⇒		𝗂𝟨𝟦.𝗋𝖾𝗆_𝗌	
+|	𝟶𝚡𝟾𝟸		⇒		𝗂𝟨𝟦.𝗋𝖾𝗆_𝗎	
+|	𝟶𝚡𝟾𝟹		⇒		𝗂𝟨𝟦.𝖺𝗇𝖽	
+|	𝟶𝚡𝟾𝟺		⇒		𝗂𝟨𝟦.𝗈𝗋	
+|	𝟶𝚡𝟾𝟻		⇒		𝗂𝟨𝟦.𝗑𝗈𝗋	
+|	𝟶𝚡𝟾𝟼		⇒		𝗂𝟨𝟦.𝗌𝗁𝗅	
+|	𝟶𝚡𝟾𝟽		⇒		𝗂𝟨𝟦.𝗌𝗁𝗋_𝗌	
+|	𝟶𝚡𝟾𝟾		⇒		𝗂𝟨𝟦.𝗌𝗁𝗋_𝗎	
+|	𝟶𝚡𝟾𝟿		⇒		𝗂𝟨𝟦.𝗋𝗈𝗍𝗅	
+|	𝟶𝚡𝟾𝙰		⇒		𝗂𝟨𝟦.𝗋𝗈𝗍𝗋	
+ 
+ 
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝟾𝙱		⇒		𝖿𝟥𝟤.𝖺𝖻𝗌	
+|	𝟶𝚡𝟾𝙲		⇒		𝖿𝟥𝟤.𝗇𝖾𝗀	
+|	𝟶𝚡𝟾𝙳		⇒		𝖿𝟥𝟤.𝖼𝖾𝗂𝗅	
+|	𝟶𝚡𝟾𝙴		⇒		𝖿𝟥𝟤.𝖿𝗅𝗈𝗈𝗋	
+|	𝟶𝚡𝟾𝙵		⇒		𝖿𝟥𝟤.𝗍𝗋𝗎𝗇𝖼	
+|	𝟶𝚡𝟿𝟶		⇒		𝖿𝟥𝟤.𝗇𝖾𝖺𝗋𝖾𝗌𝗍	
+|	𝟶𝚡𝟿𝟷		⇒		𝖿𝟥𝟤.𝗌𝗊𝗋𝗍	
+|	𝟶𝚡𝟿𝟸		⇒		𝖿𝟥𝟤.𝖺𝖽𝖽	
+|	𝟶𝚡𝟿𝟹		⇒		𝖿𝟥𝟤.𝗌𝗎𝖻	
+|	𝟶𝚡𝟿𝟺		⇒		𝖿𝟥𝟤.𝗆𝗎𝗅	
+|	𝟶𝚡𝟿𝟻		⇒		𝖿𝟥𝟤.𝖽𝗂𝗏	
+|	𝟶𝚡𝟿𝟼		⇒		𝖿𝟥𝟤.𝗆𝗂𝗇	
+|	𝟶𝚡𝟿𝟽		⇒		𝖿𝟥𝟤.𝗆𝖺𝗑	
+|	𝟶𝚡𝟿𝟾		⇒		𝖿𝟥𝟤.𝖼𝗈𝗉𝗒𝗌𝗂𝗀𝗇	
+|	𝟶𝚡𝟿𝟿		⇒		𝖿𝟨𝟦.𝖺𝖻𝗌	
+|	𝟶𝚡𝟿𝙰		⇒		𝖿𝟨𝟦.𝗇𝖾𝗀	
+|	𝟶𝚡𝟿𝙱		⇒		𝖿𝟨𝟦.𝖼𝖾𝗂𝗅	
+|	𝟶𝚡𝟿𝙲		⇒		𝖿𝟨𝟦.𝖿𝗅𝗈𝗈𝗋	
+|	𝟶𝚡𝟿𝙳		⇒		𝖿𝟨𝟦.𝗍𝗋𝗎𝗇𝖼	
+|	𝟶𝚡𝟿𝙴		⇒		𝖿𝟨𝟦.𝗇𝖾𝖺𝗋𝖾𝗌𝗍	
+|	𝟶𝚡𝟿𝙵		⇒		𝖿𝟨𝟦.𝗌𝗊𝗋𝗍	
+|	𝟶𝚡𝙰𝟶		⇒		𝖿𝟨𝟦.𝖺𝖽𝖽	
+|	𝟶𝚡𝙰𝟷		⇒		𝖿𝟨𝟦.𝗌𝗎𝖻	
+|	𝟶𝚡𝙰𝟸		⇒		𝖿𝟨𝟦.𝗆𝗎𝗅	
+|	𝟶𝚡𝙰𝟹		⇒		𝖿𝟨𝟦.𝖽𝗂𝗏	
+|	𝟶𝚡𝙰𝟺		⇒		𝖿𝟨𝟦.𝗆𝗂𝗇	
+|	𝟶𝚡𝙰𝟻		⇒		𝖿𝟨𝟦.𝗆𝖺𝗑	
+|	𝟶𝚡𝙰𝟼		⇒		𝖿𝟨𝟦.𝖼𝗈𝗉𝗒𝗌𝗂𝗀𝗇	
+ 
+ 
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝙰𝟽		⇒		𝗂𝟥𝟤.𝗐𝗋𝖺𝗉_𝗂𝟨𝟦	
+|	𝟶𝚡𝙰𝟾		⇒		𝗂𝟥𝟤.𝗍𝗋𝗎𝗇𝖼_𝗌_𝖿𝟥𝟤	
+|	𝟶𝚡𝙰𝟿		⇒		𝗂𝟥𝟤.𝗍𝗋𝗎𝗇𝖼_𝗎_𝖿𝟥𝟤	
+|	𝟶𝚡𝙰𝙰		⇒		𝗂𝟥𝟤.𝗍𝗋𝗎𝗇𝖼_𝗌_𝖿𝟨𝟦	
+|	𝟶𝚡𝙰𝙱		⇒		𝗂𝟥𝟤.𝗍𝗋𝗎𝗇𝖼_𝗎_𝖿𝟨𝟦	
+|	𝟶𝚡𝙰𝙲		⇒		𝗂𝟨𝟦.𝖾𝗑𝗍𝖾𝗇𝖽_𝗌_𝗂𝟥𝟤	
+|	𝟶𝚡𝙰𝙳		⇒		𝗂𝟨𝟦.𝖾𝗑𝗍𝖾𝗇𝖽_𝗎_𝗂𝟥𝟤	
+|	𝟶𝚡𝙰𝙴		⇒		𝗂𝟨𝟦.𝗍𝗋𝗎𝗇𝖼_𝗌_𝖿𝟥𝟤	
+|	𝟶𝚡𝙰𝙵		⇒		𝗂𝟨𝟦.𝗍𝗋𝗎𝗇𝖼_𝗎_𝖿𝟥𝟤	
+|	𝟶𝚡𝙱𝟶		⇒		𝗂𝟨𝟦.𝗍𝗋𝗎𝗇𝖼_𝗌_𝖿𝟨𝟦	
+|	𝟶𝚡𝙱𝟷		⇒		𝗂𝟨𝟦.𝗍𝗋𝗎𝗇𝖼_𝗎_𝖿𝟨𝟦	
+|	𝟶𝚡𝙱𝟸		⇒		𝖿𝟥𝟤.𝖼𝗈𝗇𝗏𝖾𝗋𝗍_𝗌_𝗂𝟥𝟤	
+|	𝟶𝚡𝙱𝟹		⇒		𝖿𝟥𝟤.𝖼𝗈𝗇𝗏𝖾𝗋𝗍_𝗎_𝗂𝟥𝟤	
+|	𝟶𝚡𝙱𝟺		⇒		𝖿𝟥𝟤.𝖼𝗈𝗇𝗏𝖾𝗋𝗍_𝗌_𝗂𝟨𝟦	
+|	𝟶𝚡𝙱𝟻		⇒		𝖿𝟥𝟤.𝖼𝗈𝗇𝗏𝖾𝗋𝗍_𝗎_𝗂𝟨𝟦	
+|	𝟶𝚡𝙱𝟼		⇒		𝖿𝟥𝟤.𝖽𝖾𝗆𝗈𝗍𝖾_𝖿𝟨𝟦	
+|	𝟶𝚡𝙱𝟽		⇒		𝖿𝟨𝟦.𝖼𝗈𝗇𝗏𝖾𝗋𝗍_𝗌_𝗂𝟥𝟤	
+|	𝟶𝚡𝙱𝟾		⇒		𝖿𝟨𝟦.𝖼𝗈𝗇𝗏𝖾𝗋𝗍_𝗎_𝗂𝟥𝟤	
+|	𝟶𝚡𝙱𝟿		⇒		𝖿𝟨𝟦.𝖼𝗈𝗇𝗏𝖾𝗋𝗍_𝗌_𝗂𝟨𝟦	
+|	𝟶𝚡𝙱𝙰		⇒		𝖿𝟨𝟦.𝖼𝗈𝗇𝗏𝖾𝗋𝗍_𝗎_𝗂𝟨𝟦	
+|	𝟶𝚡𝙱𝙱		⇒		𝖿𝟨𝟦.𝗉𝗋𝗈𝗆𝗈𝗍𝖾_𝖿𝟥𝟤	
+|	𝟶𝚡𝙱𝙲		⇒		𝗂𝟥𝟤.𝗋𝖾𝗂𝗇𝗍𝖾𝗋𝗉𝗋𝖾𝗍_𝖿𝟥𝟤	
+|	𝟶𝚡𝙱𝙳		⇒		𝗂𝟨𝟦.𝗋𝖾𝗂𝗇𝗍𝖾𝗋𝗉𝗋𝖾𝗍_𝖿𝟨𝟦	
+|	𝟶𝚡𝙱𝙴		⇒		𝖿𝟥𝟤.𝗋𝖾𝗂𝗇𝗍𝖾𝗋𝗉𝗋𝖾𝗍_𝗂𝟥𝟤	
+|	𝟶𝚡𝙱𝙵		⇒		𝖿𝟨𝟦.𝗋𝖾𝗂𝗇𝗍𝖾𝗋𝗉𝗋𝖾𝗍_𝗂𝟨𝟦	
+ 
+ 
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝙲𝟶		⇒		𝗂𝟥𝟤.𝖾𝗑𝗍𝖾𝗇𝖽𝟪_𝗌	
+|	𝟶𝚡𝙲𝟷		⇒		𝗂𝟥𝟤.𝖾𝗑𝗍𝖾𝗇𝖽𝟣𝟨_𝗌	
+|	𝟶𝚡𝙲𝟸		⇒		𝗂𝟨𝟦.𝖾𝗑𝗍𝖾𝗇𝖽𝟪_𝗌	
+|	𝟶𝚡𝙲𝟹		⇒		𝗂𝟨𝟦.𝖾𝗑𝗍𝖾𝗇𝖽𝟣𝟨_𝗌	
+|	𝟶𝚡𝙲𝟺		⇒		𝗂𝟨𝟦.𝖾𝗑𝗍𝖾𝗇𝖽𝟥𝟤_𝗌	
+ 
+ 
+The saturating truncation instructions all have a one byte prefix, whereas the actual opcode is encoded by a variable-length unsigned integer.
+
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝙵𝙲  0:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤.𝗍𝗋𝗎𝗇𝖼_𝗌𝖺𝗍_𝗌_𝖿𝟥𝟤	
+|	𝟶𝚡𝙵𝙲  1:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤.𝗍𝗋𝗎𝗇𝖼_𝗌𝖺𝗍_𝗎_𝖿𝟥𝟤	
+|	𝟶𝚡𝙵𝙲  2:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤.𝗍𝗋𝗎𝗇𝖼_𝗌𝖺𝗍_𝗌_𝖿𝟨𝟦	
+|	𝟶𝚡𝙵𝙲  3:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤.𝗍𝗋𝗎𝗇𝖼_𝗌𝖺𝗍_𝗎_𝖿𝟨𝟦	
+|	𝟶𝚡𝙵𝙲  4:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦.𝗍𝗋𝗎𝗇𝖼_𝗌𝖺𝗍_𝗌_𝖿𝟥𝟤	
+|	𝟶𝚡𝙵𝙲  5:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦.𝗍𝗋𝗎𝗇𝖼_𝗌𝖺𝗍_𝗎_𝖿𝟥𝟤	
+|	𝟶𝚡𝙵𝙲  6:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦.𝗍𝗋𝗎𝗇𝖼_𝗌𝖺𝗍_𝗌_𝖿𝟨𝟦	
+|	𝟶𝚡𝙵𝙲  7:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦.𝗍𝗋𝗎𝗇𝖼_𝗌𝖺𝗍_𝗎_𝖿𝟨𝟦	
+ 
+ 
+Vector Instructions
+All variants of vector instructions are represented by separate byte codes. They all have a one byte prefix, whereas the actual opcode is encoded by a variable-length unsigned integer.
+
+Vector loads and stores are followed by the encoding of their memarg immediate.
+
+𝚕𝚊𝚗𝚎𝚒𝚍𝚡	::=	𝑙:𝚋𝚢𝚝𝚎		⇒		𝑙	
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝙵𝙳  0:𝚞𝟹𝟸  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗏𝟣𝟤𝟪.𝗅𝗈𝖺𝖽 𝑥 ao	
+|	𝟶𝚡𝙵𝙳  1:𝚞𝟹𝟸  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗏𝟣𝟤𝟪.𝗅𝗈𝖺𝖽𝟪𝗑𝟪_𝗌 𝑥 ao	
+|	𝟶𝚡𝙵𝙳  2:𝚞𝟹𝟸  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗏𝟣𝟤𝟪.𝗅𝗈𝖺𝖽𝟪𝗑𝟪_𝗎 𝑥 ao	
+|	𝟶𝚡𝙵𝙳  3:𝚞𝟹𝟸  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗏𝟣𝟤𝟪.𝗅𝗈𝖺𝖽𝟣𝟨𝗑𝟦_𝗌 𝑥 ao	
+|	𝟶𝚡𝙵𝙳  4:𝚞𝟹𝟸  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗏𝟣𝟤𝟪.𝗅𝗈𝖺𝖽𝟣𝟨𝗑𝟦_𝗎 𝑥 ao	
+|	𝟶𝚡𝙵𝙳  5:𝚞𝟹𝟸  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗏𝟣𝟤𝟪.𝗅𝗈𝖺𝖽𝟥𝟤𝗑𝟤_𝗌 𝑥 ao	
+|	𝟶𝚡𝙵𝙳  6:𝚞𝟹𝟸  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗏𝟣𝟤𝟪.𝗅𝗈𝖺𝖽𝟥𝟤𝗑𝟤_𝗎 𝑥 ao	
+|	𝟶𝚡𝙵𝙳  7:𝚞𝟹𝟸  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗏𝟣𝟤𝟪.𝗅𝗈𝖺𝖽𝟪_𝗌𝗉𝗅𝖺𝗍 𝑥 ao	
+|	𝟶𝚡𝙵𝙳  8:𝚞𝟹𝟸  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗏𝟣𝟤𝟪.𝗅𝗈𝖺𝖽𝟣𝟨_𝗌𝗉𝗅𝖺𝗍 𝑥 ao	
+|	𝟶𝚡𝙵𝙳  9:𝚞𝟹𝟸  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗏𝟣𝟤𝟪.𝗅𝗈𝖺𝖽𝟥𝟤_𝗌𝗉𝗅𝖺𝗍 𝑥 ao	
+|	𝟶𝚡𝙵𝙳  10:𝚞𝟹𝟸  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗏𝟣𝟤𝟪.𝗅𝗈𝖺𝖽𝟨𝟦_𝗌𝗉𝗅𝖺𝗍 𝑥 ao	
+|	𝟶𝚡𝙵𝙳  11:𝚞𝟹𝟸  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗏𝟣𝟤𝟪.𝗌𝗍𝗈𝗋𝖾 𝑥 ao	
+|	𝟶𝚡𝙵𝙳  84:𝚞𝟹𝟸  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐  𝑖:𝚕𝚊𝚗𝚎𝚒𝚍𝚡		⇒		𝗏𝟣𝟤𝟪.𝗅𝗈𝖺𝖽𝟪_𝗅𝖺𝗇𝖾 𝑥 ao 𝑖	
+|	𝟶𝚡𝙵𝙳  85:𝚞𝟹𝟸  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐  𝑖:𝚕𝚊𝚗𝚎𝚒𝚍𝚡		⇒		𝗏𝟣𝟤𝟪.𝗅𝗈𝖺𝖽𝟣𝟨_𝗅𝖺𝗇𝖾 𝑥 ao 𝑖	
+|	𝟶𝚡𝙵𝙳  86:𝚞𝟹𝟸  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐  𝑖:𝚕𝚊𝚗𝚎𝚒𝚍𝚡		⇒		𝗏𝟣𝟤𝟪.𝗅𝗈𝖺𝖽𝟥𝟤_𝗅𝖺𝗇𝖾 𝑥 ao 𝑖	
+|	𝟶𝚡𝙵𝙳  87:𝚞𝟹𝟸  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐  𝑖:𝚕𝚊𝚗𝚎𝚒𝚍𝚡		⇒		𝗏𝟣𝟤𝟪.𝗅𝗈𝖺𝖽𝟨𝟦_𝗅𝖺𝗇𝖾 𝑥 ao 𝑖	
+|	𝟶𝚡𝙵𝙳  88:𝚞𝟹𝟸  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐  𝑖:𝚕𝚊𝚗𝚎𝚒𝚍𝚡		⇒		𝗏𝟣𝟤𝟪.𝗌𝗍𝗈𝗋𝖾𝟪_𝗅𝖺𝗇𝖾 𝑥 ao 𝑖	
+|	𝟶𝚡𝙵𝙳  89:𝚞𝟹𝟸  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐  𝑖:𝚕𝚊𝚗𝚎𝚒𝚍𝚡		⇒		𝗏𝟣𝟤𝟪.𝗌𝗍𝗈𝗋𝖾𝟣𝟨_𝗅𝖺𝗇𝖾 𝑥 ao 𝑖	
+|	𝟶𝚡𝙵𝙳  90:𝚞𝟹𝟸  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐  𝑖:𝚕𝚊𝚗𝚎𝚒𝚍𝚡		⇒		𝗏𝟣𝟤𝟪.𝗌𝗍𝗈𝗋𝖾𝟥𝟤_𝗅𝖺𝗇𝖾 𝑥 ao 𝑖	
+|	𝟶𝚡𝙵𝙳  91:𝚞𝟹𝟸  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐  𝑖:𝚕𝚊𝚗𝚎𝚒𝚍𝚡		⇒		𝗏𝟣𝟤𝟪.𝗌𝗍𝗈𝗋𝖾𝟨𝟦_𝗅𝖺𝗇𝖾 𝑥 ao 𝑖	
+|	𝟶𝚡𝙵𝙳  92:𝚞𝟹𝟸  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗏𝟣𝟤𝟪.𝗅𝗈𝖺𝖽𝟥𝟤_𝗓𝖾𝗋𝗈 𝑥 ao	
+|	𝟶𝚡𝙵𝙳  93:𝚞𝟹𝟸  (𝑥,ao):𝚖𝚎𝚖𝚊𝚛𝚐		⇒		𝗏𝟣𝟤𝟪.𝗅𝗈𝖺𝖽𝟨𝟦_𝗓𝖾𝗋𝗈 𝑥 ao	
+ 
+ 
+The 𝖼𝗈𝗇𝗌𝗍 instruction for vectors is followed by 16 immediate bytes, which are converted into an u128 in littleendian byte order:
+
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝙵𝙳  12:𝚞𝟹𝟸  (𝑏:𝚋𝚢𝚝𝚎)16		⇒		𝗏𝟣𝟤𝟪.𝖼𝗈𝗇𝗌𝗍 bytes−1
+𝗂𝟣𝟤𝟪((𝑏)16)	
+ 
+ 
+The 𝗌𝗁𝗎𝖿𝖿𝗅𝖾 instruction is also followed by the encoding of 16 laneidx immediates.
+
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝙵𝙳  13:𝚞𝟹𝟸  (𝑙:𝚕𝚊𝚗𝚎𝚒𝚍𝚡)16		⇒		𝗂𝟪𝗑𝟣𝟨.𝗌𝗁𝗎𝖿𝖿𝗅𝖾 𝑙16	
+|	𝟶𝚡𝙵𝙳  14:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗌𝗐𝗂𝗓𝗓𝗅𝖾	
+|	𝟶𝚡𝙵𝙳  256:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗋𝖾𝗅𝖺𝗑𝖾𝖽_𝗌𝗐𝗂𝗓𝗓𝗅𝖾	
+ 
+ 
+Lane instructions are followed by the encoding of a laneidx immediate.
+
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝙵𝙳  21:𝚞𝟹𝟸  𝑙:𝚕𝚊𝚗𝚎𝚒𝚍𝚡		⇒		𝗂𝟪𝗑𝟣𝟨.𝖾𝗑𝗍𝗋𝖺𝖼𝗍_𝗅𝖺𝗇𝖾_𝗌 𝑙	
+|	𝟶𝚡𝙵𝙳  22:𝚞𝟹𝟸  𝑙:𝚕𝚊𝚗𝚎𝚒𝚍𝚡		⇒		𝗂𝟪𝗑𝟣𝟨.𝖾𝗑𝗍𝗋𝖺𝖼𝗍_𝗅𝖺𝗇𝖾_𝗎 𝑙	
+|	𝟶𝚡𝙵𝙳  23:𝚞𝟹𝟸  𝑙:𝚕𝚊𝚗𝚎𝚒𝚍𝚡		⇒		𝗂𝟪𝗑𝟣𝟨.𝗋𝖾𝗉𝗅𝖺𝖼𝖾_𝗅𝖺𝗇𝖾 𝑙	
+|	𝟶𝚡𝙵𝙳  24:𝚞𝟹𝟸  𝑙:𝚕𝚊𝚗𝚎𝚒𝚍𝚡		⇒		𝗂𝟣𝟨𝗑𝟪.𝖾𝗑𝗍𝗋𝖺𝖼𝗍_𝗅𝖺𝗇𝖾_𝗌 𝑙	
+|	𝟶𝚡𝙵𝙳  25:𝚞𝟹𝟸  𝑙:𝚕𝚊𝚗𝚎𝚒𝚍𝚡		⇒		𝗂𝟣𝟨𝗑𝟪.𝖾𝗑𝗍𝗋𝖺𝖼𝗍_𝗅𝖺𝗇𝖾_𝗎 𝑙	
+|	𝟶𝚡𝙵𝙳  26:𝚞𝟹𝟸  𝑙:𝚕𝚊𝚗𝚎𝚒𝚍𝚡		⇒		𝗂𝟣𝟨𝗑𝟪.𝗋𝖾𝗉𝗅𝖺𝖼𝖾_𝗅𝖺𝗇𝖾 𝑙	
+|	𝟶𝚡𝙵𝙳  27:𝚞𝟹𝟸  𝑙:𝚕𝚊𝚗𝚎𝚒𝚍𝚡		⇒		𝗂𝟥𝟤𝗑𝟦.𝖾𝗑𝗍𝗋𝖺𝖼𝗍_𝗅𝖺𝗇𝖾 𝑙	
+|	𝟶𝚡𝙵𝙳  28:𝚞𝟹𝟸  𝑙:𝚕𝚊𝚗𝚎𝚒𝚍𝚡		⇒		𝗂𝟥𝟤𝗑𝟦.𝗋𝖾𝗉𝗅𝖺𝖼𝖾_𝗅𝖺𝗇𝖾 𝑙	
+|	𝟶𝚡𝙵𝙳  29:𝚞𝟹𝟸  𝑙:𝚕𝚊𝚗𝚎𝚒𝚍𝚡		⇒		𝗂𝟨𝟦𝗑𝟤.𝖾𝗑𝗍𝗋𝖺𝖼𝗍_𝗅𝖺𝗇𝖾 𝑙	
+|	𝟶𝚡𝙵𝙳  30:𝚞𝟹𝟸  𝑙:𝚕𝚊𝚗𝚎𝚒𝚍𝚡		⇒		𝗂𝟨𝟦𝗑𝟤.𝗋𝖾𝗉𝗅𝖺𝖼𝖾_𝗅𝖺𝗇𝖾 𝑙	
+|	𝟶𝚡𝙵𝙳  31:𝚞𝟹𝟸  𝑙:𝚕𝚊𝚗𝚎𝚒𝚍𝚡		⇒		𝖿𝟥𝟤𝗑𝟦.𝖾𝗑𝗍𝗋𝖺𝖼𝗍_𝗅𝖺𝗇𝖾 𝑙	
+|	𝟶𝚡𝙵𝙳  32:𝚞𝟹𝟸  𝑙:𝚕𝚊𝚗𝚎𝚒𝚍𝚡		⇒		𝖿𝟥𝟤𝗑𝟦.𝗋𝖾𝗉𝗅𝖺𝖼𝖾_𝗅𝖺𝗇𝖾 𝑙	
+|	𝟶𝚡𝙵𝙳  33:𝚞𝟹𝟸  𝑙:𝚕𝚊𝚗𝚎𝚒𝚍𝚡		⇒		𝖿𝟨𝟦𝗑𝟤.𝖾𝗑𝗍𝗋𝖺𝖼𝗍_𝗅𝖺𝗇𝖾 𝑙	
+|	𝟶𝚡𝙵𝙳  34:𝚞𝟹𝟸  𝑙:𝚕𝚊𝚗𝚎𝚒𝚍𝚡		⇒		𝖿𝟨𝟦𝗑𝟤.𝗋𝖾𝗉𝗅𝖺𝖼𝖾_𝗅𝖺𝗇𝖾 𝑙	
+ 
+ 
+All other vector instructions are plain opcodes without any immediates.
+
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝙵𝙳  15:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗌𝗉𝗅𝖺𝗍	
+|	𝟶𝚡𝙵𝙳  16:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗌𝗉𝗅𝖺𝗍	
+|	𝟶𝚡𝙵𝙳  17:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗌𝗉𝗅𝖺𝗍	
+|	𝟶𝚡𝙵𝙳  18:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝗌𝗉𝗅𝖺𝗍	
+|	𝟶𝚡𝙵𝙳  19:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝗌𝗉𝗅𝖺𝗍	
+|	𝟶𝚡𝙵𝙳  20:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝗌𝗉𝗅𝖺𝗍	
+ 
+ 
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝙵𝙳  35:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝖾𝗊	
+|	𝟶𝚡𝙵𝙳  36:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗇𝖾	
+|	𝟶𝚡𝙵𝙳  37:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗅𝗍_𝗌	
+|	𝟶𝚡𝙵𝙳  38:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗅𝗍_𝗎	
+|	𝟶𝚡𝙵𝙳  39:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗀𝗍_𝗌	
+|	𝟶𝚡𝙵𝙳  40:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗀𝗍_𝗎	
+|	𝟶𝚡𝙵𝙳  41:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗅𝖾_𝗌	
+|	𝟶𝚡𝙵𝙳  42:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗅𝖾_𝗎	
+|	𝟶𝚡𝙵𝙳  43:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗀𝖾_𝗌	
+|	𝟶𝚡𝙵𝙳  44:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗀𝖾_𝗎	
+|	𝟶𝚡𝙵𝙳  45:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝖾𝗊	
+|	𝟶𝚡𝙵𝙳  46:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗇𝖾	
+|	𝟶𝚡𝙵𝙳  47:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗅𝗍_𝗌	
+|	𝟶𝚡𝙵𝙳  48:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗅𝗍_𝗎	
+|	𝟶𝚡𝙵𝙳  49:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗀𝗍_𝗌	
+|	𝟶𝚡𝙵𝙳  50:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗀𝗍_𝗎	
+|	𝟶𝚡𝙵𝙳  51:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗅𝖾_𝗌	
+|	𝟶𝚡𝙵𝙳  52:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗅𝖾_𝗎	
+|	𝟶𝚡𝙵𝙳  53:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗀𝖾_𝗌	
+|	𝟶𝚡𝙵𝙳  54:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗀𝖾_𝗎	
+|	𝟶𝚡𝙵𝙳  55:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝖾𝗊	
+|	𝟶𝚡𝙵𝙳  56:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗇𝖾	
+|	𝟶𝚡𝙵𝙳  57:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗅𝗍_𝗌	
+|	𝟶𝚡𝙵𝙳  58:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗅𝗍_𝗎	
+|	𝟶𝚡𝙵𝙳  59:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗀𝗍_𝗌	
+|	𝟶𝚡𝙵𝙳  60:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗀𝗍_𝗎	
+|	𝟶𝚡𝙵𝙳  61:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗅𝖾_𝗌	
+|	𝟶𝚡𝙵𝙳  62:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗅𝖾_𝗎	
+|	𝟶𝚡𝙵𝙳  63:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗀𝖾_𝗌	
+|	𝟶𝚡𝙵𝙳  64:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗀𝖾_𝗎	
+|	𝟶𝚡𝙵𝙳  214:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝖾𝗊	
+|	𝟶𝚡𝙵𝙳  215:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝗇𝖾	
+|	𝟶𝚡𝙵𝙳  216:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝗅𝗍_𝗌	
+|	𝟶𝚡𝙵𝙳  217:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝗀𝗍_𝗌	
+|	𝟶𝚡𝙵𝙳  218:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝗅𝖾_𝗌	
+|	𝟶𝚡𝙵𝙳  219:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝗀𝖾_𝗌	
+ 
+ 
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝙵𝙳  65:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝖾𝗊	
+|	𝟶𝚡𝙵𝙳  66:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝗇𝖾	
+|	𝟶𝚡𝙵𝙳  67:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝗅𝗍	
+|	𝟶𝚡𝙵𝙳  68:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝗀𝗍	
+|	𝟶𝚡𝙵𝙳  69:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝗅𝖾	
+|	𝟶𝚡𝙵𝙳  70:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝗀𝖾	
+|	𝟶𝚡𝙵𝙳  71:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝖾𝗊	
+|	𝟶𝚡𝙵𝙳  72:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝗇𝖾	
+|	𝟶𝚡𝙵𝙳  73:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝗅𝗍	
+|	𝟶𝚡𝙵𝙳  74:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝗀𝗍	
+|	𝟶𝚡𝙵𝙳  75:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝗅𝖾	
+|	𝟶𝚡𝙵𝙳  76:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝗀𝖾	
+ 
+ 
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝙵𝙳  77:𝚞𝟹𝟸		⇒		𝗏𝟣𝟤𝟪.𝗇𝗈𝗍	
+|	𝟶𝚡𝙵𝙳  78:𝚞𝟹𝟸		⇒		𝗏𝟣𝟤𝟪.𝖺𝗇𝖽	
+|	𝟶𝚡𝙵𝙳  79:𝚞𝟹𝟸		⇒		𝗏𝟣𝟤𝟪.𝖺𝗇𝖽𝗇𝗈𝗍	
+|	𝟶𝚡𝙵𝙳  80:𝚞𝟹𝟸		⇒		𝗏𝟣𝟤𝟪.𝗈𝗋	
+|	𝟶𝚡𝙵𝙳  81:𝚞𝟹𝟸		⇒		𝗏𝟣𝟤𝟪.𝗑𝗈𝗋	
+|	𝟶𝚡𝙵𝙳  82:𝚞𝟹𝟸		⇒		𝗏𝟣𝟤𝟪.𝖻𝗂𝗍𝗌𝖾𝗅𝖾𝖼𝗍	
+|	𝟶𝚡𝙵𝙳  83:𝚞𝟹𝟸		⇒		𝗏𝟣𝟤𝟪.𝖺𝗇𝗒_𝗍𝗋𝗎𝖾	
+ 
+ 
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝙵𝙳  96:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝖺𝖻𝗌	
+|	𝟶𝚡𝙵𝙳  97:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗇𝖾𝗀	
+|	𝟶𝚡𝙵𝙳  98:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗉𝗈𝗉𝖼𝗇𝗍	
+|	𝟶𝚡𝙵𝙳  99:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝖺𝗅𝗅_𝗍𝗋𝗎𝖾	
+|	𝟶𝚡𝙵𝙳  100:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝖻𝗂𝗍𝗆𝖺𝗌𝗄	
+|	𝟶𝚡𝙵𝙳  101:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗇𝖺𝗋𝗋𝗈𝗐_𝗂𝟣𝟨𝗑𝟪_𝗌	
+|	𝟶𝚡𝙵𝙳  102:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗇𝖺𝗋𝗋𝗈𝗐_𝗂𝟣𝟨𝗑𝟪_𝗎	
+|	𝟶𝚡𝙵𝙳  107:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗌𝗁𝗅	
+|	𝟶𝚡𝙵𝙳  108:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗌𝗁𝗋_𝗌	
+|	𝟶𝚡𝙵𝙳  109:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗌𝗁𝗋_𝗎	
+|	𝟶𝚡𝙵𝙳  110:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝖺𝖽𝖽	
+|	𝟶𝚡𝙵𝙳  111:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝖺𝖽𝖽_𝗌𝖺𝗍_𝗌	
+|	𝟶𝚡𝙵𝙳  112:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝖺𝖽𝖽_𝗌𝖺𝗍_𝗎	
+|	𝟶𝚡𝙵𝙳  113:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗌𝗎𝖻	
+|	𝟶𝚡𝙵𝙳  114:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗌𝗎𝖻_𝗌𝖺𝗍_𝗌	
+|	𝟶𝚡𝙵𝙳  115:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗌𝗎𝖻_𝗌𝖺𝗍_𝗎	
+|	𝟶𝚡𝙵𝙳  118:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗆𝗂𝗇_𝗌	
+|	𝟶𝚡𝙵𝙳  119:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗆𝗂𝗇_𝗎	
+|	𝟶𝚡𝙵𝙳  120:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗆𝖺𝗑_𝗌	
+|	𝟶𝚡𝙵𝙳  121:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗆𝖺𝗑_𝗎	
+|	𝟶𝚡𝙵𝙳  123:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝖺𝗏𝗀𝗋_𝗎	
+ 
+ 
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝙵𝙳  124:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝖾𝗑𝗍𝖺𝖽𝖽_𝗉𝖺𝗂𝗋𝗐𝗂𝗌𝖾_𝗌_𝗂𝟪𝗑𝟣𝟨	
+|	𝟶𝚡𝙵𝙳  125:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝖾𝗑𝗍𝖺𝖽𝖽_𝗉𝖺𝗂𝗋𝗐𝗂𝗌𝖾_𝗎_𝗂𝟪𝗑𝟣𝟨	
+|	𝟶𝚡𝙵𝙳  128:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝖺𝖻𝗌	
+|	𝟶𝚡𝙵𝙳  129:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗇𝖾𝗀	
+|	𝟶𝚡𝙵𝙳  131:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝖺𝗅𝗅_𝗍𝗋𝗎𝖾	
+|	𝟶𝚡𝙵𝙳  132:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝖻𝗂𝗍𝗆𝖺𝗌𝗄	
+|	𝟶𝚡𝙵𝙳  133:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗇𝖺𝗋𝗋𝗈𝗐_𝗂𝟥𝟤𝗑𝟦_𝗌	
+|	𝟶𝚡𝙵𝙳  134:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗇𝖺𝗋𝗋𝗈𝗐_𝗂𝟥𝟤𝗑𝟦_𝗎	
+|	𝟶𝚡𝙵𝙳  135:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝖾𝗑𝗍𝖾𝗇𝖽_𝗅𝗈𝗐_𝗌_𝗂𝟪𝗑𝟣𝟨	
+|	𝟶𝚡𝙵𝙳  136:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝖾𝗑𝗍𝖾𝗇𝖽_𝗁𝗂𝗀𝗁_𝗌_𝗂𝟪𝗑𝟣𝟨	
+|	𝟶𝚡𝙵𝙳  137:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝖾𝗑𝗍𝖾𝗇𝖽_𝗅𝗈𝗐_𝗎_𝗂𝟪𝗑𝟣𝟨	
+|	𝟶𝚡𝙵𝙳  138:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝖾𝗑𝗍𝖾𝗇𝖽_𝗁𝗂𝗀𝗁_𝗎_𝗂𝟪𝗑𝟣𝟨	
+|	𝟶𝚡𝙵𝙳  139:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗌𝗁𝗅	
+|	𝟶𝚡𝙵𝙳  140:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗌𝗁𝗋_𝗌	
+|	𝟶𝚡𝙵𝙳  141:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗌𝗁𝗋_𝗎	
+|	𝟶𝚡𝙵𝙳  130:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗊𝟣𝟧𝗆𝗎𝗅𝗋_𝗌𝖺𝗍_𝗌	
+|	𝟶𝚡𝙵𝙳  142:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝖺𝖽𝖽	
+|	𝟶𝚡𝙵𝙳  143:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝖺𝖽𝖽_𝗌𝖺𝗍_𝗌	
+|	𝟶𝚡𝙵𝙳  144:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝖺𝖽𝖽_𝗌𝖺𝗍_𝗎	
+|	𝟶𝚡𝙵𝙳  145:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗌𝗎𝖻	
+|	𝟶𝚡𝙵𝙳  146:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗌𝗎𝖻_𝗌𝖺𝗍_𝗌	
+|	𝟶𝚡𝙵𝙳  147:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗌𝗎𝖻_𝗌𝖺𝗍_𝗎	
+|	𝟶𝚡𝙵𝙳  149:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗆𝗎𝗅	
+|	𝟶𝚡𝙵𝙳  150:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗆𝗂𝗇_𝗌	
+|	𝟶𝚡𝙵𝙳  151:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗆𝗂𝗇_𝗎	
+|	𝟶𝚡𝙵𝙳  152:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗆𝖺𝗑_𝗌	
+|	𝟶𝚡𝙵𝙳  153:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗆𝖺𝗑_𝗎	
+|	𝟶𝚡𝙵𝙳  155:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝖺𝗏𝗀𝗋_𝗎	
+|	𝟶𝚡𝙵𝙳  273:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗋𝖾𝗅𝖺𝗑𝖾𝖽_𝗊𝟣𝟧𝗆𝗎𝗅𝗋_𝗌	
+|	𝟶𝚡𝙵𝙳  156:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝖾𝗑𝗍𝗆𝗎𝗅_𝗅𝗈𝗐_𝗌_𝗂𝟪𝗑𝟣𝟨	
+|	𝟶𝚡𝙵𝙳  157:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝖾𝗑𝗍𝗆𝗎𝗅_𝗁𝗂𝗀𝗁_𝗌_𝗂𝟪𝗑𝟣𝟨	
+|	𝟶𝚡𝙵𝙳  158:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝖾𝗑𝗍𝗆𝗎𝗅_𝗅𝗈𝗐_𝗎_𝗂𝟪𝗑𝟣𝟨	
+|	𝟶𝚡𝙵𝙳  159:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝖾𝗑𝗍𝗆𝗎𝗅_𝗁𝗂𝗀𝗁_𝗎_𝗂𝟪𝗑𝟣𝟨	
+|	𝟶𝚡𝙵𝙳  274:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗋𝖾𝗅𝖺𝗑𝖾𝖽_𝖽𝗈𝗍_𝗌_𝗂𝟪𝗑𝟣𝟨	
+ 
+ 
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝙵𝙳  126:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝖾𝗑𝗍𝖺𝖽𝖽_𝗉𝖺𝗂𝗋𝗐𝗂𝗌𝖾_𝗌_𝗂𝟣𝟨𝗑𝟪	
+|	𝟶𝚡𝙵𝙳  127:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝖾𝗑𝗍𝖺𝖽𝖽_𝗉𝖺𝗂𝗋𝗐𝗂𝗌𝖾_𝗎_𝗂𝟣𝟨𝗑𝟪	
+|	𝟶𝚡𝙵𝙳  160:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝖺𝖻𝗌	
+|	𝟶𝚡𝙵𝙳  161:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗇𝖾𝗀	
+|	𝟶𝚡𝙵𝙳  163:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝖺𝗅𝗅_𝗍𝗋𝗎𝖾	
+|	𝟶𝚡𝙵𝙳  164:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝖻𝗂𝗍𝗆𝖺𝗌𝗄	
+|	𝟶𝚡𝙵𝙳  167:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝖾𝗑𝗍𝖾𝗇𝖽_𝗅𝗈𝗐_𝗌_𝗂𝟣𝟨𝗑𝟪	
+|	𝟶𝚡𝙵𝙳  168:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝖾𝗑𝗍𝖾𝗇𝖽_𝗁𝗂𝗀𝗁_𝗌_𝗂𝟣𝟨𝗑𝟪	
+|	𝟶𝚡𝙵𝙳  169:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝖾𝗑𝗍𝖾𝗇𝖽_𝗅𝗈𝗐_𝗎_𝗂𝟣𝟨𝗑𝟪	
+|	𝟶𝚡𝙵𝙳  170:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝖾𝗑𝗍𝖾𝗇𝖽_𝗁𝗂𝗀𝗁_𝗎_𝗂𝟣𝟨𝗑𝟪	
+|	𝟶𝚡𝙵𝙳  171:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗌𝗁𝗅	
+|	𝟶𝚡𝙵𝙳  172:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗌𝗁𝗋_𝗌	
+|	𝟶𝚡𝙵𝙳  173:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗌𝗁𝗋_𝗎	
+|	𝟶𝚡𝙵𝙳  174:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝖺𝖽𝖽	
+|	𝟶𝚡𝙵𝙳  177:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗌𝗎𝖻	
+|	𝟶𝚡𝙵𝙳  181:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗆𝗎𝗅	
+|	𝟶𝚡𝙵𝙳  182:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗆𝗂𝗇_𝗌	
+|	𝟶𝚡𝙵𝙳  183:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗆𝗂𝗇_𝗎	
+|	𝟶𝚡𝙵𝙳  184:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗆𝖺𝗑_𝗌	
+|	𝟶𝚡𝙵𝙳  185:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗆𝖺𝗑_𝗎	
+|	𝟶𝚡𝙵𝙳  186:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝖽𝗈𝗍_𝗌_𝗂𝟣𝟨𝗑𝟪	
+|	𝟶𝚡𝙵𝙳  188:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝖾𝗑𝗍𝗆𝗎𝗅_𝗅𝗈𝗐_𝗌_𝗂𝟣𝟨𝗑𝟪	
+|	𝟶𝚡𝙵𝙳  189:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝖾𝗑𝗍𝗆𝗎𝗅_𝗁𝗂𝗀𝗁_𝗌_𝗂𝟣𝟨𝗑𝟪	
+|	𝟶𝚡𝙵𝙳  190:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝖾𝗑𝗍𝗆𝗎𝗅_𝗅𝗈𝗐_𝗎_𝗂𝟣𝟨𝗑𝟪	
+|	𝟶𝚡𝙵𝙳  191:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝖾𝗑𝗍𝗆𝗎𝗅_𝗁𝗂𝗀𝗁_𝗎_𝗂𝟣𝟨𝗑𝟪	
+|	𝟶𝚡𝙵𝙳  275:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗋𝖾𝗅𝖺𝗑𝖾𝖽_𝖽𝗈𝗍_𝖺𝖽𝖽_𝗌_𝗂𝟣𝟨𝗑𝟪	
+ 
+ 
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝙵𝙳  192:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝖺𝖻𝗌	
+|	𝟶𝚡𝙵𝙳  193:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝗇𝖾𝗀	
+|	𝟶𝚡𝙵𝙳  195:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝖺𝗅𝗅_𝗍𝗋𝗎𝖾	
+|	𝟶𝚡𝙵𝙳  196:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝖻𝗂𝗍𝗆𝖺𝗌𝗄	
+|	𝟶𝚡𝙵𝙳  199:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝖾𝗑𝗍𝖾𝗇𝖽_𝗅𝗈𝗐_𝗌_𝗂𝟥𝟤𝗑𝟦	
+|	𝟶𝚡𝙵𝙳  200:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝖾𝗑𝗍𝖾𝗇𝖽_𝗁𝗂𝗀𝗁_𝗌_𝗂𝟥𝟤𝗑𝟦	
+|	𝟶𝚡𝙵𝙳  201:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝖾𝗑𝗍𝖾𝗇𝖽_𝗅𝗈𝗐_𝗎_𝗂𝟥𝟤𝗑𝟦	
+|	𝟶𝚡𝙵𝙳  202:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝖾𝗑𝗍𝖾𝗇𝖽_𝗁𝗂𝗀𝗁_𝗎_𝗂𝟥𝟤𝗑𝟦	
+|	𝟶𝚡𝙵𝙳  203:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝗌𝗁𝗅	
+|	𝟶𝚡𝙵𝙳  204:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝗌𝗁𝗋_𝗌	
+|	𝟶𝚡𝙵𝙳  205:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝗌𝗁𝗋_𝗎	
+|	𝟶𝚡𝙵𝙳  206:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝖺𝖽𝖽	
+|	𝟶𝚡𝙵𝙳  209:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝗌𝗎𝖻	
+|	𝟶𝚡𝙵𝙳  213:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝗆𝗎𝗅	
+|	𝟶𝚡𝙵𝙳  220:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝖾𝗑𝗍𝗆𝗎𝗅_𝗅𝗈𝗐_𝗌_𝗂𝟥𝟤𝗑𝟦	
+|	𝟶𝚡𝙵𝙳  221:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝖾𝗑𝗍𝗆𝗎𝗅_𝗁𝗂𝗀𝗁_𝗌_𝗂𝟥𝟤𝗑𝟦	
+|	𝟶𝚡𝙵𝙳  222:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝖾𝗑𝗍𝗆𝗎𝗅_𝗅𝗈𝗐_𝗎_𝗂𝟥𝟤𝗑𝟦	
+|	𝟶𝚡𝙵𝙳  223:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝖾𝗑𝗍𝗆𝗎𝗅_𝗁𝗂𝗀𝗁_𝗎_𝗂𝟥𝟤𝗑𝟦	
+ 
+ 
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝙵𝙳  103:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝖼𝖾𝗂𝗅	
+|	𝟶𝚡𝙵𝙳  104:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝖿𝗅𝗈𝗈𝗋	
+|	𝟶𝚡𝙵𝙳  105:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝗍𝗋𝗎𝗇𝖼	
+|	𝟶𝚡𝙵𝙳  106:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝗇𝖾𝖺𝗋𝖾𝗌𝗍	
+|	𝟶𝚡𝙵𝙳  224:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝖺𝖻𝗌	
+|	𝟶𝚡𝙵𝙳  225:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝗇𝖾𝗀	
+|	𝟶𝚡𝙵𝙳  227:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝗌𝗊𝗋𝗍	
+|	𝟶𝚡𝙵𝙳  228:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝖺𝖽𝖽	
+|	𝟶𝚡𝙵𝙳  229:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝗌𝗎𝖻	
+|	𝟶𝚡𝙵𝙳  230:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝗆𝗎𝗅	
+|	𝟶𝚡𝙵𝙳  231:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝖽𝗂𝗏	
+|	𝟶𝚡𝙵𝙳  232:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝗆𝗂𝗇	
+|	𝟶𝚡𝙵𝙳  233:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝗆𝖺𝗑	
+|	𝟶𝚡𝙵𝙳  234:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝗉𝗆𝗂𝗇	
+|	𝟶𝚡𝙵𝙳  235:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝗉𝗆𝖺𝗑	
+|	𝟶𝚡𝙵𝙳  269:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝗋𝖾𝗅𝖺𝗑𝖾𝖽_𝗆𝗂𝗇	
+|	𝟶𝚡𝙵𝙳  270:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝗋𝖾𝗅𝖺𝗑𝖾𝖽_𝗆𝖺𝗑	
+|	𝟶𝚡𝙵𝙳  261:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝗋𝖾𝗅𝖺𝗑𝖾𝖽_𝗆𝖺𝖽𝖽	
+|	𝟶𝚡𝙵𝙳  262:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝗋𝖾𝗅𝖺𝗑𝖾𝖽_𝗇𝗆𝖺𝖽𝖽	
+ 
+ 
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝙵𝙳  116:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝖼𝖾𝗂𝗅	
+|	𝟶𝚡𝙵𝙳  117:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝖿𝗅𝗈𝗈𝗋	
+|	𝟶𝚡𝙵𝙳  122:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝗍𝗋𝗎𝗇𝖼	
+|	𝟶𝚡𝙵𝙳  148:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝗇𝖾𝖺𝗋𝖾𝗌𝗍	
+|	𝟶𝚡𝙵𝙳  236:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝖺𝖻𝗌	
+|	𝟶𝚡𝙵𝙳  237:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝗇𝖾𝗀	
+|	𝟶𝚡𝙵𝙳  239:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝗌𝗊𝗋𝗍	
+|	𝟶𝚡𝙵𝙳  240:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝖺𝖽𝖽	
+|	𝟶𝚡𝙵𝙳  241:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝗌𝗎𝖻	
+|	𝟶𝚡𝙵𝙳  242:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝗆𝗎𝗅	
+|	𝟶𝚡𝙵𝙳  243:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝖽𝗂𝗏	
+|	𝟶𝚡𝙵𝙳  244:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝗆𝗂𝗇	
+|	𝟶𝚡𝙵𝙳  245:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝗆𝖺𝗑	
+|	𝟶𝚡𝙵𝙳  246:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝗉𝗆𝗂𝗇	
+|	𝟶𝚡𝙵𝙳  247:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝗉𝗆𝖺𝗑	
+|	𝟶𝚡𝙵𝙳  271:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝗋𝖾𝗅𝖺𝗑𝖾𝖽_𝗆𝗂𝗇	
+|	𝟶𝚡𝙵𝙳  272:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝗋𝖾𝗅𝖺𝗑𝖾𝖽_𝗆𝖺𝗑	
+|	𝟶𝚡𝙵𝙳  263:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝗋𝖾𝗅𝖺𝗑𝖾𝖽_𝗆𝖺𝖽𝖽	
+|	𝟶𝚡𝙵𝙳  264:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝗋𝖾𝗅𝖺𝗑𝖾𝖽_𝗇𝗆𝖺𝖽𝖽	
+|	𝟶𝚡𝙵𝙳  265:𝚞𝟹𝟸		⇒		𝗂𝟪𝗑𝟣𝟨.𝗋𝖾𝗅𝖺𝗑𝖾𝖽_𝗅𝖺𝗇𝖾𝗌𝖾𝗅𝖾𝖼𝗍	
+|	𝟶𝚡𝙵𝙳  266:𝚞𝟹𝟸		⇒		𝗂𝟣𝟨𝗑𝟪.𝗋𝖾𝗅𝖺𝗑𝖾𝖽_𝗅𝖺𝗇𝖾𝗌𝖾𝗅𝖾𝖼𝗍	
+|	𝟶𝚡𝙵𝙳  267:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗋𝖾𝗅𝖺𝗑𝖾𝖽_𝗅𝖺𝗇𝖾𝗌𝖾𝗅𝖾𝖼𝗍	
+|	𝟶𝚡𝙵𝙳  268:𝚞𝟹𝟸		⇒		𝗂𝟨𝟦𝗑𝟤.𝗋𝖾𝗅𝖺𝗑𝖾𝖽_𝗅𝖺𝗇𝖾𝗌𝖾𝗅𝖾𝖼𝗍	
+ 
+ 
+𝚒𝚗𝚜𝚝𝚛	::=	…					
+|	𝟶𝚡𝙵𝙳  94:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝖽𝖾𝗆𝗈𝗍𝖾_𝗓𝖾𝗋𝗈_𝖿𝟨𝟦𝗑𝟤	
+|	𝟶𝚡𝙵𝙳  95:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝗉𝗋𝗈𝗆𝗈𝗍𝖾_𝗅𝗈𝗐_𝖿𝟥𝟤𝗑𝟦	
+|	𝟶𝚡𝙵𝙳  248:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗍𝗋𝗎𝗇𝖼_𝗌𝖺𝗍_𝗌_𝖿𝟥𝟤𝗑𝟦	
+|	𝟶𝚡𝙵𝙳  249:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗍𝗋𝗎𝗇𝖼_𝗌𝖺𝗍_𝗎_𝖿𝟥𝟤𝗑𝟦	
+|	𝟶𝚡𝙵𝙳  250:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝖼𝗈𝗇𝗏𝖾𝗋𝗍_𝗌_𝗂𝟥𝟤𝗑𝟦	
+|	𝟶𝚡𝙵𝙳  251:𝚞𝟹𝟸		⇒		𝖿𝟥𝟤𝗑𝟦.𝖼𝗈𝗇𝗏𝖾𝗋𝗍_𝗎_𝗂𝟥𝟤𝗑𝟦	
+|	𝟶𝚡𝙵𝙳  252:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗍𝗋𝗎𝗇𝖼_𝗌𝖺𝗍_𝗌_𝗓𝖾𝗋𝗈_𝖿𝟨𝟦𝗑𝟤	
+|	𝟶𝚡𝙵𝙳  253:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗍𝗋𝗎𝗇𝖼_𝗌𝖺𝗍_𝗎_𝗓𝖾𝗋𝗈_𝖿𝟨𝟦𝗑𝟤	
+|	𝟶𝚡𝙵𝙳  254:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝖼𝗈𝗇𝗏𝖾𝗋𝗍_𝗅𝗈𝗐_𝗌_𝗂𝟥𝟤𝗑𝟦	
+|	𝟶𝚡𝙵𝙳  255:𝚞𝟹𝟸		⇒		𝖿𝟨𝟦𝗑𝟤.𝖼𝗈𝗇𝗏𝖾𝗋𝗍_𝗅𝗈𝗐_𝗎_𝗂𝟥𝟤𝗑𝟦	
+|	𝟶𝚡𝙵𝙳  257:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗋𝖾𝗅𝖺𝗑𝖾𝖽_𝗍𝗋𝗎𝗇𝖼_𝗌_𝖿𝟥𝟤𝗑𝟦	
+|	𝟶𝚡𝙵𝙳  258:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗋𝖾𝗅𝖺𝗑𝖾𝖽_𝗍𝗋𝗎𝗇𝖼_𝗎_𝖿𝟥𝟤𝗑𝟦	
+|	𝟶𝚡𝙵𝙳  259:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗋𝖾𝗅𝖺𝗑𝖾𝖽_𝗍𝗋𝗎𝗇𝖼_𝗌_𝗓𝖾𝗋𝗈_𝖿𝟨𝟦𝗑𝟤	
+|	𝟶𝚡𝙵𝙳  260:𝚞𝟹𝟸		⇒		𝗂𝟥𝟤𝗑𝟦.𝗋𝖾𝗅𝖺𝗑𝖾𝖽_𝗍𝗋𝗎𝗇𝖼_𝗎_𝗓𝖾𝗋𝗈_𝖿𝟨𝟦𝗑𝟤	
+ 
+ 
+Expressions
+Expressions are encoded by their instruction sequence terminated with an explicit 𝟶𝚡𝟶𝙱 opcode for 𝖾𝗇𝖽.
+
+𝚎𝚡𝚙𝚛	::=	(in:𝚒𝚗𝚜𝚝𝚛)∗  𝟶𝚡𝟶𝙱		⇒		in∗	
+ 
+ 
+©2017-2025, WebAssembly Community Group.